DataPipelineClient.h

 
#pragma once
#include <aws/datapipeline/DataPipeline_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/datapipeline/DataPipelineServiceClientModel.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