ElasticTranscoderClient.h

 
#pragma once
#include <aws/elastictranscoder/ElasticTranscoder_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/elastictranscoder/ElasticTranscoderServiceClientModel.h>
 
namespace Aws
{
namespace ElasticTranscoder
{
  class AWS_ELASTICTRANSCODER_API ElasticTranscoderClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<ElasticTranscoderClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef ElasticTranscoderClientConfiguration ClientConfigurationType;
      typedef ElasticTranscoderEndpointProvider EndpointProviderType;
 
        ElasticTranscoderClient(const Aws::ElasticTranscoder::ElasticTranscoderClientConfiguration& clientConfiguration = Aws::ElasticTranscoder::ElasticTranscoderClientConfiguration(),
                                std::shared_ptr<ElasticTranscoderEndpointProviderBase> endpointProvider = nullptr);
 
        ElasticTranscoderClient(const Aws::Auth::AWSCredentials& credentials,
                                std::shared_ptr<ElasticTranscoderEndpointProviderBase> endpointProvider = nullptr,
                                const Aws::ElasticTranscoder::ElasticTranscoderClientConfiguration& clientConfiguration = Aws::ElasticTranscoder::ElasticTranscoderClientConfiguration());
 
        ElasticTranscoderClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                                std::shared_ptr<ElasticTranscoderEndpointProviderBase> endpointProvider = nullptr,
                                const Aws::ElasticTranscoder::ElasticTranscoderClientConfiguration& clientConfiguration = Aws::ElasticTranscoder::ElasticTranscoderClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        ElasticTranscoderClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        ElasticTranscoderClient(const Aws::Auth::AWSCredentials& credentials,
                                const Aws::Client::ClientConfiguration& clientConfiguration);
 
        ElasticTranscoderClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                                const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~ElasticTranscoderClient();
 
        virtual Model::CancelJobOutcome CancelJob(const Model::CancelJobRequest& request) const;
 
        template<typename CancelJobRequestT = Model::CancelJobRequest>
        Model::CancelJobOutcomeCallable CancelJobCallable(const CancelJobRequestT& request) const
        {
            return SubmitCallable(&ElasticTranscoderClient::CancelJob, request);
        }
 
        template<typename CancelJobRequestT = Model::CancelJobRequest>
        void CancelJobAsync(const CancelJobRequestT& request, const CancelJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticTranscoderClient::CancelJob, request, handler, context);
        }
 
        virtual Model::CreateJobOutcome CreateJob(const Model::CreateJobRequest& request) const;
 
        template<typename CreateJobRequestT = Model::CreateJobRequest>
        Model::CreateJobOutcomeCallable CreateJobCallable(const CreateJobRequestT& request) const
        {
            return SubmitCallable(&ElasticTranscoderClient::CreateJob, request);
        }
 
        template<typename CreateJobRequestT = Model::CreateJobRequest>
        void CreateJobAsync(const CreateJobRequestT& request, const CreateJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticTranscoderClient::CreateJob, 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(&ElasticTranscoderClient::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(&ElasticTranscoderClient::CreatePipeline, request, handler, context);
        }
 
        virtual Model::CreatePresetOutcome CreatePreset(const Model::CreatePresetRequest& request) const;
 
        template<typename CreatePresetRequestT = Model::CreatePresetRequest>
        Model::CreatePresetOutcomeCallable CreatePresetCallable(const CreatePresetRequestT& request) const
        {
            return SubmitCallable(&ElasticTranscoderClient::CreatePreset, request);
        }
 
        template<typename CreatePresetRequestT = Model::CreatePresetRequest>
        void CreatePresetAsync(const CreatePresetRequestT& request, const CreatePresetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticTranscoderClient::CreatePreset, 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(&ElasticTranscoderClient::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(&ElasticTranscoderClient::DeletePipeline, request, handler, context);
        }
 
        virtual Model::DeletePresetOutcome DeletePreset(const Model::DeletePresetRequest& request) const;
 
        template<typename DeletePresetRequestT = Model::DeletePresetRequest>
        Model::DeletePresetOutcomeCallable DeletePresetCallable(const DeletePresetRequestT& request) const
        {
            return SubmitCallable(&ElasticTranscoderClient::DeletePreset, request);
        }
 
        template<typename DeletePresetRequestT = Model::DeletePresetRequest>
        void DeletePresetAsync(const DeletePresetRequestT& request, const DeletePresetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticTranscoderClient::DeletePreset, request, handler, context);
        }
 
        virtual Model::ListJobsByPipelineOutcome ListJobsByPipeline(const Model::ListJobsByPipelineRequest& request) const;
 
        template<typename ListJobsByPipelineRequestT = Model::ListJobsByPipelineRequest>
        Model::ListJobsByPipelineOutcomeCallable ListJobsByPipelineCallable(const ListJobsByPipelineRequestT& request) const
        {
            return SubmitCallable(&ElasticTranscoderClient::ListJobsByPipeline, request);
        }
 
        template<typename ListJobsByPipelineRequestT = Model::ListJobsByPipelineRequest>
        void ListJobsByPipelineAsync(const ListJobsByPipelineRequestT& request, const ListJobsByPipelineResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticTranscoderClient::ListJobsByPipeline, request, handler, context);
        }
 
        virtual Model::ListJobsByStatusOutcome ListJobsByStatus(const Model::ListJobsByStatusRequest& request) const;
 
        template<typename ListJobsByStatusRequestT = Model::ListJobsByStatusRequest>
        Model::ListJobsByStatusOutcomeCallable ListJobsByStatusCallable(const ListJobsByStatusRequestT& request) const
        {
            return SubmitCallable(&ElasticTranscoderClient::ListJobsByStatus, request);
        }
 
        template<typename ListJobsByStatusRequestT = Model::ListJobsByStatusRequest>
        void ListJobsByStatusAsync(const ListJobsByStatusRequestT& request, const ListJobsByStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticTranscoderClient::ListJobsByStatus, 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(&ElasticTranscoderClient::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(&ElasticTranscoderClient::ListPipelines, request, handler, context);
        }
 
        virtual Model::ListPresetsOutcome ListPresets(const Model::ListPresetsRequest& request = {}) const;
 
        template<typename ListPresetsRequestT = Model::ListPresetsRequest>
        Model::ListPresetsOutcomeCallable ListPresetsCallable(const ListPresetsRequestT& request = {}) const
        {
            return SubmitCallable(&ElasticTranscoderClient::ListPresets, request);
        }
 
        template<typename ListPresetsRequestT = Model::ListPresetsRequest>
        void ListPresetsAsync(const ListPresetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListPresetsRequestT& request = {}) const
        {
            return SubmitAsync(&ElasticTranscoderClient::ListPresets, request, handler, context);
        }
 
        virtual Model::ReadJobOutcome ReadJob(const Model::ReadJobRequest& request) const;
 
        template<typename ReadJobRequestT = Model::ReadJobRequest>
        Model::ReadJobOutcomeCallable ReadJobCallable(const ReadJobRequestT& request) const
        {
            return SubmitCallable(&ElasticTranscoderClient::ReadJob, request);
        }
 
        template<typename ReadJobRequestT = Model::ReadJobRequest>
        void ReadJobAsync(const ReadJobRequestT& request, const ReadJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticTranscoderClient::ReadJob, request, handler, context);
        }
 
        virtual Model::ReadPipelineOutcome ReadPipeline(const Model::ReadPipelineRequest& request) const;
 
        template<typename ReadPipelineRequestT = Model::ReadPipelineRequest>
        Model::ReadPipelineOutcomeCallable ReadPipelineCallable(const ReadPipelineRequestT& request) const
        {
            return SubmitCallable(&ElasticTranscoderClient::ReadPipeline, request);
        }
 
        template<typename ReadPipelineRequestT = Model::ReadPipelineRequest>
        void ReadPipelineAsync(const ReadPipelineRequestT& request, const ReadPipelineResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticTranscoderClient::ReadPipeline, request, handler, context);
        }
 
        virtual Model::ReadPresetOutcome ReadPreset(const Model::ReadPresetRequest& request) const;
 
        template<typename ReadPresetRequestT = Model::ReadPresetRequest>
        Model::ReadPresetOutcomeCallable ReadPresetCallable(const ReadPresetRequestT& request) const
        {
            return SubmitCallable(&ElasticTranscoderClient::ReadPreset, request);
        }
 
        template<typename ReadPresetRequestT = Model::ReadPresetRequest>
        void ReadPresetAsync(const ReadPresetRequestT& request, const ReadPresetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticTranscoderClient::ReadPreset, request, handler, context);
        }
 
        virtual Model::UpdatePipelineOutcome UpdatePipeline(const Model::UpdatePipelineRequest& request) const;
 
        template<typename UpdatePipelineRequestT = Model::UpdatePipelineRequest>
        Model::UpdatePipelineOutcomeCallable UpdatePipelineCallable(const UpdatePipelineRequestT& request) const
        {
            return SubmitCallable(&ElasticTranscoderClient::UpdatePipeline, request);
        }
 
        template<typename UpdatePipelineRequestT = Model::UpdatePipelineRequest>
        void UpdatePipelineAsync(const UpdatePipelineRequestT& request, const UpdatePipelineResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticTranscoderClient::UpdatePipeline, request, handler, context);
        }
 
        virtual Model::UpdatePipelineNotificationsOutcome UpdatePipelineNotifications(const Model::UpdatePipelineNotificationsRequest& request) const;
 
        template<typename UpdatePipelineNotificationsRequestT = Model::UpdatePipelineNotificationsRequest>
        Model::UpdatePipelineNotificationsOutcomeCallable UpdatePipelineNotificationsCallable(const UpdatePipelineNotificationsRequestT& request) const
        {
            return SubmitCallable(&ElasticTranscoderClient::UpdatePipelineNotifications, request);
        }
 
        template<typename UpdatePipelineNotificationsRequestT = Model::UpdatePipelineNotificationsRequest>
        void UpdatePipelineNotificationsAsync(const UpdatePipelineNotificationsRequestT& request, const UpdatePipelineNotificationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticTranscoderClient::UpdatePipelineNotifications, request, handler, context);
        }
 
        virtual Model::UpdatePipelineStatusOutcome UpdatePipelineStatus(const Model::UpdatePipelineStatusRequest& request) const;
 
        template<typename UpdatePipelineStatusRequestT = Model::UpdatePipelineStatusRequest>
        Model::UpdatePipelineStatusOutcomeCallable UpdatePipelineStatusCallable(const UpdatePipelineStatusRequestT& request) const
        {
            return SubmitCallable(&ElasticTranscoderClient::UpdatePipelineStatus, request);
        }
 
        template<typename UpdatePipelineStatusRequestT = Model::UpdatePipelineStatusRequest>
        void UpdatePipelineStatusAsync(const UpdatePipelineStatusRequestT& request, const UpdatePipelineStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticTranscoderClient::UpdatePipelineStatus, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<ElasticTranscoderEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<ElasticTranscoderClient>;
      void init(const ElasticTranscoderClientConfiguration& clientConfiguration);
 
      ElasticTranscoderClientConfiguration m_clientConfiguration;
      std::shared_ptr<ElasticTranscoderEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace ElasticTranscoder
} // namespace Aws