OpenZFSVolumeConfiguration.h

 
#pragma once
#include <aws/fsx/FSx_EXPORTS.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/fsx/model/OpenZFSDataCompressionType.h>
#include <aws/fsx/model/OpenZFSOriginSnapshotConfiguration.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/fsx/model/OpenZFSCopyStrategy.h>
#include <aws/fsx/model/OpenZFSNfsExport.h>
#include <aws/fsx/model/OpenZFSUserOrGroupQuota.h>
#include <utility>
 
namespace Aws
{
namespace Utils
{
namespace Json
{
  class JsonValue;
  class JsonView;
} // namespace Json
} // namespace Utils
namespace FSx
{
namespace Model
{
 
  class OpenZFSVolumeConfiguration
  {
  public:
    AWS_FSX_API OpenZFSVolumeConfiguration() = default;
    AWS_FSX_API OpenZFSVolumeConfiguration(Aws::Utils::Json::JsonView jsonValue);
    AWS_FSX_API OpenZFSVolumeConfiguration& operator=(Aws::Utils::Json::JsonView jsonValue);
    AWS_FSX_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
 
    inline const Aws::String& GetParentVolumeId() const { return m_parentVolumeId; }
    inline bool ParentVolumeIdHasBeenSet() const { return m_parentVolumeIdHasBeenSet; }
    template<typename ParentVolumeIdT = Aws::String>
    void SetParentVolumeId(ParentVolumeIdT&& value) { m_parentVolumeIdHasBeenSet = true; m_parentVolumeId = std::forward<ParentVolumeIdT>(value); }
    template<typename ParentVolumeIdT = Aws::String>
    OpenZFSVolumeConfiguration& WithParentVolumeId(ParentVolumeIdT&& value) { SetParentVolumeId(std::forward<ParentVolumeIdT>(value)); return *this;}
 
 
    inline const Aws::String& GetVolumePath() const { return m_volumePath; }
    inline bool VolumePathHasBeenSet() const { return m_volumePathHasBeenSet; }
    template<typename VolumePathT = Aws::String>
    void SetVolumePath(VolumePathT&& value) { m_volumePathHasBeenSet = true; m_volumePath = std::forward<VolumePathT>(value); }
    template<typename VolumePathT = Aws::String>
    OpenZFSVolumeConfiguration& WithVolumePath(VolumePathT&& value) { SetVolumePath(std::forward<VolumePathT>(value)); return *this;}
 
 
    inline int GetStorageCapacityReservationGiB() const { return m_storageCapacityReservationGiB; }
    inline bool StorageCapacityReservationGiBHasBeenSet() const { return m_storageCapacityReservationGiBHasBeenSet; }
    inline void SetStorageCapacityReservationGiB(int value) { m_storageCapacityReservationGiBHasBeenSet = true; m_storageCapacityReservationGiB = value; }
    inline OpenZFSVolumeConfiguration& WithStorageCapacityReservationGiB(int value) { SetStorageCapacityReservationGiB(value); return *this;}
 
 
    inline int GetStorageCapacityQuotaGiB() const { return m_storageCapacityQuotaGiB; }
    inline bool StorageCapacityQuotaGiBHasBeenSet() const { return m_storageCapacityQuotaGiBHasBeenSet; }
    inline void SetStorageCapacityQuotaGiB(int value) { m_storageCapacityQuotaGiBHasBeenSet = true; m_storageCapacityQuotaGiB = value; }
    inline OpenZFSVolumeConfiguration& WithStorageCapacityQuotaGiB(int value) { SetStorageCapacityQuotaGiB(value); return *this;}
 
 
    inline int GetRecordSizeKiB() const { return m_recordSizeKiB; }
    inline bool RecordSizeKiBHasBeenSet() const { return m_recordSizeKiBHasBeenSet; }
    inline void SetRecordSizeKiB(int value) { m_recordSizeKiBHasBeenSet = true; m_recordSizeKiB = value; }
    inline OpenZFSVolumeConfiguration& WithRecordSizeKiB(int value) { SetRecordSizeKiB(value); return *this;}
 
 
    inline OpenZFSDataCompressionType GetDataCompressionType() const { return m_dataCompressionType; }
    inline bool DataCompressionTypeHasBeenSet() const { return m_dataCompressionTypeHasBeenSet; }
    inline void SetDataCompressionType(OpenZFSDataCompressionType value) { m_dataCompressionTypeHasBeenSet = true; m_dataCompressionType = value; }
    inline OpenZFSVolumeConfiguration& WithDataCompressionType(OpenZFSDataCompressionType value) { SetDataCompressionType(value); return *this;}
 
 
    inline bool GetCopyTagsToSnapshots() const { return m_copyTagsToSnapshots; }
    inline bool CopyTagsToSnapshotsHasBeenSet() const { return m_copyTagsToSnapshotsHasBeenSet; }
    inline void SetCopyTagsToSnapshots(bool value) { m_copyTagsToSnapshotsHasBeenSet = true; m_copyTagsToSnapshots = value; }
    inline OpenZFSVolumeConfiguration& WithCopyTagsToSnapshots(bool value) { SetCopyTagsToSnapshots(value); return *this;}
 
 
    inline const OpenZFSOriginSnapshotConfiguration& GetOriginSnapshot() const { return m_originSnapshot; }
    inline bool OriginSnapshotHasBeenSet() const { return m_originSnapshotHasBeenSet; }
    template<typename OriginSnapshotT = OpenZFSOriginSnapshotConfiguration>
    void SetOriginSnapshot(OriginSnapshotT&& value) { m_originSnapshotHasBeenSet = true; m_originSnapshot = std::forward<OriginSnapshotT>(value); }
    template<typename OriginSnapshotT = OpenZFSOriginSnapshotConfiguration>
    OpenZFSVolumeConfiguration& WithOriginSnapshot(OriginSnapshotT&& value) { SetOriginSnapshot(std::forward<OriginSnapshotT>(value)); return *this;}
 
 
    inline bool GetReadOnly() const { return m_readOnly; }
    inline bool ReadOnlyHasBeenSet() const { return m_readOnlyHasBeenSet; }
    inline void SetReadOnly(bool value) { m_readOnlyHasBeenSet = true; m_readOnly = value; }
    inline OpenZFSVolumeConfiguration& WithReadOnly(bool value) { SetReadOnly(value); return *this;}
 
 
    inline const Aws::Vector<OpenZFSNfsExport>& GetNfsExports() const { return m_nfsExports; }
    inline bool NfsExportsHasBeenSet() const { return m_nfsExportsHasBeenSet; }
    template<typename NfsExportsT = Aws::Vector<OpenZFSNfsExport>>
    void SetNfsExports(NfsExportsT&& value) { m_nfsExportsHasBeenSet = true; m_nfsExports = std::forward<NfsExportsT>(value); }
    template<typename NfsExportsT = Aws::Vector<OpenZFSNfsExport>>
    OpenZFSVolumeConfiguration& WithNfsExports(NfsExportsT&& value) { SetNfsExports(std::forward<NfsExportsT>(value)); return *this;}
    template<typename NfsExportsT = OpenZFSNfsExport>
    OpenZFSVolumeConfiguration& AddNfsExports(NfsExportsT&& value) { m_nfsExportsHasBeenSet = true; m_nfsExports.emplace_back(std::forward<NfsExportsT>(value)); return *this; }
 
 
    inline const Aws::Vector<OpenZFSUserOrGroupQuota>& GetUserAndGroupQuotas() const { return m_userAndGroupQuotas; }
    inline bool UserAndGroupQuotasHasBeenSet() const { return m_userAndGroupQuotasHasBeenSet; }
    template<typename UserAndGroupQuotasT = Aws::Vector<OpenZFSUserOrGroupQuota>>
    void SetUserAndGroupQuotas(UserAndGroupQuotasT&& value) { m_userAndGroupQuotasHasBeenSet = true; m_userAndGroupQuotas = std::forward<UserAndGroupQuotasT>(value); }
    template<typename UserAndGroupQuotasT = Aws::Vector<OpenZFSUserOrGroupQuota>>
    OpenZFSVolumeConfiguration& WithUserAndGroupQuotas(UserAndGroupQuotasT&& value) { SetUserAndGroupQuotas(std::forward<UserAndGroupQuotasT>(value)); return *this;}
    template<typename UserAndGroupQuotasT = OpenZFSUserOrGroupQuota>
    OpenZFSVolumeConfiguration& AddUserAndGroupQuotas(UserAndGroupQuotasT&& value) { m_userAndGroupQuotasHasBeenSet = true; m_userAndGroupQuotas.emplace_back(std::forward<UserAndGroupQuotasT>(value)); return *this; }
 
 
    inline const Aws::String& GetRestoreToSnapshot() const { return m_restoreToSnapshot; }
    inline bool RestoreToSnapshotHasBeenSet() const { return m_restoreToSnapshotHasBeenSet; }
    template<typename RestoreToSnapshotT = Aws::String>
    void SetRestoreToSnapshot(RestoreToSnapshotT&& value) { m_restoreToSnapshotHasBeenSet = true; m_restoreToSnapshot = std::forward<RestoreToSnapshotT>(value); }
    template<typename RestoreToSnapshotT = Aws::String>
    OpenZFSVolumeConfiguration& WithRestoreToSnapshot(RestoreToSnapshotT&& value) { SetRestoreToSnapshot(std::forward<RestoreToSnapshotT>(value)); return *this;}
 
 
    inline bool GetDeleteIntermediateSnaphots() const { return m_deleteIntermediateSnaphots; }
    inline bool DeleteIntermediateSnaphotsHasBeenSet() const { return m_deleteIntermediateSnaphotsHasBeenSet; }
    inline void SetDeleteIntermediateSnaphots(bool value) { m_deleteIntermediateSnaphotsHasBeenSet = true; m_deleteIntermediateSnaphots = value; }
    inline OpenZFSVolumeConfiguration& WithDeleteIntermediateSnaphots(bool value) { SetDeleteIntermediateSnaphots(value); return *this;}
 
 
    inline bool GetDeleteClonedVolumes() const { return m_deleteClonedVolumes; }
    inline bool DeleteClonedVolumesHasBeenSet() const { return m_deleteClonedVolumesHasBeenSet; }
    inline void SetDeleteClonedVolumes(bool value) { m_deleteClonedVolumesHasBeenSet = true; m_deleteClonedVolumes = value; }
    inline OpenZFSVolumeConfiguration& WithDeleteClonedVolumes(bool value) { SetDeleteClonedVolumes(value); return *this;}
 
 
    inline bool GetDeleteIntermediateData() const { return m_deleteIntermediateData; }
    inline bool DeleteIntermediateDataHasBeenSet() const { return m_deleteIntermediateDataHasBeenSet; }
    inline void SetDeleteIntermediateData(bool value) { m_deleteIntermediateDataHasBeenSet = true; m_deleteIntermediateData = value; }
    inline OpenZFSVolumeConfiguration& WithDeleteIntermediateData(bool value) { SetDeleteIntermediateData(value); return *this;}
 
    
    inline const Aws::String& GetSourceSnapshotARN() const { return m_sourceSnapshotARN; }
    inline bool SourceSnapshotARNHasBeenSet() const { return m_sourceSnapshotARNHasBeenSet; }
    template<typename SourceSnapshotARNT = Aws::String>
    void SetSourceSnapshotARN(SourceSnapshotARNT&& value) { m_sourceSnapshotARNHasBeenSet = true; m_sourceSnapshotARN = std::forward<SourceSnapshotARNT>(value); }
    template<typename SourceSnapshotARNT = Aws::String>
    OpenZFSVolumeConfiguration& WithSourceSnapshotARN(SourceSnapshotARNT&& value) { SetSourceSnapshotARN(std::forward<SourceSnapshotARNT>(value)); return *this;}
 
 
    inline const Aws::String& GetDestinationSnapshot() const { return m_destinationSnapshot; }
    inline bool DestinationSnapshotHasBeenSet() const { return m_destinationSnapshotHasBeenSet; }
    template<typename DestinationSnapshotT = Aws::String>
    void SetDestinationSnapshot(DestinationSnapshotT&& value) { m_destinationSnapshotHasBeenSet = true; m_destinationSnapshot = std::forward<DestinationSnapshotT>(value); }
    template<typename DestinationSnapshotT = Aws::String>
    OpenZFSVolumeConfiguration& WithDestinationSnapshot(DestinationSnapshotT&& value) { SetDestinationSnapshot(std::forward<DestinationSnapshotT>(value)); return *this;}
 
 
    inline OpenZFSCopyStrategy GetCopyStrategy() const { return m_copyStrategy; }
    inline bool CopyStrategyHasBeenSet() const { return m_copyStrategyHasBeenSet; }
    inline void SetCopyStrategy(OpenZFSCopyStrategy value) { m_copyStrategyHasBeenSet = true; m_copyStrategy = value; }
    inline OpenZFSVolumeConfiguration& WithCopyStrategy(OpenZFSCopyStrategy value) { SetCopyStrategy(value); return *this;}
  private:
 
    Aws::String m_parentVolumeId;
    bool m_parentVolumeIdHasBeenSet = false;
 
    Aws::String m_volumePath;
    bool m_volumePathHasBeenSet = false;
 
    int m_storageCapacityReservationGiB{0};
    bool m_storageCapacityReservationGiBHasBeenSet = false;
 
    int m_storageCapacityQuotaGiB{0};
    bool m_storageCapacityQuotaGiBHasBeenSet = false;
 
    int m_recordSizeKiB{0};
    bool m_recordSizeKiBHasBeenSet = false;
 
    OpenZFSDataCompressionType m_dataCompressionType{OpenZFSDataCompressionType::NOT_SET};
    bool m_dataCompressionTypeHasBeenSet = false;
 
    bool m_copyTagsToSnapshots{false};
    bool m_copyTagsToSnapshotsHasBeenSet = false;
 
    OpenZFSOriginSnapshotConfiguration m_originSnapshot;
    bool m_originSnapshotHasBeenSet = false;
 
    bool m_readOnly{false};
    bool m_readOnlyHasBeenSet = false;
 
    Aws::Vector<OpenZFSNfsExport> m_nfsExports;
    bool m_nfsExportsHasBeenSet = false;
 
    Aws::Vector<OpenZFSUserOrGroupQuota> m_userAndGroupQuotas;
    bool m_userAndGroupQuotasHasBeenSet = false;
 
    Aws::String m_restoreToSnapshot;
    bool m_restoreToSnapshotHasBeenSet = false;
 
    bool m_deleteIntermediateSnaphots{false};
    bool m_deleteIntermediateSnaphotsHasBeenSet = false;
 
    bool m_deleteClonedVolumes{false};
    bool m_deleteClonedVolumesHasBeenSet = false;
 
    bool m_deleteIntermediateData{false};
    bool m_deleteIntermediateDataHasBeenSet = false;
 
    Aws::String m_sourceSnapshotARN;
    bool m_sourceSnapshotARNHasBeenSet = false;
 
    Aws::String m_destinationSnapshot;
    bool m_destinationSnapshotHasBeenSet = false;
 
    OpenZFSCopyStrategy m_copyStrategy{OpenZFSCopyStrategy::NOT_SET};
    bool m_copyStrategyHasBeenSet = false;
  };
 
} // namespace Model
} // namespace FSx
} // namespace Aws