Replication.h

 
#pragma once
#include <aws/core/utils/DateTime.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/dms/DatabaseMigrationService_EXPORTS.h>
#include <aws/dms/model/MigrationTypeValue.h>
#include <aws/dms/model/PremigrationAssessmentStatus.h>
#include <aws/dms/model/ProvisionData.h>
#include <aws/dms/model/ReplicationStats.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace DatabaseMigrationService {
namespace Model {
 
class Replication {
 public:
  AWS_DATABASEMIGRATIONSERVICE_API Replication() = default;
  AWS_DATABASEMIGRATIONSERVICE_API Replication(Aws::Utils::Json::JsonView jsonValue);
  AWS_DATABASEMIGRATIONSERVICE_API Replication& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_DATABASEMIGRATIONSERVICE_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetReplicationConfigIdentifier() const { return m_replicationConfigIdentifier; }
  inline bool ReplicationConfigIdentifierHasBeenSet() const { return m_replicationConfigIdentifierHasBeenSet; }
  template <typename ReplicationConfigIdentifierT = Aws::String>
  void SetReplicationConfigIdentifier(ReplicationConfigIdentifierT&& value) {
    m_replicationConfigIdentifierHasBeenSet = true;
    m_replicationConfigIdentifier = std::forward<ReplicationConfigIdentifierT>(value);
  }
  template <typename ReplicationConfigIdentifierT = Aws::String>
  Replication& WithReplicationConfigIdentifier(ReplicationConfigIdentifierT&& value) {
    SetReplicationConfigIdentifier(std::forward<ReplicationConfigIdentifierT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetReplicationConfigArn() const { return m_replicationConfigArn; }
  inline bool ReplicationConfigArnHasBeenSet() const { return m_replicationConfigArnHasBeenSet; }
  template <typename ReplicationConfigArnT = Aws::String>
  void SetReplicationConfigArn(ReplicationConfigArnT&& value) {
    m_replicationConfigArnHasBeenSet = true;
    m_replicationConfigArn = std::forward<ReplicationConfigArnT>(value);
  }
  template <typename ReplicationConfigArnT = Aws::String>
  Replication& WithReplicationConfigArn(ReplicationConfigArnT&& value) {
    SetReplicationConfigArn(std::forward<ReplicationConfigArnT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetSourceEndpointArn() const { return m_sourceEndpointArn; }
  inline bool SourceEndpointArnHasBeenSet() const { return m_sourceEndpointArnHasBeenSet; }
  template <typename SourceEndpointArnT = Aws::String>
  void SetSourceEndpointArn(SourceEndpointArnT&& value) {
    m_sourceEndpointArnHasBeenSet = true;
    m_sourceEndpointArn = std::forward<SourceEndpointArnT>(value);
  }
  template <typename SourceEndpointArnT = Aws::String>
  Replication& WithSourceEndpointArn(SourceEndpointArnT&& value) {
    SetSourceEndpointArn(std::forward<SourceEndpointArnT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetTargetEndpointArn() const { return m_targetEndpointArn; }
  inline bool TargetEndpointArnHasBeenSet() const { return m_targetEndpointArnHasBeenSet; }
  template <typename TargetEndpointArnT = Aws::String>
  void SetTargetEndpointArn(TargetEndpointArnT&& value) {
    m_targetEndpointArnHasBeenSet = true;
    m_targetEndpointArn = std::forward<TargetEndpointArnT>(value);
  }
  template <typename TargetEndpointArnT = Aws::String>
  Replication& WithTargetEndpointArn(TargetEndpointArnT&& value) {
    SetTargetEndpointArn(std::forward<TargetEndpointArnT>(value));
    return *this;
  }
 
 
  inline MigrationTypeValue GetReplicationType() const { return m_replicationType; }
  inline bool ReplicationTypeHasBeenSet() const { return m_replicationTypeHasBeenSet; }
  inline void SetReplicationType(MigrationTypeValue value) {
    m_replicationTypeHasBeenSet = true;
    m_replicationType = value;
  }
  inline Replication& WithReplicationType(MigrationTypeValue value) {
    SetReplicationType(value);
    return *this;
  }
 
 
  inline const Aws::String& GetStatus() const { return m_status; }
  inline bool StatusHasBeenSet() const { return m_statusHasBeenSet; }
  template <typename StatusT = Aws::String>
  void SetStatus(StatusT&& value) {
    m_statusHasBeenSet = true;
    m_status = std::forward<StatusT>(value);
  }
  template <typename StatusT = Aws::String>
  Replication& WithStatus(StatusT&& value) {
    SetStatus(std::forward<StatusT>(value));
    return *this;
  }
 
 
  inline const ProvisionData& GetProvisionData() const { return m_provisionData; }
  inline bool ProvisionDataHasBeenSet() const { return m_provisionDataHasBeenSet; }
  template <typename ProvisionDataT = ProvisionData>
  void SetProvisionData(ProvisionDataT&& value) {
    m_provisionDataHasBeenSet = true;
    m_provisionData = std::forward<ProvisionDataT>(value);
  }
  template <typename ProvisionDataT = ProvisionData>
  Replication& WithProvisionData(ProvisionDataT&& value) {
    SetProvisionData(std::forward<ProvisionDataT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<PremigrationAssessmentStatus>& GetPremigrationAssessmentStatuses() const {
    return m_premigrationAssessmentStatuses;
  }
  inline bool PremigrationAssessmentStatusesHasBeenSet() const { return m_premigrationAssessmentStatusesHasBeenSet; }
  template <typename PremigrationAssessmentStatusesT = Aws::Vector<PremigrationAssessmentStatus>>
  void SetPremigrationAssessmentStatuses(PremigrationAssessmentStatusesT&& value) {
    m_premigrationAssessmentStatusesHasBeenSet = true;
    m_premigrationAssessmentStatuses = std::forward<PremigrationAssessmentStatusesT>(value);
  }
  template <typename PremigrationAssessmentStatusesT = Aws::Vector<PremigrationAssessmentStatus>>
  Replication& WithPremigrationAssessmentStatuses(PremigrationAssessmentStatusesT&& value) {
    SetPremigrationAssessmentStatuses(std::forward<PremigrationAssessmentStatusesT>(value));
    return *this;
  }
  template <typename PremigrationAssessmentStatusesT = PremigrationAssessmentStatus>
  Replication& AddPremigrationAssessmentStatuses(PremigrationAssessmentStatusesT&& value) {
    m_premigrationAssessmentStatusesHasBeenSet = true;
    m_premigrationAssessmentStatuses.emplace_back(std::forward<PremigrationAssessmentStatusesT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetStopReason() const { return m_stopReason; }
  inline bool StopReasonHasBeenSet() const { return m_stopReasonHasBeenSet; }
  template <typename StopReasonT = Aws::String>
  void SetStopReason(StopReasonT&& value) {
    m_stopReasonHasBeenSet = true;
    m_stopReason = std::forward<StopReasonT>(value);
  }
  template <typename StopReasonT = Aws::String>
  Replication& WithStopReason(StopReasonT&& value) {
    SetStopReason(std::forward<StopReasonT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetFailureMessages() const { return m_failureMessages; }
  inline bool FailureMessagesHasBeenSet() const { return m_failureMessagesHasBeenSet; }
  template <typename FailureMessagesT = Aws::Vector<Aws::String>>
  void SetFailureMessages(FailureMessagesT&& value) {
    m_failureMessagesHasBeenSet = true;
    m_failureMessages = std::forward<FailureMessagesT>(value);
  }
  template <typename FailureMessagesT = Aws::Vector<Aws::String>>
  Replication& WithFailureMessages(FailureMessagesT&& value) {
    SetFailureMessages(std::forward<FailureMessagesT>(value));
    return *this;
  }
  template <typename FailureMessagesT = Aws::String>
  Replication& AddFailureMessages(FailureMessagesT&& value) {
    m_failureMessagesHasBeenSet = true;
    m_failureMessages.emplace_back(std::forward<FailureMessagesT>(value));
    return *this;
  }
 
 
  inline const ReplicationStats& GetReplicationStats() const { return m_replicationStats; }
  inline bool ReplicationStatsHasBeenSet() const { return m_replicationStatsHasBeenSet; }
  template <typename ReplicationStatsT = ReplicationStats>
  void SetReplicationStats(ReplicationStatsT&& value) {
    m_replicationStatsHasBeenSet = true;
    m_replicationStats = std::forward<ReplicationStatsT>(value);
  }
  template <typename ReplicationStatsT = ReplicationStats>
  Replication& WithReplicationStats(ReplicationStatsT&& value) {
    SetReplicationStats(std::forward<ReplicationStatsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetStartReplicationType() const { return m_startReplicationType; }
  inline bool StartReplicationTypeHasBeenSet() const { return m_startReplicationTypeHasBeenSet; }
  template <typename StartReplicationTypeT = Aws::String>
  void SetStartReplicationType(StartReplicationTypeT&& value) {
    m_startReplicationTypeHasBeenSet = true;
    m_startReplicationType = std::forward<StartReplicationTypeT>(value);
  }
  template <typename StartReplicationTypeT = Aws::String>
  Replication& WithStartReplicationType(StartReplicationTypeT&& value) {
    SetStartReplicationType(std::forward<StartReplicationTypeT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetCdcStartTime() const { return m_cdcStartTime; }
  inline bool CdcStartTimeHasBeenSet() const { return m_cdcStartTimeHasBeenSet; }
  template <typename CdcStartTimeT = Aws::Utils::DateTime>
  void SetCdcStartTime(CdcStartTimeT&& value) {
    m_cdcStartTimeHasBeenSet = true;
    m_cdcStartTime = std::forward<CdcStartTimeT>(value);
  }
  template <typename CdcStartTimeT = Aws::Utils::DateTime>
  Replication& WithCdcStartTime(CdcStartTimeT&& value) {
    SetCdcStartTime(std::forward<CdcStartTimeT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetCdcStartPosition() const { return m_cdcStartPosition; }
  inline bool CdcStartPositionHasBeenSet() const { return m_cdcStartPositionHasBeenSet; }
  template <typename CdcStartPositionT = Aws::String>
  void SetCdcStartPosition(CdcStartPositionT&& value) {
    m_cdcStartPositionHasBeenSet = true;
    m_cdcStartPosition = std::forward<CdcStartPositionT>(value);
  }
  template <typename CdcStartPositionT = Aws::String>
  Replication& WithCdcStartPosition(CdcStartPositionT&& value) {
    SetCdcStartPosition(std::forward<CdcStartPositionT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetCdcStopPosition() const { return m_cdcStopPosition; }
  inline bool CdcStopPositionHasBeenSet() const { return m_cdcStopPositionHasBeenSet; }
  template <typename CdcStopPositionT = Aws::String>
  void SetCdcStopPosition(CdcStopPositionT&& value) {
    m_cdcStopPositionHasBeenSet = true;
    m_cdcStopPosition = std::forward<CdcStopPositionT>(value);
  }
  template <typename CdcStopPositionT = Aws::String>
  Replication& WithCdcStopPosition(CdcStopPositionT&& value) {
    SetCdcStopPosition(std::forward<CdcStopPositionT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetRecoveryCheckpoint() const { return m_recoveryCheckpoint; }
  inline bool RecoveryCheckpointHasBeenSet() const { return m_recoveryCheckpointHasBeenSet; }
  template <typename RecoveryCheckpointT = Aws::String>
  void SetRecoveryCheckpoint(RecoveryCheckpointT&& value) {
    m_recoveryCheckpointHasBeenSet = true;
    m_recoveryCheckpoint = std::forward<RecoveryCheckpointT>(value);
  }
  template <typename RecoveryCheckpointT = Aws::String>
  Replication& WithRecoveryCheckpoint(RecoveryCheckpointT&& value) {
    SetRecoveryCheckpoint(std::forward<RecoveryCheckpointT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetReplicationCreateTime() const { return m_replicationCreateTime; }
  inline bool ReplicationCreateTimeHasBeenSet() const { return m_replicationCreateTimeHasBeenSet; }
  template <typename ReplicationCreateTimeT = Aws::Utils::DateTime>
  void SetReplicationCreateTime(ReplicationCreateTimeT&& value) {
    m_replicationCreateTimeHasBeenSet = true;
    m_replicationCreateTime = std::forward<ReplicationCreateTimeT>(value);
  }
  template <typename ReplicationCreateTimeT = Aws::Utils::DateTime>
  Replication& WithReplicationCreateTime(ReplicationCreateTimeT&& value) {
    SetReplicationCreateTime(std::forward<ReplicationCreateTimeT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetReplicationUpdateTime() const { return m_replicationUpdateTime; }
  inline bool ReplicationUpdateTimeHasBeenSet() const { return m_replicationUpdateTimeHasBeenSet; }
  template <typename ReplicationUpdateTimeT = Aws::Utils::DateTime>
  void SetReplicationUpdateTime(ReplicationUpdateTimeT&& value) {
    m_replicationUpdateTimeHasBeenSet = true;
    m_replicationUpdateTime = std::forward<ReplicationUpdateTimeT>(value);
  }
  template <typename ReplicationUpdateTimeT = Aws::Utils::DateTime>
  Replication& WithReplicationUpdateTime(ReplicationUpdateTimeT&& value) {
    SetReplicationUpdateTime(std::forward<ReplicationUpdateTimeT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetReplicationLastStopTime() const { return m_replicationLastStopTime; }
  inline bool ReplicationLastStopTimeHasBeenSet() const { return m_replicationLastStopTimeHasBeenSet; }
  template <typename ReplicationLastStopTimeT = Aws::Utils::DateTime>
  void SetReplicationLastStopTime(ReplicationLastStopTimeT&& value) {
    m_replicationLastStopTimeHasBeenSet = true;
    m_replicationLastStopTime = std::forward<ReplicationLastStopTimeT>(value);
  }
  template <typename ReplicationLastStopTimeT = Aws::Utils::DateTime>
  Replication& WithReplicationLastStopTime(ReplicationLastStopTimeT&& value) {
    SetReplicationLastStopTime(std::forward<ReplicationLastStopTimeT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetReplicationDeprovisionTime() const { return m_replicationDeprovisionTime; }
  inline bool ReplicationDeprovisionTimeHasBeenSet() const { return m_replicationDeprovisionTimeHasBeenSet; }
  template <typename ReplicationDeprovisionTimeT = Aws::Utils::DateTime>
  void SetReplicationDeprovisionTime(ReplicationDeprovisionTimeT&& value) {
    m_replicationDeprovisionTimeHasBeenSet = true;
    m_replicationDeprovisionTime = std::forward<ReplicationDeprovisionTimeT>(value);
  }
  template <typename ReplicationDeprovisionTimeT = Aws::Utils::DateTime>
  Replication& WithReplicationDeprovisionTime(ReplicationDeprovisionTimeT&& value) {
    SetReplicationDeprovisionTime(std::forward<ReplicationDeprovisionTimeT>(value));
    return *this;
  }
 
 
  inline bool GetIsReadOnly() const { return m_isReadOnly; }
  inline bool IsReadOnlyHasBeenSet() const { return m_isReadOnlyHasBeenSet; }
  inline void SetIsReadOnly(bool value) {
    m_isReadOnlyHasBeenSet = true;
    m_isReadOnly = value;
  }
  inline Replication& WithIsReadOnly(bool value) {
    SetIsReadOnly(value);
    return *this;
  }
 private:
  Aws::String m_replicationConfigIdentifier;
 
  Aws::String m_replicationConfigArn;
 
  Aws::String m_sourceEndpointArn;
 
  Aws::String m_targetEndpointArn;
 
  MigrationTypeValue m_replicationType{MigrationTypeValue::NOT_SET};
 
  Aws::String m_status;
 
  ProvisionData m_provisionData;
 
  Aws::Vector<PremigrationAssessmentStatus> m_premigrationAssessmentStatuses;
 
  Aws::String m_stopReason;
 
  Aws::Vector<Aws::String> m_failureMessages;
 
  ReplicationStats m_replicationStats;
 
  Aws::String m_startReplicationType;
 
  Aws::Utils::DateTime m_cdcStartTime{};
 
  Aws::String m_cdcStartPosition;
 
  Aws::String m_cdcStopPosition;
 
  Aws::String m_recoveryCheckpoint;
 
  Aws::Utils::DateTime m_replicationCreateTime{};
 
  Aws::Utils::DateTime m_replicationUpdateTime{};
 
  Aws::Utils::DateTime m_replicationLastStopTime{};
 
  Aws::Utils::DateTime m_replicationDeprovisionTime{};
 
  bool m_isReadOnly{false};
  bool m_replicationConfigIdentifierHasBeenSet = false;
  bool m_replicationConfigArnHasBeenSet = false;
  bool m_sourceEndpointArnHasBeenSet = false;
  bool m_targetEndpointArnHasBeenSet = false;
  bool m_replicationTypeHasBeenSet = false;
  bool m_statusHasBeenSet = false;
  bool m_provisionDataHasBeenSet = false;
  bool m_premigrationAssessmentStatusesHasBeenSet = false;
  bool m_stopReasonHasBeenSet = false;
  bool m_failureMessagesHasBeenSet = false;
  bool m_replicationStatsHasBeenSet = false;
  bool m_startReplicationTypeHasBeenSet = false;
  bool m_cdcStartTimeHasBeenSet = false;
  bool m_cdcStartPositionHasBeenSet = false;
  bool m_cdcStopPositionHasBeenSet = false;
  bool m_recoveryCheckpointHasBeenSet = false;
  bool m_replicationCreateTimeHasBeenSet = false;
  bool m_replicationUpdateTimeHasBeenSet = false;
  bool m_replicationLastStopTimeHasBeenSet = false;
  bool m_replicationDeprovisionTimeHasBeenSet = false;
  bool m_isReadOnlyHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace DatabaseMigrationService
}  // namespace Aws