BacktrackDBClusterResult.h

 
#pragma once
#include <aws/core/utils/DateTime.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/rds/RDS_EXPORTS.h>
#include <aws/rds/model/ResponseMetadata.h>
 
#include <utility>
 
namespace Aws {
template <typename RESULT_TYPE>
class AmazonWebServiceResult;
 
namespace Utils {
namespace Xml {
class XmlDocument;
}  // namespace Xml
}  // namespace Utils
namespace RDS {
namespace Model {
class BacktrackDBClusterResult {
 public:
  AWS_RDS_API BacktrackDBClusterResult() = default;
  AWS_RDS_API BacktrackDBClusterResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
  AWS_RDS_API BacktrackDBClusterResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
 
 
  inline const Aws::String& GetDBClusterIdentifier() const { return m_dBClusterIdentifier; }
  template <typename DBClusterIdentifierT = Aws::String>
  void SetDBClusterIdentifier(DBClusterIdentifierT&& value) {
    m_dBClusterIdentifierHasBeenSet = true;
    m_dBClusterIdentifier = std::forward<DBClusterIdentifierT>(value);
  }
  template <typename DBClusterIdentifierT = Aws::String>
  BacktrackDBClusterResult& WithDBClusterIdentifier(DBClusterIdentifierT&& value) {
    SetDBClusterIdentifier(std::forward<DBClusterIdentifierT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetBacktrackIdentifier() const { return m_backtrackIdentifier; }
  template <typename BacktrackIdentifierT = Aws::String>
  void SetBacktrackIdentifier(BacktrackIdentifierT&& value) {
    m_backtrackIdentifierHasBeenSet = true;
    m_backtrackIdentifier = std::forward<BacktrackIdentifierT>(value);
  }
  template <typename BacktrackIdentifierT = Aws::String>
  BacktrackDBClusterResult& WithBacktrackIdentifier(BacktrackIdentifierT&& value) {
    SetBacktrackIdentifier(std::forward<BacktrackIdentifierT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetBacktrackTo() const { return m_backtrackTo; }
  template <typename BacktrackToT = Aws::Utils::DateTime>
  void SetBacktrackTo(BacktrackToT&& value) {
    m_backtrackToHasBeenSet = true;
    m_backtrackTo = std::forward<BacktrackToT>(value);
  }
  template <typename BacktrackToT = Aws::Utils::DateTime>
  BacktrackDBClusterResult& WithBacktrackTo(BacktrackToT&& value) {
    SetBacktrackTo(std::forward<BacktrackToT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetBacktrackedFrom() const { return m_backtrackedFrom; }
  template <typename BacktrackedFromT = Aws::Utils::DateTime>
  void SetBacktrackedFrom(BacktrackedFromT&& value) {
    m_backtrackedFromHasBeenSet = true;
    m_backtrackedFrom = std::forward<BacktrackedFromT>(value);
  }
  template <typename BacktrackedFromT = Aws::Utils::DateTime>
  BacktrackDBClusterResult& WithBacktrackedFrom(BacktrackedFromT&& value) {
    SetBacktrackedFrom(std::forward<BacktrackedFromT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetBacktrackRequestCreationTime() const { return m_backtrackRequestCreationTime; }
  template <typename BacktrackRequestCreationTimeT = Aws::Utils::DateTime>
  void SetBacktrackRequestCreationTime(BacktrackRequestCreationTimeT&& value) {
    m_backtrackRequestCreationTimeHasBeenSet = true;
    m_backtrackRequestCreationTime = std::forward<BacktrackRequestCreationTimeT>(value);
  }
  template <typename BacktrackRequestCreationTimeT = Aws::Utils::DateTime>
  BacktrackDBClusterResult& WithBacktrackRequestCreationTime(BacktrackRequestCreationTimeT&& value) {
    SetBacktrackRequestCreationTime(std::forward<BacktrackRequestCreationTimeT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetStatus() const { return m_status; }
  template <typename StatusT = Aws::String>
  void SetStatus(StatusT&& value) {
    m_statusHasBeenSet = true;
    m_status = std::forward<StatusT>(value);
  }
  template <typename StatusT = Aws::String>
  BacktrackDBClusterResult& WithStatus(StatusT&& value) {
    SetStatus(std::forward<StatusT>(value));
    return *this;
  }
 
 
  inline const ResponseMetadata& GetResponseMetadata() const { return m_responseMetadata; }
  template <typename ResponseMetadataT = ResponseMetadata>
  void SetResponseMetadata(ResponseMetadataT&& value) {
    m_responseMetadataHasBeenSet = true;
    m_responseMetadata = std::forward<ResponseMetadataT>(value);
  }
  template <typename ResponseMetadataT = ResponseMetadata>
  BacktrackDBClusterResult& WithResponseMetadata(ResponseMetadataT&& value) {
    SetResponseMetadata(std::forward<ResponseMetadataT>(value));
    return *this;
  }
 private:
  Aws::String m_dBClusterIdentifier;
 
  Aws::String m_backtrackIdentifier;
 
  Aws::Utils::DateTime m_backtrackTo{};
 
  Aws::Utils::DateTime m_backtrackedFrom{};
 
  Aws::Utils::DateTime m_backtrackRequestCreationTime{};
 
  Aws::String m_status;
 
  ResponseMetadata m_responseMetadata;
  bool m_dBClusterIdentifierHasBeenSet = false;
  bool m_backtrackIdentifierHasBeenSet = false;
  bool m_backtrackToHasBeenSet = false;
  bool m_backtrackedFromHasBeenSet = false;
  bool m_backtrackRequestCreationTimeHasBeenSet = false;
  bool m_statusHasBeenSet = false;
  bool m_responseMetadataHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace RDS
}  // namespace Aws