AdminScope.h

 
#pragma once
#include <aws/crt/cbor/Cbor.h>
#include <aws/fms/FMS_EXPORTS.h>
#include <aws/fms/model/AccountScope.h>
#include <aws/fms/model/OrganizationalUnitScope.h>
#include <aws/fms/model/PolicyTypeScope.h>
#include <aws/fms/model/RegionScope.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Cbor {
class CborValue;
}  // namespace Cbor
}  // namespace Utils
namespace FMS {
namespace Model {
 
class AdminScope {
 public:
  AWS_FMS_API AdminScope() = default;
  AWS_FMS_API AdminScope(const std::shared_ptr<Aws::Crt::Cbor::CborDecoder>& decoder);
  AWS_FMS_API AdminScope& operator=(const std::shared_ptr<Aws::Crt::Cbor::CborDecoder>& decoder);
  AWS_FMS_API void CborEncode(Aws::Crt::Cbor::CborEncoder& encoder) const;
 
 
  inline const AccountScope& GetAccountScope() const { return m_accountScope; }
  inline bool AccountScopeHasBeenSet() const { return m_accountScopeHasBeenSet; }
  template <typename AccountScopeT = AccountScope>
  void SetAccountScope(AccountScopeT&& value) {
    m_accountScopeHasBeenSet = true;
    m_accountScope = std::forward<AccountScopeT>(value);
  }
  template <typename AccountScopeT = AccountScope>
  AdminScope& WithAccountScope(AccountScopeT&& value) {
    SetAccountScope(std::forward<AccountScopeT>(value));
    return *this;
  }
 
 
  inline const OrganizationalUnitScope& GetOrganizationalUnitScope() const { return m_organizationalUnitScope; }
  inline bool OrganizationalUnitScopeHasBeenSet() const { return m_organizationalUnitScopeHasBeenSet; }
  template <typename OrganizationalUnitScopeT = OrganizationalUnitScope>
  void SetOrganizationalUnitScope(OrganizationalUnitScopeT&& value) {
    m_organizationalUnitScopeHasBeenSet = true;
    m_organizationalUnitScope = std::forward<OrganizationalUnitScopeT>(value);
  }
  template <typename OrganizationalUnitScopeT = OrganizationalUnitScope>
  AdminScope& WithOrganizationalUnitScope(OrganizationalUnitScopeT&& value) {
    SetOrganizationalUnitScope(std::forward<OrganizationalUnitScopeT>(value));
    return *this;
  }
 
 
  inline const RegionScope& GetRegionScope() const { return m_regionScope; }
  inline bool RegionScopeHasBeenSet() const { return m_regionScopeHasBeenSet; }
  template <typename RegionScopeT = RegionScope>
  void SetRegionScope(RegionScopeT&& value) {
    m_regionScopeHasBeenSet = true;
    m_regionScope = std::forward<RegionScopeT>(value);
  }
  template <typename RegionScopeT = RegionScope>
  AdminScope& WithRegionScope(RegionScopeT&& value) {
    SetRegionScope(std::forward<RegionScopeT>(value));
    return *this;
  }
 
 
  inline const PolicyTypeScope& GetPolicyTypeScope() const { return m_policyTypeScope; }
  inline bool PolicyTypeScopeHasBeenSet() const { return m_policyTypeScopeHasBeenSet; }
  template <typename PolicyTypeScopeT = PolicyTypeScope>
  void SetPolicyTypeScope(PolicyTypeScopeT&& value) {
    m_policyTypeScopeHasBeenSet = true;
    m_policyTypeScope = std::forward<PolicyTypeScopeT>(value);
  }
  template <typename PolicyTypeScopeT = PolicyTypeScope>
  AdminScope& WithPolicyTypeScope(PolicyTypeScopeT&& value) {
    SetPolicyTypeScope(std::forward<PolicyTypeScopeT>(value));
    return *this;
  }
 private:
  AccountScope m_accountScope;
 
  OrganizationalUnitScope m_organizationalUnitScope;
 
  RegionScope m_regionScope;
 
  PolicyTypeScope m_policyTypeScope;
  bool m_accountScopeHasBeenSet = false;
  bool m_organizationalUnitScopeHasBeenSet = false;
  bool m_regionScopeHasBeenSet = false;
  bool m_policyTypeScopeHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace FMS
}  // namespace Aws