Field.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSMap.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/glue/Glue_EXPORTS.h>
#include <aws/glue/model/FieldDataType.h>
#include <aws/glue/model/FieldFilterOperator.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace Glue {
namespace Model {
 
class Field {
 public:
  AWS_GLUE_API Field() = default;
  AWS_GLUE_API Field(Aws::Utils::Json::JsonView jsonValue);
  AWS_GLUE_API Field& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_GLUE_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetFieldName() const { return m_fieldName; }
  inline bool FieldNameHasBeenSet() const { return m_fieldNameHasBeenSet; }
  template <typename FieldNameT = Aws::String>
  void SetFieldName(FieldNameT&& value) {
    m_fieldNameHasBeenSet = true;
    m_fieldName = std::forward<FieldNameT>(value);
  }
  template <typename FieldNameT = Aws::String>
  Field& WithFieldName(FieldNameT&& value) {
    SetFieldName(std::forward<FieldNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetLabel() const { return m_label; }
  inline bool LabelHasBeenSet() const { return m_labelHasBeenSet; }
  template <typename LabelT = Aws::String>
  void SetLabel(LabelT&& value) {
    m_labelHasBeenSet = true;
    m_label = std::forward<LabelT>(value);
  }
  template <typename LabelT = Aws::String>
  Field& WithLabel(LabelT&& value) {
    SetLabel(std::forward<LabelT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetDescription() const { return m_description; }
  inline bool DescriptionHasBeenSet() const { return m_descriptionHasBeenSet; }
  template <typename DescriptionT = Aws::String>
  void SetDescription(DescriptionT&& value) {
    m_descriptionHasBeenSet = true;
    m_description = std::forward<DescriptionT>(value);
  }
  template <typename DescriptionT = Aws::String>
  Field& WithDescription(DescriptionT&& value) {
    SetDescription(std::forward<DescriptionT>(value));
    return *this;
  }
 
 
  inline FieldDataType GetFieldType() const { return m_fieldType; }
  inline bool FieldTypeHasBeenSet() const { return m_fieldTypeHasBeenSet; }
  inline void SetFieldType(FieldDataType value) {
    m_fieldTypeHasBeenSet = true;
    m_fieldType = value;
  }
  inline Field& WithFieldType(FieldDataType value) {
    SetFieldType(value);
    return *this;
  }
 
 
  inline bool GetIsPrimaryKey() const { return m_isPrimaryKey; }
  inline bool IsPrimaryKeyHasBeenSet() const { return m_isPrimaryKeyHasBeenSet; }
  inline void SetIsPrimaryKey(bool value) {
    m_isPrimaryKeyHasBeenSet = true;
    m_isPrimaryKey = value;
  }
  inline Field& WithIsPrimaryKey(bool value) {
    SetIsPrimaryKey(value);
    return *this;
  }
 
 
  inline bool GetIsNullable() const { return m_isNullable; }
  inline bool IsNullableHasBeenSet() const { return m_isNullableHasBeenSet; }
  inline void SetIsNullable(bool value) {
    m_isNullableHasBeenSet = true;
    m_isNullable = value;
  }
  inline Field& WithIsNullable(bool value) {
    SetIsNullable(value);
    return *this;
  }
 
 
  inline bool GetIsRetrievable() const { return m_isRetrievable; }
  inline bool IsRetrievableHasBeenSet() const { return m_isRetrievableHasBeenSet; }
  inline void SetIsRetrievable(bool value) {
    m_isRetrievableHasBeenSet = true;
    m_isRetrievable = value;
  }
  inline Field& WithIsRetrievable(bool value) {
    SetIsRetrievable(value);
    return *this;
  }
 
 
  inline bool GetIsFilterable() const { return m_isFilterable; }
  inline bool IsFilterableHasBeenSet() const { return m_isFilterableHasBeenSet; }
  inline void SetIsFilterable(bool value) {
    m_isFilterableHasBeenSet = true;
    m_isFilterable = value;
  }
  inline Field& WithIsFilterable(bool value) {
    SetIsFilterable(value);
    return *this;
  }
 
 
  inline bool GetIsPartitionable() const { return m_isPartitionable; }
  inline bool IsPartitionableHasBeenSet() const { return m_isPartitionableHasBeenSet; }
  inline void SetIsPartitionable(bool value) {
    m_isPartitionableHasBeenSet = true;
    m_isPartitionable = value;
  }
  inline Field& WithIsPartitionable(bool value) {
    SetIsPartitionable(value);
    return *this;
  }
 
 
  inline bool GetIsCreateable() const { return m_isCreateable; }
  inline bool IsCreateableHasBeenSet() const { return m_isCreateableHasBeenSet; }
  inline void SetIsCreateable(bool value) {
    m_isCreateableHasBeenSet = true;
    m_isCreateable = value;
  }
  inline Field& WithIsCreateable(bool value) {
    SetIsCreateable(value);
    return *this;
  }
 
 
  inline bool GetIsUpdateable() const { return m_isUpdateable; }
  inline bool IsUpdateableHasBeenSet() const { return m_isUpdateableHasBeenSet; }
  inline void SetIsUpdateable(bool value) {
    m_isUpdateableHasBeenSet = true;
    m_isUpdateable = value;
  }
  inline Field& WithIsUpdateable(bool value) {
    SetIsUpdateable(value);
    return *this;
  }
 
 
  inline bool GetIsUpsertable() const { return m_isUpsertable; }
  inline bool IsUpsertableHasBeenSet() const { return m_isUpsertableHasBeenSet; }
  inline void SetIsUpsertable(bool value) {
    m_isUpsertableHasBeenSet = true;
    m_isUpsertable = value;
  }
  inline Field& WithIsUpsertable(bool value) {
    SetIsUpsertable(value);
    return *this;
  }
 
 
  inline bool GetIsDefaultOnCreate() const { return m_isDefaultOnCreate; }
  inline bool IsDefaultOnCreateHasBeenSet() const { return m_isDefaultOnCreateHasBeenSet; }
  inline void SetIsDefaultOnCreate(bool value) {
    m_isDefaultOnCreateHasBeenSet = true;
    m_isDefaultOnCreate = value;
  }
  inline Field& WithIsDefaultOnCreate(bool value) {
    SetIsDefaultOnCreate(value);
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetSupportedValues() const { return m_supportedValues; }
  inline bool SupportedValuesHasBeenSet() const { return m_supportedValuesHasBeenSet; }
  template <typename SupportedValuesT = Aws::Vector<Aws::String>>
  void SetSupportedValues(SupportedValuesT&& value) {
    m_supportedValuesHasBeenSet = true;
    m_supportedValues = std::forward<SupportedValuesT>(value);
  }
  template <typename SupportedValuesT = Aws::Vector<Aws::String>>
  Field& WithSupportedValues(SupportedValuesT&& value) {
    SetSupportedValues(std::forward<SupportedValuesT>(value));
    return *this;
  }
  template <typename SupportedValuesT = Aws::String>
  Field& AddSupportedValues(SupportedValuesT&& value) {
    m_supportedValuesHasBeenSet = true;
    m_supportedValues.emplace_back(std::forward<SupportedValuesT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<FieldFilterOperator>& GetSupportedFilterOperators() const { return m_supportedFilterOperators; }
  inline bool SupportedFilterOperatorsHasBeenSet() const { return m_supportedFilterOperatorsHasBeenSet; }
  template <typename SupportedFilterOperatorsT = Aws::Vector<FieldFilterOperator>>
  void SetSupportedFilterOperators(SupportedFilterOperatorsT&& value) {
    m_supportedFilterOperatorsHasBeenSet = true;
    m_supportedFilterOperators = std::forward<SupportedFilterOperatorsT>(value);
  }
  template <typename SupportedFilterOperatorsT = Aws::Vector<FieldFilterOperator>>
  Field& WithSupportedFilterOperators(SupportedFilterOperatorsT&& value) {
    SetSupportedFilterOperators(std::forward<SupportedFilterOperatorsT>(value));
    return *this;
  }
  inline Field& AddSupportedFilterOperators(FieldFilterOperator value) {
    m_supportedFilterOperatorsHasBeenSet = true;
    m_supportedFilterOperators.push_back(value);
    return *this;
  }
 
 
  inline const Aws::String& GetParentField() const { return m_parentField; }
  inline bool ParentFieldHasBeenSet() const { return m_parentFieldHasBeenSet; }
  template <typename ParentFieldT = Aws::String>
  void SetParentField(ParentFieldT&& value) {
    m_parentFieldHasBeenSet = true;
    m_parentField = std::forward<ParentFieldT>(value);
  }
  template <typename ParentFieldT = Aws::String>
  Field& WithParentField(ParentFieldT&& value) {
    SetParentField(std::forward<ParentFieldT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetNativeDataType() const { return m_nativeDataType; }
  inline bool NativeDataTypeHasBeenSet() const { return m_nativeDataTypeHasBeenSet; }
  template <typename NativeDataTypeT = Aws::String>
  void SetNativeDataType(NativeDataTypeT&& value) {
    m_nativeDataTypeHasBeenSet = true;
    m_nativeDataType = std::forward<NativeDataTypeT>(value);
  }
  template <typename NativeDataTypeT = Aws::String>
  Field& WithNativeDataType(NativeDataTypeT&& value) {
    SetNativeDataType(std::forward<NativeDataTypeT>(value));
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, Aws::String>& GetCustomProperties() const { return m_customProperties; }
  inline bool CustomPropertiesHasBeenSet() const { return m_customPropertiesHasBeenSet; }
  template <typename CustomPropertiesT = Aws::Map<Aws::String, Aws::String>>
  void SetCustomProperties(CustomPropertiesT&& value) {
    m_customPropertiesHasBeenSet = true;
    m_customProperties = std::forward<CustomPropertiesT>(value);
  }
  template <typename CustomPropertiesT = Aws::Map<Aws::String, Aws::String>>
  Field& WithCustomProperties(CustomPropertiesT&& value) {
    SetCustomProperties(std::forward<CustomPropertiesT>(value));
    return *this;
  }
  template <typename CustomPropertiesKeyT = Aws::String, typename CustomPropertiesValueT = Aws::String>
  Field& AddCustomProperties(CustomPropertiesKeyT&& key, CustomPropertiesValueT&& value) {
    m_customPropertiesHasBeenSet = true;
    m_customProperties.emplace(std::forward<CustomPropertiesKeyT>(key), std::forward<CustomPropertiesValueT>(value));
    return *this;
  }
 private:
  Aws::String m_fieldName;
 
  Aws::String m_label;
 
  Aws::String m_description;
 
  FieldDataType m_fieldType{FieldDataType::NOT_SET};
 
  bool m_isPrimaryKey{false};
 
  bool m_isNullable{false};
 
  bool m_isRetrievable{false};
 
  bool m_isFilterable{false};
 
  bool m_isPartitionable{false};
 
  bool m_isCreateable{false};
 
  bool m_isUpdateable{false};
 
  bool m_isUpsertable{false};
 
  bool m_isDefaultOnCreate{false};
 
  Aws::Vector<Aws::String> m_supportedValues;
 
  Aws::Vector<FieldFilterOperator> m_supportedFilterOperators;
 
  Aws::String m_parentField;
 
  Aws::String m_nativeDataType;
 
  Aws::Map<Aws::String, Aws::String> m_customProperties;
  bool m_fieldNameHasBeenSet = false;
  bool m_labelHasBeenSet = false;
  bool m_descriptionHasBeenSet = false;
  bool m_fieldTypeHasBeenSet = false;
  bool m_isPrimaryKeyHasBeenSet = false;
  bool m_isNullableHasBeenSet = false;
  bool m_isRetrievableHasBeenSet = false;
  bool m_isFilterableHasBeenSet = false;
  bool m_isPartitionableHasBeenSet = false;
  bool m_isCreateableHasBeenSet = false;
  bool m_isUpdateableHasBeenSet = false;
  bool m_isUpsertableHasBeenSet = false;
  bool m_isDefaultOnCreateHasBeenSet = false;
  bool m_supportedValuesHasBeenSet = false;
  bool m_supportedFilterOperatorsHasBeenSet = false;
  bool m_parentFieldHasBeenSet = false;
  bool m_nativeDataTypeHasBeenSet = false;
  bool m_customPropertiesHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Glue
}  // namespace Aws