DescribedExecution.h

 
#pragma once
#include <aws/awstransfer/Transfer_EXPORTS.h>
#include <aws/awstransfer/model/ExecutionResults.h>
#include <aws/awstransfer/model/ExecutionStatus.h>
#include <aws/awstransfer/model/FileLocation.h>
#include <aws/awstransfer/model/LoggingConfiguration.h>
#include <aws/awstransfer/model/PosixProfile.h>
#include <aws/awstransfer/model/ServiceMetadata.h>
#include <aws/core/utils/memory/stl/AWSString.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace Transfer {
namespace Model {
 
class DescribedExecution {
 public:
  AWS_TRANSFER_API DescribedExecution() = default;
  AWS_TRANSFER_API DescribedExecution(Aws::Utils::Json::JsonView jsonValue);
  AWS_TRANSFER_API DescribedExecution& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_TRANSFER_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetExecutionId() const { return m_executionId; }
  inline bool ExecutionIdHasBeenSet() const { return m_executionIdHasBeenSet; }
  template <typename ExecutionIdT = Aws::String>
  void SetExecutionId(ExecutionIdT&& value) {
    m_executionIdHasBeenSet = true;
    m_executionId = std::forward<ExecutionIdT>(value);
  }
  template <typename ExecutionIdT = Aws::String>
  DescribedExecution& WithExecutionId(ExecutionIdT&& value) {
    SetExecutionId(std::forward<ExecutionIdT>(value));
    return *this;
  }
 
 
  inline const FileLocation& GetInitialFileLocation() const { return m_initialFileLocation; }
  inline bool InitialFileLocationHasBeenSet() const { return m_initialFileLocationHasBeenSet; }
  template <typename InitialFileLocationT = FileLocation>
  void SetInitialFileLocation(InitialFileLocationT&& value) {
    m_initialFileLocationHasBeenSet = true;
    m_initialFileLocation = std::forward<InitialFileLocationT>(value);
  }
  template <typename InitialFileLocationT = FileLocation>
  DescribedExecution& WithInitialFileLocation(InitialFileLocationT&& value) {
    SetInitialFileLocation(std::forward<InitialFileLocationT>(value));
    return *this;
  }
 
 
  inline const ServiceMetadata& GetServiceMetadata() const { return m_serviceMetadata; }
  inline bool ServiceMetadataHasBeenSet() const { return m_serviceMetadataHasBeenSet; }
  template <typename ServiceMetadataT = ServiceMetadata>
  void SetServiceMetadata(ServiceMetadataT&& value) {
    m_serviceMetadataHasBeenSet = true;
    m_serviceMetadata = std::forward<ServiceMetadataT>(value);
  }
  template <typename ServiceMetadataT = ServiceMetadata>
  DescribedExecution& WithServiceMetadata(ServiceMetadataT&& value) {
    SetServiceMetadata(std::forward<ServiceMetadataT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetExecutionRole() const { return m_executionRole; }
  inline bool ExecutionRoleHasBeenSet() const { return m_executionRoleHasBeenSet; }
  template <typename ExecutionRoleT = Aws::String>
  void SetExecutionRole(ExecutionRoleT&& value) {
    m_executionRoleHasBeenSet = true;
    m_executionRole = std::forward<ExecutionRoleT>(value);
  }
  template <typename ExecutionRoleT = Aws::String>
  DescribedExecution& WithExecutionRole(ExecutionRoleT&& value) {
    SetExecutionRole(std::forward<ExecutionRoleT>(value));
    return *this;
  }
 
 
  inline const LoggingConfiguration& GetLoggingConfiguration() const { return m_loggingConfiguration; }
  inline bool LoggingConfigurationHasBeenSet() const { return m_loggingConfigurationHasBeenSet; }
  template <typename LoggingConfigurationT = LoggingConfiguration>
  void SetLoggingConfiguration(LoggingConfigurationT&& value) {
    m_loggingConfigurationHasBeenSet = true;
    m_loggingConfiguration = std::forward<LoggingConfigurationT>(value);
  }
  template <typename LoggingConfigurationT = LoggingConfiguration>
  DescribedExecution& WithLoggingConfiguration(LoggingConfigurationT&& value) {
    SetLoggingConfiguration(std::forward<LoggingConfigurationT>(value));
    return *this;
  }
 
 
  inline const PosixProfile& GetPosixProfile() const { return m_posixProfile; }
  inline bool PosixProfileHasBeenSet() const { return m_posixProfileHasBeenSet; }
  template <typename PosixProfileT = PosixProfile>
  void SetPosixProfile(PosixProfileT&& value) {
    m_posixProfileHasBeenSet = true;
    m_posixProfile = std::forward<PosixProfileT>(value);
  }
  template <typename PosixProfileT = PosixProfile>
  DescribedExecution& WithPosixProfile(PosixProfileT&& value) {
    SetPosixProfile(std::forward<PosixProfileT>(value));
    return *this;
  }
 
 
  inline ExecutionStatus GetStatus() const { return m_status; }
  inline bool StatusHasBeenSet() const { return m_statusHasBeenSet; }
  inline void SetStatus(ExecutionStatus value) {
    m_statusHasBeenSet = true;
    m_status = value;
  }
  inline DescribedExecution& WithStatus(ExecutionStatus value) {
    SetStatus(value);
    return *this;
  }
 
 
  inline const ExecutionResults& GetResults() const { return m_results; }
  inline bool ResultsHasBeenSet() const { return m_resultsHasBeenSet; }
  template <typename ResultsT = ExecutionResults>
  void SetResults(ResultsT&& value) {
    m_resultsHasBeenSet = true;
    m_results = std::forward<ResultsT>(value);
  }
  template <typename ResultsT = ExecutionResults>
  DescribedExecution& WithResults(ResultsT&& value) {
    SetResults(std::forward<ResultsT>(value));
    return *this;
  }
 private:
  Aws::String m_executionId;
 
  FileLocation m_initialFileLocation;
 
  ServiceMetadata m_serviceMetadata;
 
  Aws::String m_executionRole;
 
  LoggingConfiguration m_loggingConfiguration;
 
  PosixProfile m_posixProfile;
 
  ExecutionStatus m_status{ExecutionStatus::NOT_SET};
 
  ExecutionResults m_results;
  bool m_executionIdHasBeenSet = false;
  bool m_initialFileLocationHasBeenSet = false;
  bool m_serviceMetadataHasBeenSet = false;
  bool m_executionRoleHasBeenSet = false;
  bool m_loggingConfigurationHasBeenSet = false;
  bool m_posixProfileHasBeenSet = false;
  bool m_statusHasBeenSet = false;
  bool m_resultsHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Transfer
}  // namespace Aws