IndexField.h

 
#pragma once
#include <aws/cloudsearch/CloudSearch_EXPORTS.h>
#include <aws/cloudsearch/model/DateArrayOptions.h>
#include <aws/cloudsearch/model/DateOptions.h>
#include <aws/cloudsearch/model/DoubleArrayOptions.h>
#include <aws/cloudsearch/model/DoubleOptions.h>
#include <aws/cloudsearch/model/IndexFieldType.h>
#include <aws/cloudsearch/model/IntArrayOptions.h>
#include <aws/cloudsearch/model/IntOptions.h>
#include <aws/cloudsearch/model/LatLonOptions.h>
#include <aws/cloudsearch/model/LiteralArrayOptions.h>
#include <aws/cloudsearch/model/LiteralOptions.h>
#include <aws/cloudsearch/model/TextArrayOptions.h>
#include <aws/cloudsearch/model/TextOptions.h>
#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
#include <aws/core/utils/memory/stl/AWSString.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Xml {
class XmlNode;
}  // namespace Xml
}  // namespace Utils
namespace CloudSearch {
namespace Model {
 
class IndexField {
 public:
  AWS_CLOUDSEARCH_API IndexField() = default;
  AWS_CLOUDSEARCH_API IndexField(const Aws::Utils::Xml::XmlNode& xmlNode);
  AWS_CLOUDSEARCH_API IndexField& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
 
  AWS_CLOUDSEARCH_API void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
  AWS_CLOUDSEARCH_API void OutputToStream(Aws::OStream& oStream, const char* location) const;
 
 
  inline const Aws::String& GetIndexFieldName() const { return m_indexFieldName; }
  inline bool IndexFieldNameHasBeenSet() const { return m_indexFieldNameHasBeenSet; }
  template <typename IndexFieldNameT = Aws::String>
  void SetIndexFieldName(IndexFieldNameT&& value) {
    m_indexFieldNameHasBeenSet = true;
    m_indexFieldName = std::forward<IndexFieldNameT>(value);
  }
  template <typename IndexFieldNameT = Aws::String>
  IndexField& WithIndexFieldName(IndexFieldNameT&& value) {
    SetIndexFieldName(std::forward<IndexFieldNameT>(value));
    return *this;
  }
 
 
  inline IndexFieldType GetIndexFieldType() const { return m_indexFieldType; }
  inline bool IndexFieldTypeHasBeenSet() const { return m_indexFieldTypeHasBeenSet; }
  inline void SetIndexFieldType(IndexFieldType value) {
    m_indexFieldTypeHasBeenSet = true;
    m_indexFieldType = value;
  }
  inline IndexField& WithIndexFieldType(IndexFieldType value) {
    SetIndexFieldType(value);
    return *this;
  }
 
 
  inline const IntOptions& GetIntOptions() const { return m_intOptions; }
  inline bool IntOptionsHasBeenSet() const { return m_intOptionsHasBeenSet; }
  template <typename IntOptionsT = IntOptions>
  void SetIntOptions(IntOptionsT&& value) {
    m_intOptionsHasBeenSet = true;
    m_intOptions = std::forward<IntOptionsT>(value);
  }
  template <typename IntOptionsT = IntOptions>
  IndexField& WithIntOptions(IntOptionsT&& value) {
    SetIntOptions(std::forward<IntOptionsT>(value));
    return *this;
  }
 
 
  inline const DoubleOptions& GetDoubleOptions() const { return m_doubleOptions; }
  inline bool DoubleOptionsHasBeenSet() const { return m_doubleOptionsHasBeenSet; }
  template <typename DoubleOptionsT = DoubleOptions>
  void SetDoubleOptions(DoubleOptionsT&& value) {
    m_doubleOptionsHasBeenSet = true;
    m_doubleOptions = std::forward<DoubleOptionsT>(value);
  }
  template <typename DoubleOptionsT = DoubleOptions>
  IndexField& WithDoubleOptions(DoubleOptionsT&& value) {
    SetDoubleOptions(std::forward<DoubleOptionsT>(value));
    return *this;
  }
 
 
  inline const LiteralOptions& GetLiteralOptions() const { return m_literalOptions; }
  inline bool LiteralOptionsHasBeenSet() const { return m_literalOptionsHasBeenSet; }
  template <typename LiteralOptionsT = LiteralOptions>
  void SetLiteralOptions(LiteralOptionsT&& value) {
    m_literalOptionsHasBeenSet = true;
    m_literalOptions = std::forward<LiteralOptionsT>(value);
  }
  template <typename LiteralOptionsT = LiteralOptions>
  IndexField& WithLiteralOptions(LiteralOptionsT&& value) {
    SetLiteralOptions(std::forward<LiteralOptionsT>(value));
    return *this;
  }
 
 
  inline const TextOptions& GetTextOptions() const { return m_textOptions; }
  inline bool TextOptionsHasBeenSet() const { return m_textOptionsHasBeenSet; }
  template <typename TextOptionsT = TextOptions>
  void SetTextOptions(TextOptionsT&& value) {
    m_textOptionsHasBeenSet = true;
    m_textOptions = std::forward<TextOptionsT>(value);
  }
  template <typename TextOptionsT = TextOptions>
  IndexField& WithTextOptions(TextOptionsT&& value) {
    SetTextOptions(std::forward<TextOptionsT>(value));
    return *this;
  }
 
 
  inline const DateOptions& GetDateOptions() const { return m_dateOptions; }
  inline bool DateOptionsHasBeenSet() const { return m_dateOptionsHasBeenSet; }
  template <typename DateOptionsT = DateOptions>
  void SetDateOptions(DateOptionsT&& value) {
    m_dateOptionsHasBeenSet = true;
    m_dateOptions = std::forward<DateOptionsT>(value);
  }
  template <typename DateOptionsT = DateOptions>
  IndexField& WithDateOptions(DateOptionsT&& value) {
    SetDateOptions(std::forward<DateOptionsT>(value));
    return *this;
  }
 
 
  inline const LatLonOptions& GetLatLonOptions() const { return m_latLonOptions; }
  inline bool LatLonOptionsHasBeenSet() const { return m_latLonOptionsHasBeenSet; }
  template <typename LatLonOptionsT = LatLonOptions>
  void SetLatLonOptions(LatLonOptionsT&& value) {
    m_latLonOptionsHasBeenSet = true;
    m_latLonOptions = std::forward<LatLonOptionsT>(value);
  }
  template <typename LatLonOptionsT = LatLonOptions>
  IndexField& WithLatLonOptions(LatLonOptionsT&& value) {
    SetLatLonOptions(std::forward<LatLonOptionsT>(value));
    return *this;
  }
 
 
  inline const IntArrayOptions& GetIntArrayOptions() const { return m_intArrayOptions; }
  inline bool IntArrayOptionsHasBeenSet() const { return m_intArrayOptionsHasBeenSet; }
  template <typename IntArrayOptionsT = IntArrayOptions>
  void SetIntArrayOptions(IntArrayOptionsT&& value) {
    m_intArrayOptionsHasBeenSet = true;
    m_intArrayOptions = std::forward<IntArrayOptionsT>(value);
  }
  template <typename IntArrayOptionsT = IntArrayOptions>
  IndexField& WithIntArrayOptions(IntArrayOptionsT&& value) {
    SetIntArrayOptions(std::forward<IntArrayOptionsT>(value));
    return *this;
  }
 
 
  inline const DoubleArrayOptions& GetDoubleArrayOptions() const { return m_doubleArrayOptions; }
  inline bool DoubleArrayOptionsHasBeenSet() const { return m_doubleArrayOptionsHasBeenSet; }
  template <typename DoubleArrayOptionsT = DoubleArrayOptions>
  void SetDoubleArrayOptions(DoubleArrayOptionsT&& value) {
    m_doubleArrayOptionsHasBeenSet = true;
    m_doubleArrayOptions = std::forward<DoubleArrayOptionsT>(value);
  }
  template <typename DoubleArrayOptionsT = DoubleArrayOptions>
  IndexField& WithDoubleArrayOptions(DoubleArrayOptionsT&& value) {
    SetDoubleArrayOptions(std::forward<DoubleArrayOptionsT>(value));
    return *this;
  }
 
 
  inline const LiteralArrayOptions& GetLiteralArrayOptions() const { return m_literalArrayOptions; }
  inline bool LiteralArrayOptionsHasBeenSet() const { return m_literalArrayOptionsHasBeenSet; }
  template <typename LiteralArrayOptionsT = LiteralArrayOptions>
  void SetLiteralArrayOptions(LiteralArrayOptionsT&& value) {
    m_literalArrayOptionsHasBeenSet = true;
    m_literalArrayOptions = std::forward<LiteralArrayOptionsT>(value);
  }
  template <typename LiteralArrayOptionsT = LiteralArrayOptions>
  IndexField& WithLiteralArrayOptions(LiteralArrayOptionsT&& value) {
    SetLiteralArrayOptions(std::forward<LiteralArrayOptionsT>(value));
    return *this;
  }
 
 
  inline const TextArrayOptions& GetTextArrayOptions() const { return m_textArrayOptions; }
  inline bool TextArrayOptionsHasBeenSet() const { return m_textArrayOptionsHasBeenSet; }
  template <typename TextArrayOptionsT = TextArrayOptions>
  void SetTextArrayOptions(TextArrayOptionsT&& value) {
    m_textArrayOptionsHasBeenSet = true;
    m_textArrayOptions = std::forward<TextArrayOptionsT>(value);
  }
  template <typename TextArrayOptionsT = TextArrayOptions>
  IndexField& WithTextArrayOptions(TextArrayOptionsT&& value) {
    SetTextArrayOptions(std::forward<TextArrayOptionsT>(value));
    return *this;
  }
 
 
  inline const DateArrayOptions& GetDateArrayOptions() const { return m_dateArrayOptions; }
  inline bool DateArrayOptionsHasBeenSet() const { return m_dateArrayOptionsHasBeenSet; }
  template <typename DateArrayOptionsT = DateArrayOptions>
  void SetDateArrayOptions(DateArrayOptionsT&& value) {
    m_dateArrayOptionsHasBeenSet = true;
    m_dateArrayOptions = std::forward<DateArrayOptionsT>(value);
  }
  template <typename DateArrayOptionsT = DateArrayOptions>
  IndexField& WithDateArrayOptions(DateArrayOptionsT&& value) {
    SetDateArrayOptions(std::forward<DateArrayOptionsT>(value));
    return *this;
  }
 private:
  Aws::String m_indexFieldName;
 
  IndexFieldType m_indexFieldType{IndexFieldType::NOT_SET};
 
  IntOptions m_intOptions;
 
  DoubleOptions m_doubleOptions;
 
  LiteralOptions m_literalOptions;
 
  TextOptions m_textOptions;
 
  DateOptions m_dateOptions;
 
  LatLonOptions m_latLonOptions;
 
  IntArrayOptions m_intArrayOptions;
 
  DoubleArrayOptions m_doubleArrayOptions;
 
  LiteralArrayOptions m_literalArrayOptions;
 
  TextArrayOptions m_textArrayOptions;
 
  DateArrayOptions m_dateArrayOptions;
  bool m_indexFieldNameHasBeenSet = false;
  bool m_indexFieldTypeHasBeenSet = false;
  bool m_intOptionsHasBeenSet = false;
  bool m_doubleOptionsHasBeenSet = false;
  bool m_literalOptionsHasBeenSet = false;
  bool m_textOptionsHasBeenSet = false;
  bool m_dateOptionsHasBeenSet = false;
  bool m_latLonOptionsHasBeenSet = false;
  bool m_intArrayOptionsHasBeenSet = false;
  bool m_doubleArrayOptionsHasBeenSet = false;
  bool m_literalArrayOptionsHasBeenSet = false;
  bool m_textArrayOptionsHasBeenSet = false;
  bool m_dateArrayOptionsHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace CloudSearch
}  // namespace Aws