Options.h

 
#pragma once
#include <aws/datasync/DataSync_EXPORTS.h>
#include <aws/datasync/model/VerifyMode.h>
#include <aws/datasync/model/OverwriteMode.h>
#include <aws/datasync/model/Atime.h>
#include <aws/datasync/model/Mtime.h>
#include <aws/datasync/model/Uid.h>
#include <aws/datasync/model/Gid.h>
#include <aws/datasync/model/PreserveDeletedFiles.h>
#include <aws/datasync/model/PreserveDevices.h>
#include <aws/datasync/model/PosixPermissions.h>
#include <aws/datasync/model/TaskQueueing.h>
#include <aws/datasync/model/LogLevel.h>
#include <aws/datasync/model/TransferMode.h>
#include <aws/datasync/model/SmbSecurityDescriptorCopyFlags.h>
#include <aws/datasync/model/ObjectTags.h>
#include <utility>
 
namespace Aws
{
namespace Utils
{
namespace Json
{
  class JsonValue;
  class JsonView;
} // namespace Json
} // namespace Utils
namespace DataSync
{
namespace Model
{
 
  class Options
  {
  public:
    AWS_DATASYNC_API Options();
    AWS_DATASYNC_API Options(Aws::Utils::Json::JsonView jsonValue);
    AWS_DATASYNC_API Options& operator=(Aws::Utils::Json::JsonView jsonValue);
    AWS_DATASYNC_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
 
    inline const VerifyMode& GetVerifyMode() const{ return m_verifyMode; }
    inline bool VerifyModeHasBeenSet() const { return m_verifyModeHasBeenSet; }
    inline void SetVerifyMode(const VerifyMode& value) { m_verifyModeHasBeenSet = true; m_verifyMode = value; }
    inline void SetVerifyMode(VerifyMode&& value) { m_verifyModeHasBeenSet = true; m_verifyMode = std::move(value); }
    inline Options& WithVerifyMode(const VerifyMode& value) { SetVerifyMode(value); return *this;}
    inline Options& WithVerifyMode(VerifyMode&& value) { SetVerifyMode(std::move(value)); return *this;}
 
 
    inline const OverwriteMode& GetOverwriteMode() const{ return m_overwriteMode; }
    inline bool OverwriteModeHasBeenSet() const { return m_overwriteModeHasBeenSet; }
    inline void SetOverwriteMode(const OverwriteMode& value) { m_overwriteModeHasBeenSet = true; m_overwriteMode = value; }
    inline void SetOverwriteMode(OverwriteMode&& value) { m_overwriteModeHasBeenSet = true; m_overwriteMode = std::move(value); }
    inline Options& WithOverwriteMode(const OverwriteMode& value) { SetOverwriteMode(value); return *this;}
    inline Options& WithOverwriteMode(OverwriteMode&& value) { SetOverwriteMode(std::move(value)); return *this;}
 
 
    inline const Atime& GetAtime() const{ return m_atime; }
    inline bool AtimeHasBeenSet() const { return m_atimeHasBeenSet; }
    inline void SetAtime(const Atime& value) { m_atimeHasBeenSet = true; m_atime = value; }
    inline void SetAtime(Atime&& value) { m_atimeHasBeenSet = true; m_atime = std::move(value); }
    inline Options& WithAtime(const Atime& value) { SetAtime(value); return *this;}
    inline Options& WithAtime(Atime&& value) { SetAtime(std::move(value)); return *this;}
 
 
    inline const Mtime& GetMtime() const{ return m_mtime; }
    inline bool MtimeHasBeenSet() const { return m_mtimeHasBeenSet; }
    inline void SetMtime(const Mtime& value) { m_mtimeHasBeenSet = true; m_mtime = value; }
    inline void SetMtime(Mtime&& value) { m_mtimeHasBeenSet = true; m_mtime = std::move(value); }
    inline Options& WithMtime(const Mtime& value) { SetMtime(value); return *this;}
    inline Options& WithMtime(Mtime&& value) { SetMtime(std::move(value)); return *this;}
 
 
    inline const Uid& GetUid() const{ return m_uid; }
    inline bool UidHasBeenSet() const { return m_uidHasBeenSet; }
    inline void SetUid(const Uid& value) { m_uidHasBeenSet = true; m_uid = value; }
    inline void SetUid(Uid&& value) { m_uidHasBeenSet = true; m_uid = std::move(value); }
    inline Options& WithUid(const Uid& value) { SetUid(value); return *this;}
    inline Options& WithUid(Uid&& value) { SetUid(std::move(value)); return *this;}
 
 
    inline const Gid& GetGid() const{ return m_gid; }
    inline bool GidHasBeenSet() const { return m_gidHasBeenSet; }
    inline void SetGid(const Gid& value) { m_gidHasBeenSet = true; m_gid = value; }
    inline void SetGid(Gid&& value) { m_gidHasBeenSet = true; m_gid = std::move(value); }
    inline Options& WithGid(const Gid& value) { SetGid(value); return *this;}
    inline Options& WithGid(Gid&& value) { SetGid(std::move(value)); return *this;}
 
 
    inline const PreserveDeletedFiles& GetPreserveDeletedFiles() const{ return m_preserveDeletedFiles; }
    inline bool PreserveDeletedFilesHasBeenSet() const { return m_preserveDeletedFilesHasBeenSet; }
    inline void SetPreserveDeletedFiles(const PreserveDeletedFiles& value) { m_preserveDeletedFilesHasBeenSet = true; m_preserveDeletedFiles = value; }
    inline void SetPreserveDeletedFiles(PreserveDeletedFiles&& value) { m_preserveDeletedFilesHasBeenSet = true; m_preserveDeletedFiles = std::move(value); }
    inline Options& WithPreserveDeletedFiles(const PreserveDeletedFiles& value) { SetPreserveDeletedFiles(value); return *this;}
    inline Options& WithPreserveDeletedFiles(PreserveDeletedFiles&& value) { SetPreserveDeletedFiles(std::move(value)); return *this;}
 
 
    inline const PreserveDevices& GetPreserveDevices() const{ return m_preserveDevices; }
    inline bool PreserveDevicesHasBeenSet() const { return m_preserveDevicesHasBeenSet; }
    inline void SetPreserveDevices(const PreserveDevices& value) { m_preserveDevicesHasBeenSet = true; m_preserveDevices = value; }
    inline void SetPreserveDevices(PreserveDevices&& value) { m_preserveDevicesHasBeenSet = true; m_preserveDevices = std::move(value); }
    inline Options& WithPreserveDevices(const PreserveDevices& value) { SetPreserveDevices(value); return *this;}
    inline Options& WithPreserveDevices(PreserveDevices&& value) { SetPreserveDevices(std::move(value)); return *this;}
 
 
    inline const PosixPermissions& GetPosixPermissions() const{ return m_posixPermissions; }
    inline bool PosixPermissionsHasBeenSet() const { return m_posixPermissionsHasBeenSet; }
    inline void SetPosixPermissions(const PosixPermissions& value) { m_posixPermissionsHasBeenSet = true; m_posixPermissions = value; }
    inline void SetPosixPermissions(PosixPermissions&& value) { m_posixPermissionsHasBeenSet = true; m_posixPermissions = std::move(value); }
    inline Options& WithPosixPermissions(const PosixPermissions& value) { SetPosixPermissions(value); return *this;}
    inline Options& WithPosixPermissions(PosixPermissions&& value) { SetPosixPermissions(std::move(value)); return *this;}
 
 
    inline long long GetBytesPerSecond() const{ return m_bytesPerSecond; }
    inline bool BytesPerSecondHasBeenSet() const { return m_bytesPerSecondHasBeenSet; }
    inline void SetBytesPerSecond(long long value) { m_bytesPerSecondHasBeenSet = true; m_bytesPerSecond = value; }
    inline Options& WithBytesPerSecond(long long value) { SetBytesPerSecond(value); return *this;}
 
 
    inline const TaskQueueing& GetTaskQueueing() const{ return m_taskQueueing; }
    inline bool TaskQueueingHasBeenSet() const { return m_taskQueueingHasBeenSet; }
    inline void SetTaskQueueing(const TaskQueueing& value) { m_taskQueueingHasBeenSet = true; m_taskQueueing = value; }
    inline void SetTaskQueueing(TaskQueueing&& value) { m_taskQueueingHasBeenSet = true; m_taskQueueing = std::move(value); }
    inline Options& WithTaskQueueing(const TaskQueueing& value) { SetTaskQueueing(value); return *this;}
    inline Options& WithTaskQueueing(TaskQueueing&& value) { SetTaskQueueing(std::move(value)); return *this;}
 
 
    inline const LogLevel& GetLogLevel() const{ return m_logLevel; }
    inline bool LogLevelHasBeenSet() const { return m_logLevelHasBeenSet; }
    inline void SetLogLevel(const LogLevel& value) { m_logLevelHasBeenSet = true; m_logLevel = value; }
    inline void SetLogLevel(LogLevel&& value) { m_logLevelHasBeenSet = true; m_logLevel = std::move(value); }
    inline Options& WithLogLevel(const LogLevel& value) { SetLogLevel(value); return *this;}
    inline Options& WithLogLevel(LogLevel&& value) { SetLogLevel(std::move(value)); return *this;}
 
 
    inline const TransferMode& GetTransferMode() const{ return m_transferMode; }
    inline bool TransferModeHasBeenSet() const { return m_transferModeHasBeenSet; }
    inline void SetTransferMode(const TransferMode& value) { m_transferModeHasBeenSet = true; m_transferMode = value; }
    inline void SetTransferMode(TransferMode&& value) { m_transferModeHasBeenSet = true; m_transferMode = std::move(value); }
    inline Options& WithTransferMode(const TransferMode& value) { SetTransferMode(value); return *this;}
    inline Options& WithTransferMode(TransferMode&& value) { SetTransferMode(std::move(value)); return *this;}
 
 
    inline const SmbSecurityDescriptorCopyFlags& GetSecurityDescriptorCopyFlags() const{ return m_securityDescriptorCopyFlags; }
    inline bool SecurityDescriptorCopyFlagsHasBeenSet() const { return m_securityDescriptorCopyFlagsHasBeenSet; }
    inline void SetSecurityDescriptorCopyFlags(const SmbSecurityDescriptorCopyFlags& value) { m_securityDescriptorCopyFlagsHasBeenSet = true; m_securityDescriptorCopyFlags = value; }
    inline void SetSecurityDescriptorCopyFlags(SmbSecurityDescriptorCopyFlags&& value) { m_securityDescriptorCopyFlagsHasBeenSet = true; m_securityDescriptorCopyFlags = std::move(value); }
    inline Options& WithSecurityDescriptorCopyFlags(const SmbSecurityDescriptorCopyFlags& value) { SetSecurityDescriptorCopyFlags(value); return *this;}
    inline Options& WithSecurityDescriptorCopyFlags(SmbSecurityDescriptorCopyFlags&& value) { SetSecurityDescriptorCopyFlags(std::move(value)); return *this;}
 
 
    inline const ObjectTags& GetObjectTags() const{ return m_objectTags; }
    inline bool ObjectTagsHasBeenSet() const { return m_objectTagsHasBeenSet; }
    inline void SetObjectTags(const ObjectTags& value) { m_objectTagsHasBeenSet = true; m_objectTags = value; }
    inline void SetObjectTags(ObjectTags&& value) { m_objectTagsHasBeenSet = true; m_objectTags = std::move(value); }
    inline Options& WithObjectTags(const ObjectTags& value) { SetObjectTags(value); return *this;}
    inline Options& WithObjectTags(ObjectTags&& value) { SetObjectTags(std::move(value)); return *this;}
  private:
 
    VerifyMode m_verifyMode;
    bool m_verifyModeHasBeenSet = false;
 
    OverwriteMode m_overwriteMode;
    bool m_overwriteModeHasBeenSet = false;
 
    Atime m_atime;
    bool m_atimeHasBeenSet = false;
 
    Mtime m_mtime;
    bool m_mtimeHasBeenSet = false;
 
    Uid m_uid;
    bool m_uidHasBeenSet = false;
 
    Gid m_gid;
    bool m_gidHasBeenSet = false;
 
    PreserveDeletedFiles m_preserveDeletedFiles;
    bool m_preserveDeletedFilesHasBeenSet = false;
 
    PreserveDevices m_preserveDevices;
    bool m_preserveDevicesHasBeenSet = false;
 
    PosixPermissions m_posixPermissions;
    bool m_posixPermissionsHasBeenSet = false;
 
    long long m_bytesPerSecond;
    bool m_bytesPerSecondHasBeenSet = false;
 
    TaskQueueing m_taskQueueing;
    bool m_taskQueueingHasBeenSet = false;
 
    LogLevel m_logLevel;
    bool m_logLevelHasBeenSet = false;
 
    TransferMode m_transferMode;
    bool m_transferModeHasBeenSet = false;
 
    SmbSecurityDescriptorCopyFlags m_securityDescriptorCopyFlags;
    bool m_securityDescriptorCopyFlagsHasBeenSet = false;
 
    ObjectTags m_objectTags;
    bool m_objectTagsHasBeenSet = false;
  };
 
} // namespace Model
} // namespace DataSync
} // namespace Aws