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};
    bool m_auditLogVolumeHasBeenSet = false;
 
    AutocommitPeriod m_autocommitPeriod;
    bool m_autocommitPeriodHasBeenSet = false;
 
    PrivilegedDelete m_privilegedDelete{PrivilegedDelete::NOT_SET};
    bool m_privilegedDeleteHasBeenSet = false;
 
    SnaplockRetentionPeriod m_retentionPeriod;
    bool m_retentionPeriodHasBeenSet = false;
 
    bool m_volumeAppendModeEnabled{false};
    bool m_volumeAppendModeEnabledHasBeenSet = false;
  };
 
} // namespace Model
} // namespace FSx
} // namespace Aws