StartRunRequest.h

 
#pragma once
#include <aws/core/utils/Document.h>
#include <aws/core/utils/UUID.h>
#include <aws/core/utils/memory/stl/AWSMap.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/omics/OmicsRequest.h>
#include <aws/omics/Omics_EXPORTS.h>
#include <aws/omics/model/CacheBehavior.h>
#include <aws/omics/model/NetworkingMode.h>
#include <aws/omics/model/RunLogLevel.h>
#include <aws/omics/model/RunRetentionMode.h>
#include <aws/omics/model/StorageType.h>
#include <aws/omics/model/WorkflowType.h>
 
#include <utility>
 
namespace Aws {
namespace Omics {
namespace Model {
 
class StartRunRequest : public OmicsRequest {
 public:
  AWS_OMICS_API StartRunRequest() = default;
 
  // Service request name is the Operation name which will send this request out,
  // each operation should has unique request name, so that we can get operation's name from this request.
  // Note: this is not true for response, multiple operations may have the same response name,
  // so we can not get operation's name from response.
  inline virtual const char* GetServiceRequestName() const override { return "StartRun"; }
 
  AWS_OMICS_API Aws::String SerializePayload() const override;
 
 
  inline const Aws::String& GetWorkflowId() const { return m_workflowId; }
  inline bool WorkflowIdHasBeenSet() const { return m_workflowIdHasBeenSet; }
  template <typename WorkflowIdT = Aws::String>
  void SetWorkflowId(WorkflowIdT&& value) {
    m_workflowIdHasBeenSet = true;
    m_workflowId = std::forward<WorkflowIdT>(value);
  }
  template <typename WorkflowIdT = Aws::String>
  StartRunRequest& WithWorkflowId(WorkflowIdT&& value) {
    SetWorkflowId(std::forward<WorkflowIdT>(value));
    return *this;
  }
 
 
  inline WorkflowType GetWorkflowType() const { return m_workflowType; }
  inline bool WorkflowTypeHasBeenSet() const { return m_workflowTypeHasBeenSet; }
  inline void SetWorkflowType(WorkflowType value) {
    m_workflowTypeHasBeenSet = true;
    m_workflowType = value;
  }
  inline StartRunRequest& WithWorkflowType(WorkflowType value) {
    SetWorkflowType(value);
    return *this;
  }
 
 
  inline const Aws::String& GetRunId() const { return m_runId; }
  inline bool RunIdHasBeenSet() const { return m_runIdHasBeenSet; }
  template <typename RunIdT = Aws::String>
  void SetRunId(RunIdT&& value) {
    m_runIdHasBeenSet = true;
    m_runId = std::forward<RunIdT>(value);
  }
  template <typename RunIdT = Aws::String>
  StartRunRequest& WithRunId(RunIdT&& value) {
    SetRunId(std::forward<RunIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetRoleArn() const { return m_roleArn; }
  inline bool RoleArnHasBeenSet() const { return m_roleArnHasBeenSet; }
  template <typename RoleArnT = Aws::String>
  void SetRoleArn(RoleArnT&& value) {
    m_roleArnHasBeenSet = true;
    m_roleArn = std::forward<RoleArnT>(value);
  }
  template <typename RoleArnT = Aws::String>
  StartRunRequest& WithRoleArn(RoleArnT&& value) {
    SetRoleArn(std::forward<RoleArnT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetName() const { return m_name; }
  inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
  template <typename NameT = Aws::String>
  void SetName(NameT&& value) {
    m_nameHasBeenSet = true;
    m_name = std::forward<NameT>(value);
  }
  template <typename NameT = Aws::String>
  StartRunRequest& WithName(NameT&& value) {
    SetName(std::forward<NameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetCacheId() const { return m_cacheId; }
  inline bool CacheIdHasBeenSet() const { return m_cacheIdHasBeenSet; }
  template <typename CacheIdT = Aws::String>
  void SetCacheId(CacheIdT&& value) {
    m_cacheIdHasBeenSet = true;
    m_cacheId = std::forward<CacheIdT>(value);
  }
  template <typename CacheIdT = Aws::String>
  StartRunRequest& WithCacheId(CacheIdT&& value) {
    SetCacheId(std::forward<CacheIdT>(value));
    return *this;
  }
 
 
  inline CacheBehavior GetCacheBehavior() const { return m_cacheBehavior; }
  inline bool CacheBehaviorHasBeenSet() const { return m_cacheBehaviorHasBeenSet; }
  inline void SetCacheBehavior(CacheBehavior value) {
    m_cacheBehaviorHasBeenSet = true;
    m_cacheBehavior = value;
  }
  inline StartRunRequest& WithCacheBehavior(CacheBehavior value) {
    SetCacheBehavior(value);
    return *this;
  }
 
 
  inline const Aws::String& GetRunGroupId() const { return m_runGroupId; }
  inline bool RunGroupIdHasBeenSet() const { return m_runGroupIdHasBeenSet; }
  template <typename RunGroupIdT = Aws::String>
  void SetRunGroupId(RunGroupIdT&& value) {
    m_runGroupIdHasBeenSet = true;
    m_runGroupId = std::forward<RunGroupIdT>(value);
  }
  template <typename RunGroupIdT = Aws::String>
  StartRunRequest& WithRunGroupId(RunGroupIdT&& value) {
    SetRunGroupId(std::forward<RunGroupIdT>(value));
    return *this;
  }
 
 
  inline int GetPriority() const { return m_priority; }
  inline bool PriorityHasBeenSet() const { return m_priorityHasBeenSet; }
  inline void SetPriority(int value) {
    m_priorityHasBeenSet = true;
    m_priority = value;
  }
  inline StartRunRequest& WithPriority(int value) {
    SetPriority(value);
    return *this;
  }
 
 
  inline Aws::Utils::DocumentView GetParameters() const { return m_parameters; }
  inline bool ParametersHasBeenSet() const { return m_parametersHasBeenSet; }
  template <typename ParametersT = Aws::Utils::Document>
  void SetParameters(ParametersT&& value) {
    m_parametersHasBeenSet = true;
    m_parameters = std::forward<ParametersT>(value);
  }
  template <typename ParametersT = Aws::Utils::Document>
  StartRunRequest& WithParameters(ParametersT&& value) {
    SetParameters(std::forward<ParametersT>(value));
    return *this;
  }
 
 
  inline int GetStorageCapacity() const { return m_storageCapacity; }
  inline bool StorageCapacityHasBeenSet() const { return m_storageCapacityHasBeenSet; }
  inline void SetStorageCapacity(int value) {
    m_storageCapacityHasBeenSet = true;
    m_storageCapacity = value;
  }
  inline StartRunRequest& WithStorageCapacity(int value) {
    SetStorageCapacity(value);
    return *this;
  }
 
 
  inline const Aws::String& GetOutputUri() const { return m_outputUri; }
  inline bool OutputUriHasBeenSet() const { return m_outputUriHasBeenSet; }
  template <typename OutputUriT = Aws::String>
  void SetOutputUri(OutputUriT&& value) {
    m_outputUriHasBeenSet = true;
    m_outputUri = std::forward<OutputUriT>(value);
  }
  template <typename OutputUriT = Aws::String>
  StartRunRequest& WithOutputUri(OutputUriT&& value) {
    SetOutputUri(std::forward<OutputUriT>(value));
    return *this;
  }
 
 
  inline RunLogLevel GetLogLevel() const { return m_logLevel; }
  inline bool LogLevelHasBeenSet() const { return m_logLevelHasBeenSet; }
  inline void SetLogLevel(RunLogLevel value) {
    m_logLevelHasBeenSet = true;
    m_logLevel = value;
  }
  inline StartRunRequest& WithLogLevel(RunLogLevel value) {
    SetLogLevel(value);
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, Aws::String>& GetTags() const { return m_tags; }
  inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
  template <typename TagsT = Aws::Map<Aws::String, Aws::String>>
  void SetTags(TagsT&& value) {
    m_tagsHasBeenSet = true;
    m_tags = std::forward<TagsT>(value);
  }
  template <typename TagsT = Aws::Map<Aws::String, Aws::String>>
  StartRunRequest& WithTags(TagsT&& value) {
    SetTags(std::forward<TagsT>(value));
    return *this;
  }
  template <typename TagsKeyT = Aws::String, typename TagsValueT = Aws::String>
  StartRunRequest& AddTags(TagsKeyT&& key, TagsValueT&& value) {
    m_tagsHasBeenSet = true;
    m_tags.emplace(std::forward<TagsKeyT>(key), std::forward<TagsValueT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetRequestId() const { return m_requestId; }
  inline bool RequestIdHasBeenSet() const { return m_requestIdHasBeenSet; }
  template <typename RequestIdT = Aws::String>
  void SetRequestId(RequestIdT&& value) {
    m_requestIdHasBeenSet = true;
    m_requestId = std::forward<RequestIdT>(value);
  }
  template <typename RequestIdT = Aws::String>
  StartRunRequest& WithRequestId(RequestIdT&& value) {
    SetRequestId(std::forward<RequestIdT>(value));
    return *this;
  }
 
 
  inline RunRetentionMode GetRetentionMode() const { return m_retentionMode; }
  inline bool RetentionModeHasBeenSet() const { return m_retentionModeHasBeenSet; }
  inline void SetRetentionMode(RunRetentionMode value) {
    m_retentionModeHasBeenSet = true;
    m_retentionMode = value;
  }
  inline StartRunRequest& WithRetentionMode(RunRetentionMode value) {
    SetRetentionMode(value);
    return *this;
  }
 
 
  inline StorageType GetStorageType() const { return m_storageType; }
  inline bool StorageTypeHasBeenSet() const { return m_storageTypeHasBeenSet; }
  inline void SetStorageType(StorageType value) {
    m_storageTypeHasBeenSet = true;
    m_storageType = value;
  }
  inline StartRunRequest& WithStorageType(StorageType value) {
    SetStorageType(value);
    return *this;
  }
 
 
  inline const Aws::String& GetWorkflowOwnerId() const { return m_workflowOwnerId; }
  inline bool WorkflowOwnerIdHasBeenSet() const { return m_workflowOwnerIdHasBeenSet; }
  template <typename WorkflowOwnerIdT = Aws::String>
  void SetWorkflowOwnerId(WorkflowOwnerIdT&& value) {
    m_workflowOwnerIdHasBeenSet = true;
    m_workflowOwnerId = std::forward<WorkflowOwnerIdT>(value);
  }
  template <typename WorkflowOwnerIdT = Aws::String>
  StartRunRequest& WithWorkflowOwnerId(WorkflowOwnerIdT&& value) {
    SetWorkflowOwnerId(std::forward<WorkflowOwnerIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetWorkflowVersionName() const { return m_workflowVersionName; }
  inline bool WorkflowVersionNameHasBeenSet() const { return m_workflowVersionNameHasBeenSet; }
  template <typename WorkflowVersionNameT = Aws::String>
  void SetWorkflowVersionName(WorkflowVersionNameT&& value) {
    m_workflowVersionNameHasBeenSet = true;
    m_workflowVersionName = std::forward<WorkflowVersionNameT>(value);
  }
  template <typename WorkflowVersionNameT = Aws::String>
  StartRunRequest& WithWorkflowVersionName(WorkflowVersionNameT&& value) {
    SetWorkflowVersionName(std::forward<WorkflowVersionNameT>(value));
    return *this;
  }
 
 
  inline NetworkingMode GetNetworkingMode() const { return m_networkingMode; }
  inline bool NetworkingModeHasBeenSet() const { return m_networkingModeHasBeenSet; }
  inline void SetNetworkingMode(NetworkingMode value) {
    m_networkingModeHasBeenSet = true;
    m_networkingMode = value;
  }
  inline StartRunRequest& WithNetworkingMode(NetworkingMode value) {
    SetNetworkingMode(value);
    return *this;
  }
 
 
  inline const Aws::String& GetConfigurationName() const { return m_configurationName; }
  inline bool ConfigurationNameHasBeenSet() const { return m_configurationNameHasBeenSet; }
  template <typename ConfigurationNameT = Aws::String>
  void SetConfigurationName(ConfigurationNameT&& value) {
    m_configurationNameHasBeenSet = true;
    m_configurationName = std::forward<ConfigurationNameT>(value);
  }
  template <typename ConfigurationNameT = Aws::String>
  StartRunRequest& WithConfigurationName(ConfigurationNameT&& value) {
    SetConfigurationName(std::forward<ConfigurationNameT>(value));
    return *this;
  }
 private:
  Aws::String m_workflowId;
 
  WorkflowType m_workflowType{WorkflowType::NOT_SET};
 
  Aws::String m_runId;
 
  Aws::String m_roleArn;
 
  Aws::String m_name;
 
  Aws::String m_cacheId;
 
  CacheBehavior m_cacheBehavior{CacheBehavior::NOT_SET};
 
  Aws::String m_runGroupId;
 
  int m_priority{0};
 
  Aws::Utils::Document m_parameters;
 
  int m_storageCapacity{0};
 
  Aws::String m_outputUri;
 
  RunLogLevel m_logLevel{RunLogLevel::NOT_SET};
 
  Aws::Map<Aws::String, Aws::String> m_tags;
 
  Aws::String m_requestId{Aws::Utils::UUID::PseudoRandomUUID()};
 
  RunRetentionMode m_retentionMode{RunRetentionMode::NOT_SET};
 
  StorageType m_storageType{StorageType::NOT_SET};
 
  Aws::String m_workflowOwnerId;
 
  Aws::String m_workflowVersionName;
 
  NetworkingMode m_networkingMode{NetworkingMode::NOT_SET};
 
  Aws::String m_configurationName;
  bool m_workflowIdHasBeenSet = false;
  bool m_workflowTypeHasBeenSet = false;
  bool m_runIdHasBeenSet = false;
  bool m_roleArnHasBeenSet = false;
  bool m_nameHasBeenSet = false;
  bool m_cacheIdHasBeenSet = false;
  bool m_cacheBehaviorHasBeenSet = false;
  bool m_runGroupIdHasBeenSet = false;
  bool m_priorityHasBeenSet = false;
  bool m_parametersHasBeenSet = false;
  bool m_storageCapacityHasBeenSet = false;
  bool m_outputUriHasBeenSet = false;
  bool m_logLevelHasBeenSet = false;
  bool m_tagsHasBeenSet = false;
  bool m_requestIdHasBeenSet = true;
  bool m_retentionModeHasBeenSet = false;
  bool m_storageTypeHasBeenSet = false;
  bool m_workflowOwnerIdHasBeenSet = false;
  bool m_workflowVersionNameHasBeenSet = false;
  bool m_networkingModeHasBeenSet = false;
  bool m_configurationNameHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Omics
}  // namespace Aws