ComplianceDrift.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSMap.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/resiliencehub/ResilienceHub_EXPORTS.h>
#include <aws/resiliencehub/model/DifferenceType.h>
#include <aws/resiliencehub/model/DisruptionCompliance.h>
#include <aws/resiliencehub/model/DisruptionType.h>
#include <aws/resiliencehub/model/DriftType.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace ResilienceHub {
namespace Model {
 
class ComplianceDrift {
 public:
  AWS_RESILIENCEHUB_API ComplianceDrift() = default;
  AWS_RESILIENCEHUB_API ComplianceDrift(Aws::Utils::Json::JsonView jsonValue);
  AWS_RESILIENCEHUB_API ComplianceDrift& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_RESILIENCEHUB_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetActualReferenceId() const { return m_actualReferenceId; }
  inline bool ActualReferenceIdHasBeenSet() const { return m_actualReferenceIdHasBeenSet; }
  template <typename ActualReferenceIdT = Aws::String>
  void SetActualReferenceId(ActualReferenceIdT&& value) {
    m_actualReferenceIdHasBeenSet = true;
    m_actualReferenceId = std::forward<ActualReferenceIdT>(value);
  }
  template <typename ActualReferenceIdT = Aws::String>
  ComplianceDrift& WithActualReferenceId(ActualReferenceIdT&& value) {
    SetActualReferenceId(std::forward<ActualReferenceIdT>(value));
    return *this;
  }
 
 
  inline const Aws::Map<DisruptionType, DisruptionCompliance>& GetActualValue() const { return m_actualValue; }
  inline bool ActualValueHasBeenSet() const { return m_actualValueHasBeenSet; }
  template <typename ActualValueT = Aws::Map<DisruptionType, DisruptionCompliance>>
  void SetActualValue(ActualValueT&& value) {
    m_actualValueHasBeenSet = true;
    m_actualValue = std::forward<ActualValueT>(value);
  }
  template <typename ActualValueT = Aws::Map<DisruptionType, DisruptionCompliance>>
  ComplianceDrift& WithActualValue(ActualValueT&& value) {
    SetActualValue(std::forward<ActualValueT>(value));
    return *this;
  }
  inline ComplianceDrift& AddActualValue(DisruptionType key, DisruptionCompliance value) {
    m_actualValueHasBeenSet = true;
    m_actualValue.emplace(key, value);
    return *this;
  }
 
 
  inline const Aws::String& GetAppId() const { return m_appId; }
  inline bool AppIdHasBeenSet() const { return m_appIdHasBeenSet; }
  template <typename AppIdT = Aws::String>
  void SetAppId(AppIdT&& value) {
    m_appIdHasBeenSet = true;
    m_appId = std::forward<AppIdT>(value);
  }
  template <typename AppIdT = Aws::String>
  ComplianceDrift& WithAppId(AppIdT&& value) {
    SetAppId(std::forward<AppIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetAppVersion() const { return m_appVersion; }
  inline bool AppVersionHasBeenSet() const { return m_appVersionHasBeenSet; }
  template <typename AppVersionT = Aws::String>
  void SetAppVersion(AppVersionT&& value) {
    m_appVersionHasBeenSet = true;
    m_appVersion = std::forward<AppVersionT>(value);
  }
  template <typename AppVersionT = Aws::String>
  ComplianceDrift& WithAppVersion(AppVersionT&& value) {
    SetAppVersion(std::forward<AppVersionT>(value));
    return *this;
  }
 
 
  inline DifferenceType GetDiffType() const { return m_diffType; }
  inline bool DiffTypeHasBeenSet() const { return m_diffTypeHasBeenSet; }
  inline void SetDiffType(DifferenceType value) {
    m_diffTypeHasBeenSet = true;
    m_diffType = value;
  }
  inline ComplianceDrift& WithDiffType(DifferenceType value) {
    SetDiffType(value);
    return *this;
  }
 
 
  inline DriftType GetDriftType() const { return m_driftType; }
  inline bool DriftTypeHasBeenSet() const { return m_driftTypeHasBeenSet; }
  inline void SetDriftType(DriftType value) {
    m_driftTypeHasBeenSet = true;
    m_driftType = value;
  }
  inline ComplianceDrift& WithDriftType(DriftType value) {
    SetDriftType(value);
    return *this;
  }
 
 
  inline const Aws::String& GetEntityId() const { return m_entityId; }
  inline bool EntityIdHasBeenSet() const { return m_entityIdHasBeenSet; }
  template <typename EntityIdT = Aws::String>
  void SetEntityId(EntityIdT&& value) {
    m_entityIdHasBeenSet = true;
    m_entityId = std::forward<EntityIdT>(value);
  }
  template <typename EntityIdT = Aws::String>
  ComplianceDrift& WithEntityId(EntityIdT&& value) {
    SetEntityId(std::forward<EntityIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetEntityType() const { return m_entityType; }
  inline bool EntityTypeHasBeenSet() const { return m_entityTypeHasBeenSet; }
  template <typename EntityTypeT = Aws::String>
  void SetEntityType(EntityTypeT&& value) {
    m_entityTypeHasBeenSet = true;
    m_entityType = std::forward<EntityTypeT>(value);
  }
  template <typename EntityTypeT = Aws::String>
  ComplianceDrift& WithEntityType(EntityTypeT&& value) {
    SetEntityType(std::forward<EntityTypeT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetExpectedReferenceId() const { return m_expectedReferenceId; }
  inline bool ExpectedReferenceIdHasBeenSet() const { return m_expectedReferenceIdHasBeenSet; }
  template <typename ExpectedReferenceIdT = Aws::String>
  void SetExpectedReferenceId(ExpectedReferenceIdT&& value) {
    m_expectedReferenceIdHasBeenSet = true;
    m_expectedReferenceId = std::forward<ExpectedReferenceIdT>(value);
  }
  template <typename ExpectedReferenceIdT = Aws::String>
  ComplianceDrift& WithExpectedReferenceId(ExpectedReferenceIdT&& value) {
    SetExpectedReferenceId(std::forward<ExpectedReferenceIdT>(value));
    return *this;
  }
 
 
  inline const Aws::Map<DisruptionType, DisruptionCompliance>& GetExpectedValue() const { return m_expectedValue; }
  inline bool ExpectedValueHasBeenSet() const { return m_expectedValueHasBeenSet; }
  template <typename ExpectedValueT = Aws::Map<DisruptionType, DisruptionCompliance>>
  void SetExpectedValue(ExpectedValueT&& value) {
    m_expectedValueHasBeenSet = true;
    m_expectedValue = std::forward<ExpectedValueT>(value);
  }
  template <typename ExpectedValueT = Aws::Map<DisruptionType, DisruptionCompliance>>
  ComplianceDrift& WithExpectedValue(ExpectedValueT&& value) {
    SetExpectedValue(std::forward<ExpectedValueT>(value));
    return *this;
  }
  inline ComplianceDrift& AddExpectedValue(DisruptionType key, DisruptionCompliance value) {
    m_expectedValueHasBeenSet = true;
    m_expectedValue.emplace(key, value);
    return *this;
  }
 private:
  Aws::String m_actualReferenceId;
 
  Aws::Map<DisruptionType, DisruptionCompliance> m_actualValue;
 
  Aws::String m_appId;
 
  Aws::String m_appVersion;
 
  DifferenceType m_diffType{DifferenceType::NOT_SET};
 
  DriftType m_driftType{DriftType::NOT_SET};
 
  Aws::String m_entityId;
 
  Aws::String m_entityType;
 
  Aws::String m_expectedReferenceId;
 
  Aws::Map<DisruptionType, DisruptionCompliance> m_expectedValue;
  bool m_actualReferenceIdHasBeenSet = false;
  bool m_actualValueHasBeenSet = false;
  bool m_appIdHasBeenSet = false;
  bool m_appVersionHasBeenSet = false;
  bool m_diffTypeHasBeenSet = false;
  bool m_driftTypeHasBeenSet = false;
  bool m_entityIdHasBeenSet = false;
  bool m_entityTypeHasBeenSet = false;
  bool m_expectedReferenceIdHasBeenSet = false;
  bool m_expectedValueHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace ResilienceHub
}  // namespace Aws