ThingIndexingConfiguration.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/iot/IoT_EXPORTS.h>
#include <aws/iot/model/DeviceDefenderIndexingMode.h>
#include <aws/iot/model/Field.h>
#include <aws/iot/model/IndexingFilter.h>
#include <aws/iot/model/NamedShadowIndexingMode.h>
#include <aws/iot/model/ThingConnectivityIndexingMode.h>
#include <aws/iot/model/ThingIndexingMode.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace IoT {
namespace Model {
 
class ThingIndexingConfiguration {
 public:
  AWS_IOT_API ThingIndexingConfiguration() = default;
  AWS_IOT_API ThingIndexingConfiguration(Aws::Utils::Json::JsonView jsonValue);
  AWS_IOT_API ThingIndexingConfiguration& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_IOT_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline ThingIndexingMode GetThingIndexingMode() const { return m_thingIndexingMode; }
  inline bool ThingIndexingModeHasBeenSet() const { return m_thingIndexingModeHasBeenSet; }
  inline void SetThingIndexingMode(ThingIndexingMode value) {
    m_thingIndexingModeHasBeenSet = true;
    m_thingIndexingMode = value;
  }
  inline ThingIndexingConfiguration& WithThingIndexingMode(ThingIndexingMode value) {
    SetThingIndexingMode(value);
    return *this;
  }
 
 
  inline ThingConnectivityIndexingMode GetThingConnectivityIndexingMode() const { return m_thingConnectivityIndexingMode; }
  inline bool ThingConnectivityIndexingModeHasBeenSet() const { return m_thingConnectivityIndexingModeHasBeenSet; }
  inline void SetThingConnectivityIndexingMode(ThingConnectivityIndexingMode value) {
    m_thingConnectivityIndexingModeHasBeenSet = true;
    m_thingConnectivityIndexingMode = value;
  }
  inline ThingIndexingConfiguration& WithThingConnectivityIndexingMode(ThingConnectivityIndexingMode value) {
    SetThingConnectivityIndexingMode(value);
    return *this;
  }
 
 
  inline DeviceDefenderIndexingMode GetDeviceDefenderIndexingMode() const { return m_deviceDefenderIndexingMode; }
  inline bool DeviceDefenderIndexingModeHasBeenSet() const { return m_deviceDefenderIndexingModeHasBeenSet; }
  inline void SetDeviceDefenderIndexingMode(DeviceDefenderIndexingMode value) {
    m_deviceDefenderIndexingModeHasBeenSet = true;
    m_deviceDefenderIndexingMode = value;
  }
  inline ThingIndexingConfiguration& WithDeviceDefenderIndexingMode(DeviceDefenderIndexingMode value) {
    SetDeviceDefenderIndexingMode(value);
    return *this;
  }
 
 
  inline NamedShadowIndexingMode GetNamedShadowIndexingMode() const { return m_namedShadowIndexingMode; }
  inline bool NamedShadowIndexingModeHasBeenSet() const { return m_namedShadowIndexingModeHasBeenSet; }
  inline void SetNamedShadowIndexingMode(NamedShadowIndexingMode value) {
    m_namedShadowIndexingModeHasBeenSet = true;
    m_namedShadowIndexingMode = value;
  }
  inline ThingIndexingConfiguration& WithNamedShadowIndexingMode(NamedShadowIndexingMode value) {
    SetNamedShadowIndexingMode(value);
    return *this;
  }
 
 
  inline const Aws::Vector<Field>& GetManagedFields() const { return m_managedFields; }
  inline bool ManagedFieldsHasBeenSet() const { return m_managedFieldsHasBeenSet; }
  template <typename ManagedFieldsT = Aws::Vector<Field>>
  void SetManagedFields(ManagedFieldsT&& value) {
    m_managedFieldsHasBeenSet = true;
    m_managedFields = std::forward<ManagedFieldsT>(value);
  }
  template <typename ManagedFieldsT = Aws::Vector<Field>>
  ThingIndexingConfiguration& WithManagedFields(ManagedFieldsT&& value) {
    SetManagedFields(std::forward<ManagedFieldsT>(value));
    return *this;
  }
  template <typename ManagedFieldsT = Field>
  ThingIndexingConfiguration& AddManagedFields(ManagedFieldsT&& value) {
    m_managedFieldsHasBeenSet = true;
    m_managedFields.emplace_back(std::forward<ManagedFieldsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Field>& GetCustomFields() const { return m_customFields; }
  inline bool CustomFieldsHasBeenSet() const { return m_customFieldsHasBeenSet; }
  template <typename CustomFieldsT = Aws::Vector<Field>>
  void SetCustomFields(CustomFieldsT&& value) {
    m_customFieldsHasBeenSet = true;
    m_customFields = std::forward<CustomFieldsT>(value);
  }
  template <typename CustomFieldsT = Aws::Vector<Field>>
  ThingIndexingConfiguration& WithCustomFields(CustomFieldsT&& value) {
    SetCustomFields(std::forward<CustomFieldsT>(value));
    return *this;
  }
  template <typename CustomFieldsT = Field>
  ThingIndexingConfiguration& AddCustomFields(CustomFieldsT&& value) {
    m_customFieldsHasBeenSet = true;
    m_customFields.emplace_back(std::forward<CustomFieldsT>(value));
    return *this;
  }
 
 
  inline const IndexingFilter& GetFilter() const { return m_filter; }
  inline bool FilterHasBeenSet() const { return m_filterHasBeenSet; }
  template <typename FilterT = IndexingFilter>
  void SetFilter(FilterT&& value) {
    m_filterHasBeenSet = true;
    m_filter = std::forward<FilterT>(value);
  }
  template <typename FilterT = IndexingFilter>
  ThingIndexingConfiguration& WithFilter(FilterT&& value) {
    SetFilter(std::forward<FilterT>(value));
    return *this;
  }
 private:
  ThingIndexingMode m_thingIndexingMode{ThingIndexingMode::NOT_SET};
 
  ThingConnectivityIndexingMode m_thingConnectivityIndexingMode{ThingConnectivityIndexingMode::NOT_SET};
 
  DeviceDefenderIndexingMode m_deviceDefenderIndexingMode{DeviceDefenderIndexingMode::NOT_SET};
 
  NamedShadowIndexingMode m_namedShadowIndexingMode{NamedShadowIndexingMode::NOT_SET};
 
  Aws::Vector<Field> m_managedFields;
 
  Aws::Vector<Field> m_customFields;
 
  IndexingFilter m_filter;
  bool m_thingIndexingModeHasBeenSet = false;
  bool m_thingConnectivityIndexingModeHasBeenSet = false;
  bool m_deviceDefenderIndexingModeHasBeenSet = false;
  bool m_namedShadowIndexingModeHasBeenSet = false;
  bool m_managedFieldsHasBeenSet = false;
  bool m_customFieldsHasBeenSet = false;
  bool m_filterHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace IoT
}  // namespace Aws