DataPipelineClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/datapipeline/DataPipelineServiceClientModel.h>
#include <aws/datapipeline/DataPipeline_EXPORTS.h>
 
namespace Aws {
namespace DataPipeline {
class AWS_DATAPIPELINE_API DataPipelineClient : public Aws::Client::AWSJsonClient,
                                                public Aws::Client::ClientWithAsyncTemplateMethods<DataPipelineClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef DataPipelineClientConfiguration ClientConfigurationType;
  typedef DataPipelineEndpointProvider EndpointProviderType;
 
  DataPipelineClient(
      const Aws::DataPipeline::DataPipelineClientConfiguration& clientConfiguration = Aws::DataPipeline::DataPipelineClientConfiguration(),
      std::shared_ptr<DataPipelineEndpointProviderBase> endpointProvider = nullptr);
 
  DataPipelineClient(
      const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<DataPipelineEndpointProviderBase> endpointProvider = nullptr,
      const Aws::DataPipeline::DataPipelineClientConfiguration& clientConfiguration = Aws::DataPipeline::DataPipelineClientConfiguration());
 
  DataPipelineClient(
      const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
      std::shared_ptr<DataPipelineEndpointProviderBase> endpointProvider = nullptr,
      const Aws::DataPipeline::DataPipelineClientConfiguration& clientConfiguration = Aws::DataPipeline::DataPipelineClientConfiguration());
 
  /* Legacy constructors due deprecation */
  DataPipelineClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  DataPipelineClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  DataPipelineClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                     const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~DataPipelineClient();
 
  virtual Model::ActivatePipelineOutcome ActivatePipeline(const Model::ActivatePipelineRequest& request) const;
 
  template <typename ActivatePipelineRequestT = Model::ActivatePipelineRequest>
  Model::ActivatePipelineOutcomeCallable ActivatePipelineCallable(const ActivatePipelineRequestT& request) const {
    return SubmitCallable(&DataPipelineClient::ActivatePipeline, request);
  }
 
  template <typename ActivatePipelineRequestT = Model::ActivatePipelineRequest>
  void ActivatePipelineAsync(const ActivatePipelineRequestT& request, const ActivatePipelineResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataPipelineClient::ActivatePipeline, request, handler, context);
  }
 
  virtual Model::AddTagsOutcome AddTags(const Model::AddTagsRequest& request) const;
 
  template <typename AddTagsRequestT = Model::AddTagsRequest>
  Model::AddTagsOutcomeCallable AddTagsCallable(const AddTagsRequestT& request) const {
    return SubmitCallable(&DataPipelineClient::AddTags, request);
  }
 
  template <typename AddTagsRequestT = Model::AddTagsRequest>
  void AddTagsAsync(const AddTagsRequestT& request, const AddTagsResponseReceivedHandler& handler,
                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataPipelineClient::AddTags, request, handler, context);
  }
 
  virtual Model::CreatePipelineOutcome CreatePipeline(const Model::CreatePipelineRequest& request) const;
 
  template <typename CreatePipelineRequestT = Model::CreatePipelineRequest>
  Model::CreatePipelineOutcomeCallable CreatePipelineCallable(const CreatePipelineRequestT& request) const {
    return SubmitCallable(&DataPipelineClient::CreatePipeline, request);
  }
 
  template <typename CreatePipelineRequestT = Model::CreatePipelineRequest>
  void CreatePipelineAsync(const CreatePipelineRequestT& request, const CreatePipelineResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataPipelineClient::CreatePipeline, request, handler, context);
  }
 
  virtual Model::DeactivatePipelineOutcome DeactivatePipeline(const Model::DeactivatePipelineRequest& request) const;
 
  template <typename DeactivatePipelineRequestT = Model::DeactivatePipelineRequest>
  Model::DeactivatePipelineOutcomeCallable DeactivatePipelineCallable(const DeactivatePipelineRequestT& request) const {
    return SubmitCallable(&DataPipelineClient::DeactivatePipeline, request);
  }
 
  template <typename DeactivatePipelineRequestT = Model::DeactivatePipelineRequest>
  void DeactivatePipelineAsync(const DeactivatePipelineRequestT& request, const DeactivatePipelineResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataPipelineClient::DeactivatePipeline, request, handler, context);
  }
 
  virtual Model::DeletePipelineOutcome DeletePipeline(const Model::DeletePipelineRequest& request) const;
 
  template <typename DeletePipelineRequestT = Model::DeletePipelineRequest>
  Model::DeletePipelineOutcomeCallable DeletePipelineCallable(const DeletePipelineRequestT& request) const {
    return SubmitCallable(&DataPipelineClient::DeletePipeline, request);
  }
 
  template <typename DeletePipelineRequestT = Model::DeletePipelineRequest>
  void DeletePipelineAsync(const DeletePipelineRequestT& request, const DeletePipelineResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataPipelineClient::DeletePipeline, request, handler, context);
  }
 
  virtual Model::DescribeObjectsOutcome DescribeObjects(const Model::DescribeObjectsRequest& request) const;
 
  template <typename DescribeObjectsRequestT = Model::DescribeObjectsRequest>
  Model::DescribeObjectsOutcomeCallable DescribeObjectsCallable(const DescribeObjectsRequestT& request) const {
    return SubmitCallable(&DataPipelineClient::DescribeObjects, request);
  }
 
  template <typename DescribeObjectsRequestT = Model::DescribeObjectsRequest>
  void DescribeObjectsAsync(const DescribeObjectsRequestT& request, const DescribeObjectsResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataPipelineClient::DescribeObjects, request, handler, context);
  }
 
  virtual Model::DescribePipelinesOutcome DescribePipelines(const Model::DescribePipelinesRequest& request) const;
 
  template <typename DescribePipelinesRequestT = Model::DescribePipelinesRequest>
  Model::DescribePipelinesOutcomeCallable DescribePipelinesCallable(const DescribePipelinesRequestT& request) const {
    return SubmitCallable(&DataPipelineClient::DescribePipelines, request);
  }
 
  template <typename DescribePipelinesRequestT = Model::DescribePipelinesRequest>
  void DescribePipelinesAsync(const DescribePipelinesRequestT& request, const DescribePipelinesResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataPipelineClient::DescribePipelines, request, handler, context);
  }
 
  virtual Model::EvaluateExpressionOutcome EvaluateExpression(const Model::EvaluateExpressionRequest& request) const;
 
  template <typename EvaluateExpressionRequestT = Model::EvaluateExpressionRequest>
  Model::EvaluateExpressionOutcomeCallable EvaluateExpressionCallable(const EvaluateExpressionRequestT& request) const {
    return SubmitCallable(&DataPipelineClient::EvaluateExpression, request);
  }
 
  template <typename EvaluateExpressionRequestT = Model::EvaluateExpressionRequest>
  void EvaluateExpressionAsync(const EvaluateExpressionRequestT& request, const EvaluateExpressionResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataPipelineClient::EvaluateExpression, request, handler, context);
  }
 
  virtual Model::GetPipelineDefinitionOutcome GetPipelineDefinition(const Model::GetPipelineDefinitionRequest& request) const;
 
  template <typename GetPipelineDefinitionRequestT = Model::GetPipelineDefinitionRequest>
  Model::GetPipelineDefinitionOutcomeCallable GetPipelineDefinitionCallable(const GetPipelineDefinitionRequestT& request) const {
    return SubmitCallable(&DataPipelineClient::GetPipelineDefinition, request);
  }
 
  template <typename GetPipelineDefinitionRequestT = Model::GetPipelineDefinitionRequest>
  void GetPipelineDefinitionAsync(const GetPipelineDefinitionRequestT& request, const GetPipelineDefinitionResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataPipelineClient::GetPipelineDefinition, request, handler, context);
  }
 
  virtual Model::ListPipelinesOutcome ListPipelines(const Model::ListPipelinesRequest& request = {}) const;
 
  template <typename ListPipelinesRequestT = Model::ListPipelinesRequest>
  Model::ListPipelinesOutcomeCallable ListPipelinesCallable(const ListPipelinesRequestT& request = {}) const {
    return SubmitCallable(&DataPipelineClient::ListPipelines, request);
  }
 
  template <typename ListPipelinesRequestT = Model::ListPipelinesRequest>
  void ListPipelinesAsync(const ListPipelinesResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                          const ListPipelinesRequestT& request = {}) const {
    return SubmitAsync(&DataPipelineClient::ListPipelines, request, handler, context);
  }
 
  virtual Model::PollForTaskOutcome PollForTask(const Model::PollForTaskRequest& request) const;
 
  template <typename PollForTaskRequestT = Model::PollForTaskRequest>
  Model::PollForTaskOutcomeCallable PollForTaskCallable(const PollForTaskRequestT& request) const {
    return SubmitCallable(&DataPipelineClient::PollForTask, request);
  }
 
  template <typename PollForTaskRequestT = Model::PollForTaskRequest>
  void PollForTaskAsync(const PollForTaskRequestT& request, const PollForTaskResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataPipelineClient::PollForTask, request, handler, context);
  }
 
  virtual Model::PutPipelineDefinitionOutcome PutPipelineDefinition(const Model::PutPipelineDefinitionRequest& request) const;
 
  template <typename PutPipelineDefinitionRequestT = Model::PutPipelineDefinitionRequest>
  Model::PutPipelineDefinitionOutcomeCallable PutPipelineDefinitionCallable(const PutPipelineDefinitionRequestT& request) const {
    return SubmitCallable(&DataPipelineClient::PutPipelineDefinition, request);
  }
 
  template <typename PutPipelineDefinitionRequestT = Model::PutPipelineDefinitionRequest>
  void PutPipelineDefinitionAsync(const PutPipelineDefinitionRequestT& request, const PutPipelineDefinitionResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataPipelineClient::PutPipelineDefinition, request, handler, context);
  }
 
  virtual Model::QueryObjectsOutcome QueryObjects(const Model::QueryObjectsRequest& request) const;
 
  template <typename QueryObjectsRequestT = Model::QueryObjectsRequest>
  Model::QueryObjectsOutcomeCallable QueryObjectsCallable(const QueryObjectsRequestT& request) const {
    return SubmitCallable(&DataPipelineClient::QueryObjects, request);
  }
 
  template <typename QueryObjectsRequestT = Model::QueryObjectsRequest>
  void QueryObjectsAsync(const QueryObjectsRequestT& request, const QueryObjectsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataPipelineClient::QueryObjects, request, handler, context);
  }
 
  virtual Model::RemoveTagsOutcome RemoveTags(const Model::RemoveTagsRequest& request) const;
 
  template <typename RemoveTagsRequestT = Model::RemoveTagsRequest>
  Model::RemoveTagsOutcomeCallable RemoveTagsCallable(const RemoveTagsRequestT& request) const {
    return SubmitCallable(&DataPipelineClient::RemoveTags, request);
  }
 
  template <typename RemoveTagsRequestT = Model::RemoveTagsRequest>
  void RemoveTagsAsync(const RemoveTagsRequestT& request, const RemoveTagsResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataPipelineClient::RemoveTags, request, handler, context);
  }
 
  virtual Model::ReportTaskProgressOutcome ReportTaskProgress(const Model::ReportTaskProgressRequest& request) const;
 
  template <typename ReportTaskProgressRequestT = Model::ReportTaskProgressRequest>
  Model::ReportTaskProgressOutcomeCallable ReportTaskProgressCallable(const ReportTaskProgressRequestT& request) const {
    return SubmitCallable(&DataPipelineClient::ReportTaskProgress, request);
  }
 
  template <typename ReportTaskProgressRequestT = Model::ReportTaskProgressRequest>
  void ReportTaskProgressAsync(const ReportTaskProgressRequestT& request, const ReportTaskProgressResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataPipelineClient::ReportTaskProgress, request, handler, context);
  }
 
  virtual Model::ReportTaskRunnerHeartbeatOutcome ReportTaskRunnerHeartbeat(const Model::ReportTaskRunnerHeartbeatRequest& request) const;
 
  template <typename ReportTaskRunnerHeartbeatRequestT = Model::ReportTaskRunnerHeartbeatRequest>
  Model::ReportTaskRunnerHeartbeatOutcomeCallable ReportTaskRunnerHeartbeatCallable(
      const ReportTaskRunnerHeartbeatRequestT& request) const {
    return SubmitCallable(&DataPipelineClient::ReportTaskRunnerHeartbeat, request);
  }
 
  template <typename ReportTaskRunnerHeartbeatRequestT = Model::ReportTaskRunnerHeartbeatRequest>
  void ReportTaskRunnerHeartbeatAsync(const ReportTaskRunnerHeartbeatRequestT& request,
                                      const ReportTaskRunnerHeartbeatResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataPipelineClient::ReportTaskRunnerHeartbeat, request, handler, context);
  }
 
  virtual Model::SetStatusOutcome SetStatus(const Model::SetStatusRequest& request) const;
 
  template <typename SetStatusRequestT = Model::SetStatusRequest>
  Model::SetStatusOutcomeCallable SetStatusCallable(const SetStatusRequestT& request) const {
    return SubmitCallable(&DataPipelineClient::SetStatus, request);
  }
 
  template <typename SetStatusRequestT = Model::SetStatusRequest>
  void SetStatusAsync(const SetStatusRequestT& request, const SetStatusResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataPipelineClient::SetStatus, request, handler, context);
  }
 
  virtual Model::SetTaskStatusOutcome SetTaskStatus(const Model::SetTaskStatusRequest& request) const;
 
  template <typename SetTaskStatusRequestT = Model::SetTaskStatusRequest>
  Model::SetTaskStatusOutcomeCallable SetTaskStatusCallable(const SetTaskStatusRequestT& request) const {
    return SubmitCallable(&DataPipelineClient::SetTaskStatus, request);
  }
 
  template <typename SetTaskStatusRequestT = Model::SetTaskStatusRequest>
  void SetTaskStatusAsync(const SetTaskStatusRequestT& request, const SetTaskStatusResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataPipelineClient::SetTaskStatus, request, handler, context);
  }
 
  virtual Model::ValidatePipelineDefinitionOutcome ValidatePipelineDefinition(
      const Model::ValidatePipelineDefinitionRequest& request) const;
 
  template <typename ValidatePipelineDefinitionRequestT = Model::ValidatePipelineDefinitionRequest>
  Model::ValidatePipelineDefinitionOutcomeCallable ValidatePipelineDefinitionCallable(
      const ValidatePipelineDefinitionRequestT& request) const {
    return SubmitCallable(&DataPipelineClient::ValidatePipelineDefinition, request);
  }
 
  template <typename ValidatePipelineDefinitionRequestT = Model::ValidatePipelineDefinitionRequest>
  void ValidatePipelineDefinitionAsync(const ValidatePipelineDefinitionRequestT& request,
                                       const ValidatePipelineDefinitionResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataPipelineClient::ValidatePipelineDefinition, request, handler, context);
  }
 
  void OverrideEndpoint(const Aws::String& endpoint);
  std::shared_ptr<DataPipelineEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<DataPipelineClient>;
  void init(const DataPipelineClientConfiguration& clientConfiguration);
 
  DataPipelineClientConfiguration m_clientConfiguration;
  std::shared_ptr<DataPipelineEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace DataPipeline
}  // namespace Aws