CreateFileSystemLustreConfiguration.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/fsx/FSx_EXPORTS.h>
#include <aws/fsx/model/AutoImportPolicyType.h>
#include <aws/fsx/model/CreateFileSystemLustreMetadataConfiguration.h>
#include <aws/fsx/model/DataCompressionType.h>
#include <aws/fsx/model/DriveCacheType.h>
#include <aws/fsx/model/LustreDeploymentType.h>
#include <aws/fsx/model/LustreLogCreateConfiguration.h>
#include <aws/fsx/model/LustreReadCacheConfiguration.h>
#include <aws/fsx/model/LustreRootSquashConfiguration.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace FSx {
namespace Model {
 
class CreateFileSystemLustreConfiguration {
 public:
  AWS_FSX_API CreateFileSystemLustreConfiguration() = default;
  AWS_FSX_API CreateFileSystemLustreConfiguration(Aws::Utils::Json::JsonView jsonValue);
  AWS_FSX_API CreateFileSystemLustreConfiguration& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_FSX_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetWeeklyMaintenanceStartTime() const { return m_weeklyMaintenanceStartTime; }
  inline bool WeeklyMaintenanceStartTimeHasBeenSet() const { return m_weeklyMaintenanceStartTimeHasBeenSet; }
  template <typename WeeklyMaintenanceStartTimeT = Aws::String>
  void SetWeeklyMaintenanceStartTime(WeeklyMaintenanceStartTimeT&& value) {
    m_weeklyMaintenanceStartTimeHasBeenSet = true;
    m_weeklyMaintenanceStartTime = std::forward<WeeklyMaintenanceStartTimeT>(value);
  }
  template <typename WeeklyMaintenanceStartTimeT = Aws::String>
  CreateFileSystemLustreConfiguration& WithWeeklyMaintenanceStartTime(WeeklyMaintenanceStartTimeT&& value) {
    SetWeeklyMaintenanceStartTime(std::forward<WeeklyMaintenanceStartTimeT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetImportPath() const { return m_importPath; }
  inline bool ImportPathHasBeenSet() const { return m_importPathHasBeenSet; }
  template <typename ImportPathT = Aws::String>
  void SetImportPath(ImportPathT&& value) {
    m_importPathHasBeenSet = true;
    m_importPath = std::forward<ImportPathT>(value);
  }
  template <typename ImportPathT = Aws::String>
  CreateFileSystemLustreConfiguration& WithImportPath(ImportPathT&& value) {
    SetImportPath(std::forward<ImportPathT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetExportPath() const { return m_exportPath; }
  inline bool ExportPathHasBeenSet() const { return m_exportPathHasBeenSet; }
  template <typename ExportPathT = Aws::String>
  void SetExportPath(ExportPathT&& value) {
    m_exportPathHasBeenSet = true;
    m_exportPath = std::forward<ExportPathT>(value);
  }
  template <typename ExportPathT = Aws::String>
  CreateFileSystemLustreConfiguration& WithExportPath(ExportPathT&& value) {
    SetExportPath(std::forward<ExportPathT>(value));
    return *this;
  }
 
 
  inline int GetImportedFileChunkSize() const { return m_importedFileChunkSize; }
  inline bool ImportedFileChunkSizeHasBeenSet() const { return m_importedFileChunkSizeHasBeenSet; }
  inline void SetImportedFileChunkSize(int value) {
    m_importedFileChunkSizeHasBeenSet = true;
    m_importedFileChunkSize = value;
  }
  inline CreateFileSystemLustreConfiguration& WithImportedFileChunkSize(int value) {
    SetImportedFileChunkSize(value);
    return *this;
  }
 
 
  inline LustreDeploymentType GetDeploymentType() const { return m_deploymentType; }
  inline bool DeploymentTypeHasBeenSet() const { return m_deploymentTypeHasBeenSet; }
  inline void SetDeploymentType(LustreDeploymentType value) {
    m_deploymentTypeHasBeenSet = true;
    m_deploymentType = value;
  }
  inline CreateFileSystemLustreConfiguration& WithDeploymentType(LustreDeploymentType value) {
    SetDeploymentType(value);
    return *this;
  }
 
 
  inline AutoImportPolicyType GetAutoImportPolicy() const { return m_autoImportPolicy; }
  inline bool AutoImportPolicyHasBeenSet() const { return m_autoImportPolicyHasBeenSet; }
  inline void SetAutoImportPolicy(AutoImportPolicyType value) {
    m_autoImportPolicyHasBeenSet = true;
    m_autoImportPolicy = value;
  }
  inline CreateFileSystemLustreConfiguration& WithAutoImportPolicy(AutoImportPolicyType value) {
    SetAutoImportPolicy(value);
    return *this;
  }
 
 
  inline int GetPerUnitStorageThroughput() const { return m_perUnitStorageThroughput; }
  inline bool PerUnitStorageThroughputHasBeenSet() const { return m_perUnitStorageThroughputHasBeenSet; }
  inline void SetPerUnitStorageThroughput(int value) {
    m_perUnitStorageThroughputHasBeenSet = true;
    m_perUnitStorageThroughput = value;
  }
  inline CreateFileSystemLustreConfiguration& WithPerUnitStorageThroughput(int value) {
    SetPerUnitStorageThroughput(value);
    return *this;
  }
 
 
  inline const Aws::String& GetDailyAutomaticBackupStartTime() const { return m_dailyAutomaticBackupStartTime; }
  inline bool DailyAutomaticBackupStartTimeHasBeenSet() const { return m_dailyAutomaticBackupStartTimeHasBeenSet; }
  template <typename DailyAutomaticBackupStartTimeT = Aws::String>
  void SetDailyAutomaticBackupStartTime(DailyAutomaticBackupStartTimeT&& value) {
    m_dailyAutomaticBackupStartTimeHasBeenSet = true;
    m_dailyAutomaticBackupStartTime = std::forward<DailyAutomaticBackupStartTimeT>(value);
  }
  template <typename DailyAutomaticBackupStartTimeT = Aws::String>
  CreateFileSystemLustreConfiguration& WithDailyAutomaticBackupStartTime(DailyAutomaticBackupStartTimeT&& value) {
    SetDailyAutomaticBackupStartTime(std::forward<DailyAutomaticBackupStartTimeT>(value));
    return *this;
  }
 
 
  inline int GetAutomaticBackupRetentionDays() const { return m_automaticBackupRetentionDays; }
  inline bool AutomaticBackupRetentionDaysHasBeenSet() const { return m_automaticBackupRetentionDaysHasBeenSet; }
  inline void SetAutomaticBackupRetentionDays(int value) {
    m_automaticBackupRetentionDaysHasBeenSet = true;
    m_automaticBackupRetentionDays = value;
  }
  inline CreateFileSystemLustreConfiguration& WithAutomaticBackupRetentionDays(int value) {
    SetAutomaticBackupRetentionDays(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 CreateFileSystemLustreConfiguration& WithCopyTagsToBackups(bool value) {
    SetCopyTagsToBackups(value);
    return *this;
  }
 
 
  inline DriveCacheType GetDriveCacheType() const { return m_driveCacheType; }
  inline bool DriveCacheTypeHasBeenSet() const { return m_driveCacheTypeHasBeenSet; }
  inline void SetDriveCacheType(DriveCacheType value) {
    m_driveCacheTypeHasBeenSet = true;
    m_driveCacheType = value;
  }
  inline CreateFileSystemLustreConfiguration& WithDriveCacheType(DriveCacheType value) {
    SetDriveCacheType(value);
    return *this;
  }
 
 
  inline DataCompressionType GetDataCompressionType() const { return m_dataCompressionType; }
  inline bool DataCompressionTypeHasBeenSet() const { return m_dataCompressionTypeHasBeenSet; }
  inline void SetDataCompressionType(DataCompressionType value) {
    m_dataCompressionTypeHasBeenSet = true;
    m_dataCompressionType = value;
  }
  inline CreateFileSystemLustreConfiguration& WithDataCompressionType(DataCompressionType value) {
    SetDataCompressionType(value);
    return *this;
  }
 
 
  inline bool GetEfaEnabled() const { return m_efaEnabled; }
  inline bool EfaEnabledHasBeenSet() const { return m_efaEnabledHasBeenSet; }
  inline void SetEfaEnabled(bool value) {
    m_efaEnabledHasBeenSet = true;
    m_efaEnabled = value;
  }
  inline CreateFileSystemLustreConfiguration& WithEfaEnabled(bool value) {
    SetEfaEnabled(value);
    return *this;
  }
 
 
  inline const LustreLogCreateConfiguration& GetLogConfiguration() const { return m_logConfiguration; }
  inline bool LogConfigurationHasBeenSet() const { return m_logConfigurationHasBeenSet; }
  template <typename LogConfigurationT = LustreLogCreateConfiguration>
  void SetLogConfiguration(LogConfigurationT&& value) {
    m_logConfigurationHasBeenSet = true;
    m_logConfiguration = std::forward<LogConfigurationT>(value);
  }
  template <typename LogConfigurationT = LustreLogCreateConfiguration>
  CreateFileSystemLustreConfiguration& WithLogConfiguration(LogConfigurationT&& value) {
    SetLogConfiguration(std::forward<LogConfigurationT>(value));
    return *this;
  }
 
 
  inline const LustreRootSquashConfiguration& GetRootSquashConfiguration() const { return m_rootSquashConfiguration; }
  inline bool RootSquashConfigurationHasBeenSet() const { return m_rootSquashConfigurationHasBeenSet; }
  template <typename RootSquashConfigurationT = LustreRootSquashConfiguration>
  void SetRootSquashConfiguration(RootSquashConfigurationT&& value) {
    m_rootSquashConfigurationHasBeenSet = true;
    m_rootSquashConfiguration = std::forward<RootSquashConfigurationT>(value);
  }
  template <typename RootSquashConfigurationT = LustreRootSquashConfiguration>
  CreateFileSystemLustreConfiguration& WithRootSquashConfiguration(RootSquashConfigurationT&& value) {
    SetRootSquashConfiguration(std::forward<RootSquashConfigurationT>(value));
    return *this;
  }
 
 
  inline const CreateFileSystemLustreMetadataConfiguration& GetMetadataConfiguration() const { return m_metadataConfiguration; }
  inline bool MetadataConfigurationHasBeenSet() const { return m_metadataConfigurationHasBeenSet; }
  template <typename MetadataConfigurationT = CreateFileSystemLustreMetadataConfiguration>
  void SetMetadataConfiguration(MetadataConfigurationT&& value) {
    m_metadataConfigurationHasBeenSet = true;
    m_metadataConfiguration = std::forward<MetadataConfigurationT>(value);
  }
  template <typename MetadataConfigurationT = CreateFileSystemLustreMetadataConfiguration>
  CreateFileSystemLustreConfiguration& WithMetadataConfiguration(MetadataConfigurationT&& value) {
    SetMetadataConfiguration(std::forward<MetadataConfigurationT>(value));
    return *this;
  }
 
 
  inline int GetThroughputCapacity() const { return m_throughputCapacity; }
  inline bool ThroughputCapacityHasBeenSet() const { return m_throughputCapacityHasBeenSet; }
  inline void SetThroughputCapacity(int value) {
    m_throughputCapacityHasBeenSet = true;
    m_throughputCapacity = value;
  }
  inline CreateFileSystemLustreConfiguration& WithThroughputCapacity(int value) {
    SetThroughputCapacity(value);
    return *this;
  }
 
 
  inline const LustreReadCacheConfiguration& GetDataReadCacheConfiguration() const { return m_dataReadCacheConfiguration; }
  inline bool DataReadCacheConfigurationHasBeenSet() const { return m_dataReadCacheConfigurationHasBeenSet; }
  template <typename DataReadCacheConfigurationT = LustreReadCacheConfiguration>
  void SetDataReadCacheConfiguration(DataReadCacheConfigurationT&& value) {
    m_dataReadCacheConfigurationHasBeenSet = true;
    m_dataReadCacheConfiguration = std::forward<DataReadCacheConfigurationT>(value);
  }
  template <typename DataReadCacheConfigurationT = LustreReadCacheConfiguration>
  CreateFileSystemLustreConfiguration& WithDataReadCacheConfiguration(DataReadCacheConfigurationT&& value) {
    SetDataReadCacheConfiguration(std::forward<DataReadCacheConfigurationT>(value));
    return *this;
  }
 private:
  Aws::String m_weeklyMaintenanceStartTime;
 
  Aws::String m_importPath;
 
  Aws::String m_exportPath;
 
  int m_importedFileChunkSize{0};
 
  LustreDeploymentType m_deploymentType{LustreDeploymentType::NOT_SET};
 
  AutoImportPolicyType m_autoImportPolicy{AutoImportPolicyType::NOT_SET};
 
  int m_perUnitStorageThroughput{0};
 
  Aws::String m_dailyAutomaticBackupStartTime;
 
  int m_automaticBackupRetentionDays{0};
 
  bool m_copyTagsToBackups{false};
 
  DriveCacheType m_driveCacheType{DriveCacheType::NOT_SET};
 
  DataCompressionType m_dataCompressionType{DataCompressionType::NOT_SET};
 
  bool m_efaEnabled{false};
 
  LustreLogCreateConfiguration m_logConfiguration;
 
  LustreRootSquashConfiguration m_rootSquashConfiguration;
 
  CreateFileSystemLustreMetadataConfiguration m_metadataConfiguration;
 
  int m_throughputCapacity{0};
 
  LustreReadCacheConfiguration m_dataReadCacheConfiguration;
  bool m_weeklyMaintenanceStartTimeHasBeenSet = false;
  bool m_importPathHasBeenSet = false;
  bool m_exportPathHasBeenSet = false;
  bool m_importedFileChunkSizeHasBeenSet = false;
  bool m_deploymentTypeHasBeenSet = false;
  bool m_autoImportPolicyHasBeenSet = false;
  bool m_perUnitStorageThroughputHasBeenSet = false;
  bool m_dailyAutomaticBackupStartTimeHasBeenSet = false;
  bool m_automaticBackupRetentionDaysHasBeenSet = false;
  bool m_copyTagsToBackupsHasBeenSet = false;
  bool m_driveCacheTypeHasBeenSet = false;
  bool m_dataCompressionTypeHasBeenSet = false;
  bool m_efaEnabledHasBeenSet = false;
  bool m_logConfigurationHasBeenSet = false;
  bool m_rootSquashConfigurationHasBeenSet = false;
  bool m_metadataConfigurationHasBeenSet = false;
  bool m_throughputCapacityHasBeenSet = false;
  bool m_dataReadCacheConfigurationHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace FSx
}  // namespace Aws