CapacityManagerDimension.h

 
#pragma once
#include <aws/core/utils/DateTime.h>
#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/ec2/EC2_EXPORTS.h>
#include <aws/ec2/model/CapacityManagerTagDimension.h>
#include <aws/ec2/model/CapacityTenancy.h>
#include <aws/ec2/model/ReservationEndDateType.h>
#include <aws/ec2/model/ReservationState.h>
#include <aws/ec2/model/ReservationType.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Xml {
class XmlNode;
}  // namespace Xml
}  // namespace Utils
namespace EC2 {
namespace Model {
 
class CapacityManagerDimension {
 public:
  AWS_EC2_API CapacityManagerDimension() = default;
  AWS_EC2_API CapacityManagerDimension(const Aws::Utils::Xml::XmlNode& xmlNode);
  AWS_EC2_API CapacityManagerDimension& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
 
  AWS_EC2_API void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
  AWS_EC2_API void OutputToStream(Aws::OStream& oStream, const char* location) const;
 
 
  inline const Aws::String& GetResourceRegion() const { return m_resourceRegion; }
  inline bool ResourceRegionHasBeenSet() const { return m_resourceRegionHasBeenSet; }
  template <typename ResourceRegionT = Aws::String>
  void SetResourceRegion(ResourceRegionT&& value) {
    m_resourceRegionHasBeenSet = true;
    m_resourceRegion = std::forward<ResourceRegionT>(value);
  }
  template <typename ResourceRegionT = Aws::String>
  CapacityManagerDimension& WithResourceRegion(ResourceRegionT&& value) {
    SetResourceRegion(std::forward<ResourceRegionT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetAvailabilityZoneId() const { return m_availabilityZoneId; }
  inline bool AvailabilityZoneIdHasBeenSet() const { return m_availabilityZoneIdHasBeenSet; }
  template <typename AvailabilityZoneIdT = Aws::String>
  void SetAvailabilityZoneId(AvailabilityZoneIdT&& value) {
    m_availabilityZoneIdHasBeenSet = true;
    m_availabilityZoneId = std::forward<AvailabilityZoneIdT>(value);
  }
  template <typename AvailabilityZoneIdT = Aws::String>
  CapacityManagerDimension& WithAvailabilityZoneId(AvailabilityZoneIdT&& value) {
    SetAvailabilityZoneId(std::forward<AvailabilityZoneIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetAccountId() const { return m_accountId; }
  inline bool AccountIdHasBeenSet() const { return m_accountIdHasBeenSet; }
  template <typename AccountIdT = Aws::String>
  void SetAccountId(AccountIdT&& value) {
    m_accountIdHasBeenSet = true;
    m_accountId = std::forward<AccountIdT>(value);
  }
  template <typename AccountIdT = Aws::String>
  CapacityManagerDimension& WithAccountId(AccountIdT&& value) {
    SetAccountId(std::forward<AccountIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetAccountName() const { return m_accountName; }
  inline bool AccountNameHasBeenSet() const { return m_accountNameHasBeenSet; }
  template <typename AccountNameT = Aws::String>
  void SetAccountName(AccountNameT&& value) {
    m_accountNameHasBeenSet = true;
    m_accountName = std::forward<AccountNameT>(value);
  }
  template <typename AccountNameT = Aws::String>
  CapacityManagerDimension& WithAccountName(AccountNameT&& value) {
    SetAccountName(std::forward<AccountNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetInstanceFamily() const { return m_instanceFamily; }
  inline bool InstanceFamilyHasBeenSet() const { return m_instanceFamilyHasBeenSet; }
  template <typename InstanceFamilyT = Aws::String>
  void SetInstanceFamily(InstanceFamilyT&& value) {
    m_instanceFamilyHasBeenSet = true;
    m_instanceFamily = std::forward<InstanceFamilyT>(value);
  }
  template <typename InstanceFamilyT = Aws::String>
  CapacityManagerDimension& WithInstanceFamily(InstanceFamilyT&& value) {
    SetInstanceFamily(std::forward<InstanceFamilyT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetInstanceType() const { return m_instanceType; }
  inline bool InstanceTypeHasBeenSet() const { return m_instanceTypeHasBeenSet; }
  template <typename InstanceTypeT = Aws::String>
  void SetInstanceType(InstanceTypeT&& value) {
    m_instanceTypeHasBeenSet = true;
    m_instanceType = std::forward<InstanceTypeT>(value);
  }
  template <typename InstanceTypeT = Aws::String>
  CapacityManagerDimension& WithInstanceType(InstanceTypeT&& value) {
    SetInstanceType(std::forward<InstanceTypeT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetInstancePlatform() const { return m_instancePlatform; }
  inline bool InstancePlatformHasBeenSet() const { return m_instancePlatformHasBeenSet; }
  template <typename InstancePlatformT = Aws::String>
  void SetInstancePlatform(InstancePlatformT&& value) {
    m_instancePlatformHasBeenSet = true;
    m_instancePlatform = std::forward<InstancePlatformT>(value);
  }
  template <typename InstancePlatformT = Aws::String>
  CapacityManagerDimension& WithInstancePlatform(InstancePlatformT&& value) {
    SetInstancePlatform(std::forward<InstancePlatformT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetReservationArn() const { return m_reservationArn; }
  inline bool ReservationArnHasBeenSet() const { return m_reservationArnHasBeenSet; }
  template <typename ReservationArnT = Aws::String>
  void SetReservationArn(ReservationArnT&& value) {
    m_reservationArnHasBeenSet = true;
    m_reservationArn = std::forward<ReservationArnT>(value);
  }
  template <typename ReservationArnT = Aws::String>
  CapacityManagerDimension& WithReservationArn(ReservationArnT&& value) {
    SetReservationArn(std::forward<ReservationArnT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetReservationId() const { return m_reservationId; }
  inline bool ReservationIdHasBeenSet() const { return m_reservationIdHasBeenSet; }
  template <typename ReservationIdT = Aws::String>
  void SetReservationId(ReservationIdT&& value) {
    m_reservationIdHasBeenSet = true;
    m_reservationId = std::forward<ReservationIdT>(value);
  }
  template <typename ReservationIdT = Aws::String>
  CapacityManagerDimension& WithReservationId(ReservationIdT&& value) {
    SetReservationId(std::forward<ReservationIdT>(value));
    return *this;
  }
 
 
  inline ReservationType GetReservationType() const { return m_reservationType; }
  inline bool ReservationTypeHasBeenSet() const { return m_reservationTypeHasBeenSet; }
  inline void SetReservationType(ReservationType value) {
    m_reservationTypeHasBeenSet = true;
    m_reservationType = value;
  }
  inline CapacityManagerDimension& WithReservationType(ReservationType value) {
    SetReservationType(value);
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetReservationCreateTimestamp() const { return m_reservationCreateTimestamp; }
  inline bool ReservationCreateTimestampHasBeenSet() const { return m_reservationCreateTimestampHasBeenSet; }
  template <typename ReservationCreateTimestampT = Aws::Utils::DateTime>
  void SetReservationCreateTimestamp(ReservationCreateTimestampT&& value) {
    m_reservationCreateTimestampHasBeenSet = true;
    m_reservationCreateTimestamp = std::forward<ReservationCreateTimestampT>(value);
  }
  template <typename ReservationCreateTimestampT = Aws::Utils::DateTime>
  CapacityManagerDimension& WithReservationCreateTimestamp(ReservationCreateTimestampT&& value) {
    SetReservationCreateTimestamp(std::forward<ReservationCreateTimestampT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetReservationStartTimestamp() const { return m_reservationStartTimestamp; }
  inline bool ReservationStartTimestampHasBeenSet() const { return m_reservationStartTimestampHasBeenSet; }
  template <typename ReservationStartTimestampT = Aws::Utils::DateTime>
  void SetReservationStartTimestamp(ReservationStartTimestampT&& value) {
    m_reservationStartTimestampHasBeenSet = true;
    m_reservationStartTimestamp = std::forward<ReservationStartTimestampT>(value);
  }
  template <typename ReservationStartTimestampT = Aws::Utils::DateTime>
  CapacityManagerDimension& WithReservationStartTimestamp(ReservationStartTimestampT&& value) {
    SetReservationStartTimestamp(std::forward<ReservationStartTimestampT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetReservationEndTimestamp() const { return m_reservationEndTimestamp; }
  inline bool ReservationEndTimestampHasBeenSet() const { return m_reservationEndTimestampHasBeenSet; }
  template <typename ReservationEndTimestampT = Aws::Utils::DateTime>
  void SetReservationEndTimestamp(ReservationEndTimestampT&& value) {
    m_reservationEndTimestampHasBeenSet = true;
    m_reservationEndTimestamp = std::forward<ReservationEndTimestampT>(value);
  }
  template <typename ReservationEndTimestampT = Aws::Utils::DateTime>
  CapacityManagerDimension& WithReservationEndTimestamp(ReservationEndTimestampT&& value) {
    SetReservationEndTimestamp(std::forward<ReservationEndTimestampT>(value));
    return *this;
  }
 
 
  inline ReservationEndDateType GetReservationEndDateType() const { return m_reservationEndDateType; }
  inline bool ReservationEndDateTypeHasBeenSet() const { return m_reservationEndDateTypeHasBeenSet; }
  inline void SetReservationEndDateType(ReservationEndDateType value) {
    m_reservationEndDateTypeHasBeenSet = true;
    m_reservationEndDateType = value;
  }
  inline CapacityManagerDimension& WithReservationEndDateType(ReservationEndDateType value) {
    SetReservationEndDateType(value);
    return *this;
  }
 
 
  inline CapacityTenancy GetTenancy() const { return m_tenancy; }
  inline bool TenancyHasBeenSet() const { return m_tenancyHasBeenSet; }
  inline void SetTenancy(CapacityTenancy value) {
    m_tenancyHasBeenSet = true;
    m_tenancy = value;
  }
  inline CapacityManagerDimension& WithTenancy(CapacityTenancy value) {
    SetTenancy(value);
    return *this;
  }
 
 
  inline ReservationState GetReservationState() const { return m_reservationState; }
  inline bool ReservationStateHasBeenSet() const { return m_reservationStateHasBeenSet; }
  inline void SetReservationState(ReservationState value) {
    m_reservationStateHasBeenSet = true;
    m_reservationState = value;
  }
  inline CapacityManagerDimension& WithReservationState(ReservationState value) {
    SetReservationState(value);
    return *this;
  }
 
 
  inline const Aws::String& GetReservationInstanceMatchCriteria() const { return m_reservationInstanceMatchCriteria; }
  inline bool ReservationInstanceMatchCriteriaHasBeenSet() const { return m_reservationInstanceMatchCriteriaHasBeenSet; }
  template <typename ReservationInstanceMatchCriteriaT = Aws::String>
  void SetReservationInstanceMatchCriteria(ReservationInstanceMatchCriteriaT&& value) {
    m_reservationInstanceMatchCriteriaHasBeenSet = true;
    m_reservationInstanceMatchCriteria = std::forward<ReservationInstanceMatchCriteriaT>(value);
  }
  template <typename ReservationInstanceMatchCriteriaT = Aws::String>
  CapacityManagerDimension& WithReservationInstanceMatchCriteria(ReservationInstanceMatchCriteriaT&& value) {
    SetReservationInstanceMatchCriteria(std::forward<ReservationInstanceMatchCriteriaT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetReservationUnusedFinancialOwner() const { return m_reservationUnusedFinancialOwner; }
  inline bool ReservationUnusedFinancialOwnerHasBeenSet() const { return m_reservationUnusedFinancialOwnerHasBeenSet; }
  template <typename ReservationUnusedFinancialOwnerT = Aws::String>
  void SetReservationUnusedFinancialOwner(ReservationUnusedFinancialOwnerT&& value) {
    m_reservationUnusedFinancialOwnerHasBeenSet = true;
    m_reservationUnusedFinancialOwner = std::forward<ReservationUnusedFinancialOwnerT>(value);
  }
  template <typename ReservationUnusedFinancialOwnerT = Aws::String>
  CapacityManagerDimension& WithReservationUnusedFinancialOwner(ReservationUnusedFinancialOwnerT&& value) {
    SetReservationUnusedFinancialOwner(std::forward<ReservationUnusedFinancialOwnerT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<CapacityManagerTagDimension>& GetTags() const { return m_tags; }
  inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
  template <typename TagsT = Aws::Vector<CapacityManagerTagDimension>>
  void SetTags(TagsT&& value) {
    m_tagsHasBeenSet = true;
    m_tags = std::forward<TagsT>(value);
  }
  template <typename TagsT = Aws::Vector<CapacityManagerTagDimension>>
  CapacityManagerDimension& WithTags(TagsT&& value) {
    SetTags(std::forward<TagsT>(value));
    return *this;
  }
  template <typename TagsT = CapacityManagerTagDimension>
  CapacityManagerDimension& AddTags(TagsT&& value) {
    m_tagsHasBeenSet = true;
    m_tags.emplace_back(std::forward<TagsT>(value));
    return *this;
  }
 private:
  Aws::String m_resourceRegion;
 
  Aws::String m_availabilityZoneId;
 
  Aws::String m_accountId;
 
  Aws::String m_accountName;
 
  Aws::String m_instanceFamily;
 
  Aws::String m_instanceType;
 
  Aws::String m_instancePlatform;
 
  Aws::String m_reservationArn;
 
  Aws::String m_reservationId;
 
  ReservationType m_reservationType{ReservationType::NOT_SET};
 
  Aws::Utils::DateTime m_reservationCreateTimestamp{};
 
  Aws::Utils::DateTime m_reservationStartTimestamp{};
 
  Aws::Utils::DateTime m_reservationEndTimestamp{};
 
  ReservationEndDateType m_reservationEndDateType{ReservationEndDateType::NOT_SET};
 
  CapacityTenancy m_tenancy{CapacityTenancy::NOT_SET};
 
  ReservationState m_reservationState{ReservationState::NOT_SET};
 
  Aws::String m_reservationInstanceMatchCriteria;
 
  Aws::String m_reservationUnusedFinancialOwner;
 
  Aws::Vector<CapacityManagerTagDimension> m_tags;
  bool m_resourceRegionHasBeenSet = false;
  bool m_availabilityZoneIdHasBeenSet = false;
  bool m_accountIdHasBeenSet = false;
  bool m_accountNameHasBeenSet = false;
  bool m_instanceFamilyHasBeenSet = false;
  bool m_instanceTypeHasBeenSet = false;
  bool m_instancePlatformHasBeenSet = false;
  bool m_reservationArnHasBeenSet = false;
  bool m_reservationIdHasBeenSet = false;
  bool m_reservationTypeHasBeenSet = false;
  bool m_reservationCreateTimestampHasBeenSet = false;
  bool m_reservationStartTimestampHasBeenSet = false;
  bool m_reservationEndTimestampHasBeenSet = false;
  bool m_reservationEndDateTypeHasBeenSet = false;
  bool m_tenancyHasBeenSet = false;
  bool m_reservationStateHasBeenSet = false;
  bool m_reservationInstanceMatchCriteriaHasBeenSet = false;
  bool m_reservationUnusedFinancialOwnerHasBeenSet = false;
  bool m_tagsHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace EC2
}  // namespace Aws