OntapVolumeConfiguration.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/fsx/FSx_EXPORTS.h>
#include <aws/fsx/model/AggregateConfiguration.h>
#include <aws/fsx/model/FlexCacheEndpointType.h>
#include <aws/fsx/model/OntapVolumeType.h>
#include <aws/fsx/model/SecurityStyle.h>
#include <aws/fsx/model/SnaplockConfiguration.h>
#include <aws/fsx/model/TieringPolicy.h>
#include <aws/fsx/model/VolumeStyle.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace FSx {
namespace Model {
 
class OntapVolumeConfiguration {
 public:
  AWS_FSX_API OntapVolumeConfiguration() = default;
  AWS_FSX_API OntapVolumeConfiguration(Aws::Utils::Json::JsonView jsonValue);
  AWS_FSX_API OntapVolumeConfiguration& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_FSX_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline FlexCacheEndpointType GetFlexCacheEndpointType() const { return m_flexCacheEndpointType; }
  inline bool FlexCacheEndpointTypeHasBeenSet() const { return m_flexCacheEndpointTypeHasBeenSet; }
  inline void SetFlexCacheEndpointType(FlexCacheEndpointType value) {
    m_flexCacheEndpointTypeHasBeenSet = true;
    m_flexCacheEndpointType = value;
  }
  inline OntapVolumeConfiguration& WithFlexCacheEndpointType(FlexCacheEndpointType value) {
    SetFlexCacheEndpointType(value);
    return *this;
  }
 
 
  inline const Aws::String& GetJunctionPath() const { return m_junctionPath; }
  inline bool JunctionPathHasBeenSet() const { return m_junctionPathHasBeenSet; }
  template <typename JunctionPathT = Aws::String>
  void SetJunctionPath(JunctionPathT&& value) {
    m_junctionPathHasBeenSet = true;
    m_junctionPath = std::forward<JunctionPathT>(value);
  }
  template <typename JunctionPathT = Aws::String>
  OntapVolumeConfiguration& WithJunctionPath(JunctionPathT&& value) {
    SetJunctionPath(std::forward<JunctionPathT>(value));
    return *this;
  }
 
 
  inline SecurityStyle GetSecurityStyle() const { return m_securityStyle; }
  inline bool SecurityStyleHasBeenSet() const { return m_securityStyleHasBeenSet; }
  inline void SetSecurityStyle(SecurityStyle value) {
    m_securityStyleHasBeenSet = true;
    m_securityStyle = value;
  }
  inline OntapVolumeConfiguration& WithSecurityStyle(SecurityStyle value) {
    SetSecurityStyle(value);
    return *this;
  }
 
 
  inline int GetSizeInMegabytes() const { return m_sizeInMegabytes; }
  inline bool SizeInMegabytesHasBeenSet() const { return m_sizeInMegabytesHasBeenSet; }
  inline void SetSizeInMegabytes(int value) {
    m_sizeInMegabytesHasBeenSet = true;
    m_sizeInMegabytes = value;
  }
  inline OntapVolumeConfiguration& WithSizeInMegabytes(int value) {
    SetSizeInMegabytes(value);
    return *this;
  }
 
 
  inline bool GetStorageEfficiencyEnabled() const { return m_storageEfficiencyEnabled; }
  inline bool StorageEfficiencyEnabledHasBeenSet() const { return m_storageEfficiencyEnabledHasBeenSet; }
  inline void SetStorageEfficiencyEnabled(bool value) {
    m_storageEfficiencyEnabledHasBeenSet = true;
    m_storageEfficiencyEnabled = value;
  }
  inline OntapVolumeConfiguration& WithStorageEfficiencyEnabled(bool value) {
    SetStorageEfficiencyEnabled(value);
    return *this;
  }
 
 
  inline const Aws::String& GetStorageVirtualMachineId() const { return m_storageVirtualMachineId; }
  inline bool StorageVirtualMachineIdHasBeenSet() const { return m_storageVirtualMachineIdHasBeenSet; }
  template <typename StorageVirtualMachineIdT = Aws::String>
  void SetStorageVirtualMachineId(StorageVirtualMachineIdT&& value) {
    m_storageVirtualMachineIdHasBeenSet = true;
    m_storageVirtualMachineId = std::forward<StorageVirtualMachineIdT>(value);
  }
  template <typename StorageVirtualMachineIdT = Aws::String>
  OntapVolumeConfiguration& WithStorageVirtualMachineId(StorageVirtualMachineIdT&& value) {
    SetStorageVirtualMachineId(std::forward<StorageVirtualMachineIdT>(value));
    return *this;
  }
 
 
  inline bool GetStorageVirtualMachineRoot() const { return m_storageVirtualMachineRoot; }
  inline bool StorageVirtualMachineRootHasBeenSet() const { return m_storageVirtualMachineRootHasBeenSet; }
  inline void SetStorageVirtualMachineRoot(bool value) {
    m_storageVirtualMachineRootHasBeenSet = true;
    m_storageVirtualMachineRoot = value;
  }
  inline OntapVolumeConfiguration& WithStorageVirtualMachineRoot(bool value) {
    SetStorageVirtualMachineRoot(value);
    return *this;
  }
 
 
  inline const TieringPolicy& GetTieringPolicy() const { return m_tieringPolicy; }
  inline bool TieringPolicyHasBeenSet() const { return m_tieringPolicyHasBeenSet; }
  template <typename TieringPolicyT = TieringPolicy>
  void SetTieringPolicy(TieringPolicyT&& value) {
    m_tieringPolicyHasBeenSet = true;
    m_tieringPolicy = std::forward<TieringPolicyT>(value);
  }
  template <typename TieringPolicyT = TieringPolicy>
  OntapVolumeConfiguration& WithTieringPolicy(TieringPolicyT&& value) {
    SetTieringPolicy(std::forward<TieringPolicyT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetUUID() const { return m_uUID; }
  inline bool UUIDHasBeenSet() const { return m_uUIDHasBeenSet; }
  template <typename UUIDT = Aws::String>
  void SetUUID(UUIDT&& value) {
    m_uUIDHasBeenSet = true;
    m_uUID = std::forward<UUIDT>(value);
  }
  template <typename UUIDT = Aws::String>
  OntapVolumeConfiguration& WithUUID(UUIDT&& value) {
    SetUUID(std::forward<UUIDT>(value));
    return *this;
  }
 
 
  inline OntapVolumeType GetOntapVolumeType() const { return m_ontapVolumeType; }
  inline bool OntapVolumeTypeHasBeenSet() const { return m_ontapVolumeTypeHasBeenSet; }
  inline void SetOntapVolumeType(OntapVolumeType value) {
    m_ontapVolumeTypeHasBeenSet = true;
    m_ontapVolumeType = value;
  }
  inline OntapVolumeConfiguration& WithOntapVolumeType(OntapVolumeType value) {
    SetOntapVolumeType(value);
    return *this;
  }
 
 
  inline const Aws::String& GetSnapshotPolicy() const { return m_snapshotPolicy; }
  inline bool SnapshotPolicyHasBeenSet() const { return m_snapshotPolicyHasBeenSet; }
  template <typename SnapshotPolicyT = Aws::String>
  void SetSnapshotPolicy(SnapshotPolicyT&& value) {
    m_snapshotPolicyHasBeenSet = true;
    m_snapshotPolicy = std::forward<SnapshotPolicyT>(value);
  }
  template <typename SnapshotPolicyT = Aws::String>
  OntapVolumeConfiguration& WithSnapshotPolicy(SnapshotPolicyT&& value) {
    SetSnapshotPolicy(std::forward<SnapshotPolicyT>(value));
    return *this;
  }
 
 
  inline bool GetCopyTagsToBackups() const { return m_copyTagsToBackups; }
  inline bool CopyTagsToBackupsHasBeenSet() const { return m_copyTagsToBackupsHasBeenSet; }
  inline void SetCopyTagsToBackups(bool value) {
    m_copyTagsToBackupsHasBeenSet = true;
    m_copyTagsToBackups = value;
  }
  inline OntapVolumeConfiguration& WithCopyTagsToBackups(bool value) {
    SetCopyTagsToBackups(value);
    return *this;
  }
 
 
  inline const SnaplockConfiguration& GetSnaplockConfiguration() const { return m_snaplockConfiguration; }
  inline bool SnaplockConfigurationHasBeenSet() const { return m_snaplockConfigurationHasBeenSet; }
  template <typename SnaplockConfigurationT = SnaplockConfiguration>
  void SetSnaplockConfiguration(SnaplockConfigurationT&& value) {
    m_snaplockConfigurationHasBeenSet = true;
    m_snaplockConfiguration = std::forward<SnaplockConfigurationT>(value);
  }
  template <typename SnaplockConfigurationT = SnaplockConfiguration>
  OntapVolumeConfiguration& WithSnaplockConfiguration(SnaplockConfigurationT&& value) {
    SetSnaplockConfiguration(std::forward<SnaplockConfigurationT>(value));
    return *this;
  }
 
 
  inline VolumeStyle GetVolumeStyle() const { return m_volumeStyle; }
  inline bool VolumeStyleHasBeenSet() const { return m_volumeStyleHasBeenSet; }
  inline void SetVolumeStyle(VolumeStyle value) {
    m_volumeStyleHasBeenSet = true;
    m_volumeStyle = value;
  }
  inline OntapVolumeConfiguration& WithVolumeStyle(VolumeStyle value) {
    SetVolumeStyle(value);
    return *this;
  }
 
 
  inline const AggregateConfiguration& GetAggregateConfiguration() const { return m_aggregateConfiguration; }
  inline bool AggregateConfigurationHasBeenSet() const { return m_aggregateConfigurationHasBeenSet; }
  template <typename AggregateConfigurationT = AggregateConfiguration>
  void SetAggregateConfiguration(AggregateConfigurationT&& value) {
    m_aggregateConfigurationHasBeenSet = true;
    m_aggregateConfiguration = std::forward<AggregateConfigurationT>(value);
  }
  template <typename AggregateConfigurationT = AggregateConfiguration>
  OntapVolumeConfiguration& WithAggregateConfiguration(AggregateConfigurationT&& value) {
    SetAggregateConfiguration(std::forward<AggregateConfigurationT>(value));
    return *this;
  }
 
 
  inline long long GetSizeInBytes() const { return m_sizeInBytes; }
  inline bool SizeInBytesHasBeenSet() const { return m_sizeInBytesHasBeenSet; }
  inline void SetSizeInBytes(long long value) {
    m_sizeInBytesHasBeenSet = true;
    m_sizeInBytes = value;
  }
  inline OntapVolumeConfiguration& WithSizeInBytes(long long value) {
    SetSizeInBytes(value);
    return *this;
  }
 private:
  FlexCacheEndpointType m_flexCacheEndpointType{FlexCacheEndpointType::NOT_SET};
 
  Aws::String m_junctionPath;
 
  SecurityStyle m_securityStyle{SecurityStyle::NOT_SET};
 
  int m_sizeInMegabytes{0};
 
  bool m_storageEfficiencyEnabled{false};
 
  Aws::String m_storageVirtualMachineId;
 
  bool m_storageVirtualMachineRoot{false};
 
  TieringPolicy m_tieringPolicy;
 
  Aws::String m_uUID;
 
  OntapVolumeType m_ontapVolumeType{OntapVolumeType::NOT_SET};
 
  Aws::String m_snapshotPolicy;
 
  bool m_copyTagsToBackups{false};
 
  SnaplockConfiguration m_snaplockConfiguration;
 
  VolumeStyle m_volumeStyle{VolumeStyle::NOT_SET};
 
  AggregateConfiguration m_aggregateConfiguration;
 
  long long m_sizeInBytes{0};
  bool m_flexCacheEndpointTypeHasBeenSet = false;
  bool m_junctionPathHasBeenSet = false;
  bool m_securityStyleHasBeenSet = false;
  bool m_sizeInMegabytesHasBeenSet = false;
  bool m_storageEfficiencyEnabledHasBeenSet = false;
  bool m_storageVirtualMachineIdHasBeenSet = false;
  bool m_storageVirtualMachineRootHasBeenSet = false;
  bool m_tieringPolicyHasBeenSet = false;
  bool m_uUIDHasBeenSet = false;
  bool m_ontapVolumeTypeHasBeenSet = false;
  bool m_snapshotPolicyHasBeenSet = false;
  bool m_copyTagsToBackupsHasBeenSet = false;
  bool m_snaplockConfigurationHasBeenSet = false;
  bool m_volumeStyleHasBeenSet = false;
  bool m_aggregateConfigurationHasBeenSet = false;
  bool m_sizeInBytesHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace FSx
}  // namespace Aws