UpdateSnaplockConfiguration.h

 
#pragma once
#include <aws/fsx/FSx_EXPORTS.h>
#include <aws/fsx/model/AutocommitPeriod.h>
#include <aws/fsx/model/PrivilegedDelete.h>
#include <aws/fsx/model/SnaplockRetentionPeriod.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace FSx {
namespace Model {
 
class UpdateSnaplockConfiguration {
 public:
  AWS_FSX_API UpdateSnaplockConfiguration() = default;
  AWS_FSX_API UpdateSnaplockConfiguration(Aws::Utils::Json::JsonView jsonValue);
  AWS_FSX_API UpdateSnaplockConfiguration& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_FSX_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline bool GetAuditLogVolume() const { return m_auditLogVolume; }
  inline bool AuditLogVolumeHasBeenSet() const { return m_auditLogVolumeHasBeenSet; }
  inline void SetAuditLogVolume(bool value) {
    m_auditLogVolumeHasBeenSet = true;
    m_auditLogVolume = value;
  }
  inline UpdateSnaplockConfiguration& WithAuditLogVolume(bool value) {
    SetAuditLogVolume(value);
    return *this;
  }
 
 
  inline const AutocommitPeriod& GetAutocommitPeriod() const { return m_autocommitPeriod; }
  inline bool AutocommitPeriodHasBeenSet() const { return m_autocommitPeriodHasBeenSet; }
  template <typename AutocommitPeriodT = AutocommitPeriod>
  void SetAutocommitPeriod(AutocommitPeriodT&& value) {
    m_autocommitPeriodHasBeenSet = true;
    m_autocommitPeriod = std::forward<AutocommitPeriodT>(value);
  }
  template <typename AutocommitPeriodT = AutocommitPeriod>
  UpdateSnaplockConfiguration& WithAutocommitPeriod(AutocommitPeriodT&& value) {
    SetAutocommitPeriod(std::forward<AutocommitPeriodT>(value));
    return *this;
  }
 
 
  inline PrivilegedDelete GetPrivilegedDelete() const { return m_privilegedDelete; }
  inline bool PrivilegedDeleteHasBeenSet() const { return m_privilegedDeleteHasBeenSet; }
  inline void SetPrivilegedDelete(PrivilegedDelete value) {
    m_privilegedDeleteHasBeenSet = true;
    m_privilegedDelete = value;
  }
  inline UpdateSnaplockConfiguration& WithPrivilegedDelete(PrivilegedDelete value) {
    SetPrivilegedDelete(value);
    return *this;
  }
 
 
  inline const SnaplockRetentionPeriod& GetRetentionPeriod() const { return m_retentionPeriod; }
  inline bool RetentionPeriodHasBeenSet() const { return m_retentionPeriodHasBeenSet; }
  template <typename RetentionPeriodT = SnaplockRetentionPeriod>
  void SetRetentionPeriod(RetentionPeriodT&& value) {
    m_retentionPeriodHasBeenSet = true;
    m_retentionPeriod = std::forward<RetentionPeriodT>(value);
  }
  template <typename RetentionPeriodT = SnaplockRetentionPeriod>
  UpdateSnaplockConfiguration& WithRetentionPeriod(RetentionPeriodT&& value) {
    SetRetentionPeriod(std::forward<RetentionPeriodT>(value));
    return *this;
  }
 
 
  inline bool GetVolumeAppendModeEnabled() const { return m_volumeAppendModeEnabled; }
  inline bool VolumeAppendModeEnabledHasBeenSet() const { return m_volumeAppendModeEnabledHasBeenSet; }
  inline void SetVolumeAppendModeEnabled(bool value) {
    m_volumeAppendModeEnabledHasBeenSet = true;
    m_volumeAppendModeEnabled = value;
  }
  inline UpdateSnaplockConfiguration& WithVolumeAppendModeEnabled(bool value) {
    SetVolumeAppendModeEnabled(value);
    return *this;
  }
 private:
  bool m_auditLogVolume{false};
 
  AutocommitPeriod m_autocommitPeriod;
 
  PrivilegedDelete m_privilegedDelete{PrivilegedDelete::NOT_SET};
 
  SnaplockRetentionPeriod m_retentionPeriod;
 
  bool m_volumeAppendModeEnabled{false};
  bool m_auditLogVolumeHasBeenSet = false;
  bool m_autocommitPeriodHasBeenSet = false;
  bool m_privilegedDeleteHasBeenSet = false;
  bool m_retentionPeriodHasBeenSet = false;
  bool m_volumeAppendModeEnabledHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace FSx
}  // namespace Aws