Tape.h

 
#pragma once
#include <aws/core/utils/DateTime.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/storagegateway/StorageGateway_EXPORTS.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace StorageGateway {
namespace Model {
 
class Tape {
 public:
  AWS_STORAGEGATEWAY_API Tape() = default;
  AWS_STORAGEGATEWAY_API Tape(Aws::Utils::Json::JsonView jsonValue);
  AWS_STORAGEGATEWAY_API Tape& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_STORAGEGATEWAY_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetTapeARN() const { return m_tapeARN; }
  inline bool TapeARNHasBeenSet() const { return m_tapeARNHasBeenSet; }
  template <typename TapeARNT = Aws::String>
  void SetTapeARN(TapeARNT&& value) {
    m_tapeARNHasBeenSet = true;
    m_tapeARN = std::forward<TapeARNT>(value);
  }
  template <typename TapeARNT = Aws::String>
  Tape& WithTapeARN(TapeARNT&& value) {
    SetTapeARN(std::forward<TapeARNT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetTapeBarcode() const { return m_tapeBarcode; }
  inline bool TapeBarcodeHasBeenSet() const { return m_tapeBarcodeHasBeenSet; }
  template <typename TapeBarcodeT = Aws::String>
  void SetTapeBarcode(TapeBarcodeT&& value) {
    m_tapeBarcodeHasBeenSet = true;
    m_tapeBarcode = std::forward<TapeBarcodeT>(value);
  }
  template <typename TapeBarcodeT = Aws::String>
  Tape& WithTapeBarcode(TapeBarcodeT&& value) {
    SetTapeBarcode(std::forward<TapeBarcodeT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetTapeCreatedDate() const { return m_tapeCreatedDate; }
  inline bool TapeCreatedDateHasBeenSet() const { return m_tapeCreatedDateHasBeenSet; }
  template <typename TapeCreatedDateT = Aws::Utils::DateTime>
  void SetTapeCreatedDate(TapeCreatedDateT&& value) {
    m_tapeCreatedDateHasBeenSet = true;
    m_tapeCreatedDate = std::forward<TapeCreatedDateT>(value);
  }
  template <typename TapeCreatedDateT = Aws::Utils::DateTime>
  Tape& WithTapeCreatedDate(TapeCreatedDateT&& value) {
    SetTapeCreatedDate(std::forward<TapeCreatedDateT>(value));
    return *this;
  }
 
 
  inline long long GetTapeSizeInBytes() const { return m_tapeSizeInBytes; }
  inline bool TapeSizeInBytesHasBeenSet() const { return m_tapeSizeInBytesHasBeenSet; }
  inline void SetTapeSizeInBytes(long long value) {
    m_tapeSizeInBytesHasBeenSet = true;
    m_tapeSizeInBytes = value;
  }
  inline Tape& WithTapeSizeInBytes(long long value) {
    SetTapeSizeInBytes(value);
    return *this;
  }
 
 
  inline const Aws::String& GetTapeStatus() const { return m_tapeStatus; }
  inline bool TapeStatusHasBeenSet() const { return m_tapeStatusHasBeenSet; }
  template <typename TapeStatusT = Aws::String>
  void SetTapeStatus(TapeStatusT&& value) {
    m_tapeStatusHasBeenSet = true;
    m_tapeStatus = std::forward<TapeStatusT>(value);
  }
  template <typename TapeStatusT = Aws::String>
  Tape& WithTapeStatus(TapeStatusT&& value) {
    SetTapeStatus(std::forward<TapeStatusT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetVTLDevice() const { return m_vTLDevice; }
  inline bool VTLDeviceHasBeenSet() const { return m_vTLDeviceHasBeenSet; }
  template <typename VTLDeviceT = Aws::String>
  void SetVTLDevice(VTLDeviceT&& value) {
    m_vTLDeviceHasBeenSet = true;
    m_vTLDevice = std::forward<VTLDeviceT>(value);
  }
  template <typename VTLDeviceT = Aws::String>
  Tape& WithVTLDevice(VTLDeviceT&& value) {
    SetVTLDevice(std::forward<VTLDeviceT>(value));
    return *this;
  }
 
 
  inline double GetProgress() const { return m_progress; }
  inline bool ProgressHasBeenSet() const { return m_progressHasBeenSet; }
  inline void SetProgress(double value) {
    m_progressHasBeenSet = true;
    m_progress = value;
  }
  inline Tape& WithProgress(double value) {
    SetProgress(value);
    return *this;
  }
 
 
  inline long long GetTapeUsedInBytes() const { return m_tapeUsedInBytes; }
  inline bool TapeUsedInBytesHasBeenSet() const { return m_tapeUsedInBytesHasBeenSet; }
  inline void SetTapeUsedInBytes(long long value) {
    m_tapeUsedInBytesHasBeenSet = true;
    m_tapeUsedInBytes = value;
  }
  inline Tape& WithTapeUsedInBytes(long long value) {
    SetTapeUsedInBytes(value);
    return *this;
  }
 
 
  inline const Aws::String& GetKMSKey() const { return m_kMSKey; }
  inline bool KMSKeyHasBeenSet() const { return m_kMSKeyHasBeenSet; }
  template <typename KMSKeyT = Aws::String>
  void SetKMSKey(KMSKeyT&& value) {
    m_kMSKeyHasBeenSet = true;
    m_kMSKey = std::forward<KMSKeyT>(value);
  }
  template <typename KMSKeyT = Aws::String>
  Tape& WithKMSKey(KMSKeyT&& value) {
    SetKMSKey(std::forward<KMSKeyT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetPoolId() const { return m_poolId; }
  inline bool PoolIdHasBeenSet() const { return m_poolIdHasBeenSet; }
  template <typename PoolIdT = Aws::String>
  void SetPoolId(PoolIdT&& value) {
    m_poolIdHasBeenSet = true;
    m_poolId = std::forward<PoolIdT>(value);
  }
  template <typename PoolIdT = Aws::String>
  Tape& WithPoolId(PoolIdT&& value) {
    SetPoolId(std::forward<PoolIdT>(value));
    return *this;
  }
 
 
  inline bool GetWorm() const { return m_worm; }
  inline bool WormHasBeenSet() const { return m_wormHasBeenSet; }
  inline void SetWorm(bool value) {
    m_wormHasBeenSet = true;
    m_worm = value;
  }
  inline Tape& WithWorm(bool value) {
    SetWorm(value);
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetRetentionStartDate() const { return m_retentionStartDate; }
  inline bool RetentionStartDateHasBeenSet() const { return m_retentionStartDateHasBeenSet; }
  template <typename RetentionStartDateT = Aws::Utils::DateTime>
  void SetRetentionStartDate(RetentionStartDateT&& value) {
    m_retentionStartDateHasBeenSet = true;
    m_retentionStartDate = std::forward<RetentionStartDateT>(value);
  }
  template <typename RetentionStartDateT = Aws::Utils::DateTime>
  Tape& WithRetentionStartDate(RetentionStartDateT&& value) {
    SetRetentionStartDate(std::forward<RetentionStartDateT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetPoolEntryDate() const { return m_poolEntryDate; }
  inline bool PoolEntryDateHasBeenSet() const { return m_poolEntryDateHasBeenSet; }
  template <typename PoolEntryDateT = Aws::Utils::DateTime>
  void SetPoolEntryDate(PoolEntryDateT&& value) {
    m_poolEntryDateHasBeenSet = true;
    m_poolEntryDate = std::forward<PoolEntryDateT>(value);
  }
  template <typename PoolEntryDateT = Aws::Utils::DateTime>
  Tape& WithPoolEntryDate(PoolEntryDateT&& value) {
    SetPoolEntryDate(std::forward<PoolEntryDateT>(value));
    return *this;
  }
 private:
  Aws::String m_tapeARN;
 
  Aws::String m_tapeBarcode;
 
  Aws::Utils::DateTime m_tapeCreatedDate{};
 
  long long m_tapeSizeInBytes{0};
 
  Aws::String m_tapeStatus;
 
  Aws::String m_vTLDevice;
 
  double m_progress{0.0};
 
  long long m_tapeUsedInBytes{0};
 
  Aws::String m_kMSKey;
 
  Aws::String m_poolId;
 
  bool m_worm{false};
 
  Aws::Utils::DateTime m_retentionStartDate{};
 
  Aws::Utils::DateTime m_poolEntryDate{};
  bool m_tapeARNHasBeenSet = false;
  bool m_tapeBarcodeHasBeenSet = false;
  bool m_tapeCreatedDateHasBeenSet = false;
  bool m_tapeSizeInBytesHasBeenSet = false;
  bool m_tapeStatusHasBeenSet = false;
  bool m_vTLDeviceHasBeenSet = false;
  bool m_progressHasBeenSet = false;
  bool m_tapeUsedInBytesHasBeenSet = false;
  bool m_kMSKeyHasBeenSet = false;
  bool m_poolIdHasBeenSet = false;
  bool m_wormHasBeenSet = false;
  bool m_retentionStartDateHasBeenSet = false;
  bool m_poolEntryDateHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace StorageGateway
}  // namespace Aws