DataReplicationInfo.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/drs/Drs_EXPORTS.h>
#include <aws/drs/model/DataReplicationError.h>
#include <aws/drs/model/DataReplicationInfoReplicatedDisk.h>
#include <aws/drs/model/DataReplicationInitiation.h>
#include <aws/drs/model/DataReplicationState.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace drs {
namespace Model {
 
class DataReplicationInfo {
 public:
  AWS_DRS_API DataReplicationInfo() = default;
  AWS_DRS_API DataReplicationInfo(Aws::Utils::Json::JsonView jsonValue);
  AWS_DRS_API DataReplicationInfo& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_DRS_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const DataReplicationError& GetDataReplicationError() const { return m_dataReplicationError; }
  inline bool DataReplicationErrorHasBeenSet() const { return m_dataReplicationErrorHasBeenSet; }
  template <typename DataReplicationErrorT = DataReplicationError>
  void SetDataReplicationError(DataReplicationErrorT&& value) {
    m_dataReplicationErrorHasBeenSet = true;
    m_dataReplicationError = std::forward<DataReplicationErrorT>(value);
  }
  template <typename DataReplicationErrorT = DataReplicationError>
  DataReplicationInfo& WithDataReplicationError(DataReplicationErrorT&& value) {
    SetDataReplicationError(std::forward<DataReplicationErrorT>(value));
    return *this;
  }
 
 
  inline const DataReplicationInitiation& GetDataReplicationInitiation() const { return m_dataReplicationInitiation; }
  inline bool DataReplicationInitiationHasBeenSet() const { return m_dataReplicationInitiationHasBeenSet; }
  template <typename DataReplicationInitiationT = DataReplicationInitiation>
  void SetDataReplicationInitiation(DataReplicationInitiationT&& value) {
    m_dataReplicationInitiationHasBeenSet = true;
    m_dataReplicationInitiation = std::forward<DataReplicationInitiationT>(value);
  }
  template <typename DataReplicationInitiationT = DataReplicationInitiation>
  DataReplicationInfo& WithDataReplicationInitiation(DataReplicationInitiationT&& value) {
    SetDataReplicationInitiation(std::forward<DataReplicationInitiationT>(value));
    return *this;
  }
 
 
  inline DataReplicationState GetDataReplicationState() const { return m_dataReplicationState; }
  inline bool DataReplicationStateHasBeenSet() const { return m_dataReplicationStateHasBeenSet; }
  inline void SetDataReplicationState(DataReplicationState value) {
    m_dataReplicationStateHasBeenSet = true;
    m_dataReplicationState = value;
  }
  inline DataReplicationInfo& WithDataReplicationState(DataReplicationState value) {
    SetDataReplicationState(value);
    return *this;
  }
 
 
  inline const Aws::String& GetEtaDateTime() const { return m_etaDateTime; }
  inline bool EtaDateTimeHasBeenSet() const { return m_etaDateTimeHasBeenSet; }
  template <typename EtaDateTimeT = Aws::String>
  void SetEtaDateTime(EtaDateTimeT&& value) {
    m_etaDateTimeHasBeenSet = true;
    m_etaDateTime = std::forward<EtaDateTimeT>(value);
  }
  template <typename EtaDateTimeT = Aws::String>
  DataReplicationInfo& WithEtaDateTime(EtaDateTimeT&& value) {
    SetEtaDateTime(std::forward<EtaDateTimeT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetLagDuration() const { return m_lagDuration; }
  inline bool LagDurationHasBeenSet() const { return m_lagDurationHasBeenSet; }
  template <typename LagDurationT = Aws::String>
  void SetLagDuration(LagDurationT&& value) {
    m_lagDurationHasBeenSet = true;
    m_lagDuration = std::forward<LagDurationT>(value);
  }
  template <typename LagDurationT = Aws::String>
  DataReplicationInfo& WithLagDuration(LagDurationT&& value) {
    SetLagDuration(std::forward<LagDurationT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<DataReplicationInfoReplicatedDisk>& GetReplicatedDisks() const { return m_replicatedDisks; }
  inline bool ReplicatedDisksHasBeenSet() const { return m_replicatedDisksHasBeenSet; }
  template <typename ReplicatedDisksT = Aws::Vector<DataReplicationInfoReplicatedDisk>>
  void SetReplicatedDisks(ReplicatedDisksT&& value) {
    m_replicatedDisksHasBeenSet = true;
    m_replicatedDisks = std::forward<ReplicatedDisksT>(value);
  }
  template <typename ReplicatedDisksT = Aws::Vector<DataReplicationInfoReplicatedDisk>>
  DataReplicationInfo& WithReplicatedDisks(ReplicatedDisksT&& value) {
    SetReplicatedDisks(std::forward<ReplicatedDisksT>(value));
    return *this;
  }
  template <typename ReplicatedDisksT = DataReplicationInfoReplicatedDisk>
  DataReplicationInfo& AddReplicatedDisks(ReplicatedDisksT&& value) {
    m_replicatedDisksHasBeenSet = true;
    m_replicatedDisks.emplace_back(std::forward<ReplicatedDisksT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetStagingAvailabilityZone() const { return m_stagingAvailabilityZone; }
  inline bool StagingAvailabilityZoneHasBeenSet() const { return m_stagingAvailabilityZoneHasBeenSet; }
  template <typename StagingAvailabilityZoneT = Aws::String>
  void SetStagingAvailabilityZone(StagingAvailabilityZoneT&& value) {
    m_stagingAvailabilityZoneHasBeenSet = true;
    m_stagingAvailabilityZone = std::forward<StagingAvailabilityZoneT>(value);
  }
  template <typename StagingAvailabilityZoneT = Aws::String>
  DataReplicationInfo& WithStagingAvailabilityZone(StagingAvailabilityZoneT&& value) {
    SetStagingAvailabilityZone(std::forward<StagingAvailabilityZoneT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetStagingOutpostArn() const { return m_stagingOutpostArn; }
  inline bool StagingOutpostArnHasBeenSet() const { return m_stagingOutpostArnHasBeenSet; }
  template <typename StagingOutpostArnT = Aws::String>
  void SetStagingOutpostArn(StagingOutpostArnT&& value) {
    m_stagingOutpostArnHasBeenSet = true;
    m_stagingOutpostArn = std::forward<StagingOutpostArnT>(value);
  }
  template <typename StagingOutpostArnT = Aws::String>
  DataReplicationInfo& WithStagingOutpostArn(StagingOutpostArnT&& value) {
    SetStagingOutpostArn(std::forward<StagingOutpostArnT>(value));
    return *this;
  }
 private:
  DataReplicationError m_dataReplicationError;
 
  DataReplicationInitiation m_dataReplicationInitiation;
 
  DataReplicationState m_dataReplicationState{DataReplicationState::NOT_SET};
 
  Aws::String m_etaDateTime;
 
  Aws::String m_lagDuration;
 
  Aws::Vector<DataReplicationInfoReplicatedDisk> m_replicatedDisks;
 
  Aws::String m_stagingAvailabilityZone;
 
  Aws::String m_stagingOutpostArn;
  bool m_dataReplicationErrorHasBeenSet = false;
  bool m_dataReplicationInitiationHasBeenSet = false;
  bool m_dataReplicationStateHasBeenSet = false;
  bool m_etaDateTimeHasBeenSet = false;
  bool m_lagDurationHasBeenSet = false;
  bool m_replicatedDisksHasBeenSet = false;
  bool m_stagingAvailabilityZoneHasBeenSet = false;
  bool m_stagingOutpostArnHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace drs
}  // namespace Aws