CreateOntapVolumeConfiguration.h

 
#pragma once
#include <aws/fsx/FSx_EXPORTS.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/fsx/model/SecurityStyle.h>
#include <aws/fsx/model/TieringPolicy.h>
#include <aws/fsx/model/InputOntapVolumeType.h>
#include <aws/fsx/model/CreateSnaplockConfiguration.h>
#include <aws/fsx/model/VolumeStyle.h>
#include <aws/fsx/model/CreateAggregateConfiguration.h>
#include <utility>
 
namespace Aws
{
namespace Utils
{
namespace Json
{
  class JsonValue;
  class JsonView;
} // namespace Json
} // namespace Utils
namespace FSx
{
namespace Model
{
 
  class CreateOntapVolumeConfiguration
  {
  public:
    AWS_FSX_API CreateOntapVolumeConfiguration() = default;
    AWS_FSX_API CreateOntapVolumeConfiguration(Aws::Utils::Json::JsonView jsonValue);
    AWS_FSX_API CreateOntapVolumeConfiguration& operator=(Aws::Utils::Json::JsonView jsonValue);
    AWS_FSX_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
 
    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>
    CreateOntapVolumeConfiguration& 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 CreateOntapVolumeConfiguration& WithSecurityStyle(SecurityStyle value) { SetSecurityStyle(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 CreateOntapVolumeConfiguration& 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>
    CreateOntapVolumeConfiguration& WithStorageVirtualMachineId(StorageVirtualMachineIdT&& value) { SetStorageVirtualMachineId(std::forward<StorageVirtualMachineIdT>(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>
    CreateOntapVolumeConfiguration& WithTieringPolicy(TieringPolicyT&& value) { SetTieringPolicy(std::forward<TieringPolicyT>(value)); return *this;}
 
 
    inline InputOntapVolumeType GetOntapVolumeType() const { return m_ontapVolumeType; }
    inline bool OntapVolumeTypeHasBeenSet() const { return m_ontapVolumeTypeHasBeenSet; }
    inline void SetOntapVolumeType(InputOntapVolumeType value) { m_ontapVolumeTypeHasBeenSet = true; m_ontapVolumeType = value; }
    inline CreateOntapVolumeConfiguration& WithOntapVolumeType(InputOntapVolumeType 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>
    CreateOntapVolumeConfiguration& 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 CreateOntapVolumeConfiguration& WithCopyTagsToBackups(bool value) { SetCopyTagsToBackups(value); return *this;}
 
 
    inline const CreateSnaplockConfiguration& GetSnaplockConfiguration() const { return m_snaplockConfiguration; }
    inline bool SnaplockConfigurationHasBeenSet() const { return m_snaplockConfigurationHasBeenSet; }
    template<typename SnaplockConfigurationT = CreateSnaplockConfiguration>
    void SetSnaplockConfiguration(SnaplockConfigurationT&& value) { m_snaplockConfigurationHasBeenSet = true; m_snaplockConfiguration = std::forward<SnaplockConfigurationT>(value); }
    template<typename SnaplockConfigurationT = CreateSnaplockConfiguration>
    CreateOntapVolumeConfiguration& 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 CreateOntapVolumeConfiguration& WithVolumeStyle(VolumeStyle value) { SetVolumeStyle(value); return *this;}
 
 
    inline const CreateAggregateConfiguration& GetAggregateConfiguration() const { return m_aggregateConfiguration; }
    inline bool AggregateConfigurationHasBeenSet() const { return m_aggregateConfigurationHasBeenSet; }
    template<typename AggregateConfigurationT = CreateAggregateConfiguration>
    void SetAggregateConfiguration(AggregateConfigurationT&& value) { m_aggregateConfigurationHasBeenSet = true; m_aggregateConfiguration = std::forward<AggregateConfigurationT>(value); }
    template<typename AggregateConfigurationT = CreateAggregateConfiguration>
    CreateOntapVolumeConfiguration& 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 CreateOntapVolumeConfiguration& WithSizeInBytes(long long value) { SetSizeInBytes(value); return *this;}
  private:
 
    Aws::String m_junctionPath;
    bool m_junctionPathHasBeenSet = false;
 
    SecurityStyle m_securityStyle{SecurityStyle::NOT_SET};
    bool m_securityStyleHasBeenSet = false;
 
    bool m_storageEfficiencyEnabled{false};
    bool m_storageEfficiencyEnabledHasBeenSet = false;
 
    Aws::String m_storageVirtualMachineId;
    bool m_storageVirtualMachineIdHasBeenSet = false;
 
    TieringPolicy m_tieringPolicy;
    bool m_tieringPolicyHasBeenSet = false;
 
    InputOntapVolumeType m_ontapVolumeType{InputOntapVolumeType::NOT_SET};
    bool m_ontapVolumeTypeHasBeenSet = false;
 
    Aws::String m_snapshotPolicy;
    bool m_snapshotPolicyHasBeenSet = false;
 
    bool m_copyTagsToBackups{false};
    bool m_copyTagsToBackupsHasBeenSet = false;
 
    CreateSnaplockConfiguration m_snaplockConfiguration;
    bool m_snaplockConfigurationHasBeenSet = false;
 
    VolumeStyle m_volumeStyle{VolumeStyle::NOT_SET};
    bool m_volumeStyleHasBeenSet = false;
 
    CreateAggregateConfiguration m_aggregateConfiguration;
    bool m_aggregateConfigurationHasBeenSet = false;
 
    long long m_sizeInBytes{0};
    bool m_sizeInBytesHasBeenSet = false;
  };
 
} // namespace Model
} // namespace FSx
} // namespace Aws