ThingIndexingConfiguration.h

 
#pragma once
#include <aws/iot/IoT_EXPORTS.h>
#include <aws/iot/model/ThingIndexingMode.h>
#include <aws/iot/model/ThingConnectivityIndexingMode.h>
#include <aws/iot/model/DeviceDefenderIndexingMode.h>
#include <aws/iot/model/NamedShadowIndexingMode.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/iot/model/IndexingFilter.h>
#include <aws/iot/model/Field.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};
    bool m_thingIndexingModeHasBeenSet = false;
 
    ThingConnectivityIndexingMode m_thingConnectivityIndexingMode{ThingConnectivityIndexingMode::NOT_SET};
    bool m_thingConnectivityIndexingModeHasBeenSet = false;
 
    DeviceDefenderIndexingMode m_deviceDefenderIndexingMode{DeviceDefenderIndexingMode::NOT_SET};
    bool m_deviceDefenderIndexingModeHasBeenSet = false;
 
    NamedShadowIndexingMode m_namedShadowIndexingMode{NamedShadowIndexingMode::NOT_SET};
    bool m_namedShadowIndexingModeHasBeenSet = false;
 
    Aws::Vector<Field> m_managedFields;
    bool m_managedFieldsHasBeenSet = false;
 
    Aws::Vector<Field> m_customFields;
    bool m_customFieldsHasBeenSet = false;
 
    IndexingFilter m_filter;
    bool m_filterHasBeenSet = false;
  };
 
} // namespace Model
} // namespace IoT
} // namespace Aws