BraketClient.h

 
#pragma once
#include <aws/braket/Braket_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/braket/BraketServiceClientModel.h>
 
namespace Aws
{
namespace Braket
{
  class AWS_BRAKET_API BraketClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<BraketClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef BraketClientConfiguration ClientConfigurationType;
      typedef BraketEndpointProvider EndpointProviderType;
 
        BraketClient(const Aws::Braket::BraketClientConfiguration& clientConfiguration = Aws::Braket::BraketClientConfiguration(),
                     std::shared_ptr<BraketEndpointProviderBase> endpointProvider = nullptr);
 
        BraketClient(const Aws::Auth::AWSCredentials& credentials,
                     std::shared_ptr<BraketEndpointProviderBase> endpointProvider = nullptr,
                     const Aws::Braket::BraketClientConfiguration& clientConfiguration = Aws::Braket::BraketClientConfiguration());
 
        BraketClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                     std::shared_ptr<BraketEndpointProviderBase> endpointProvider = nullptr,
                     const Aws::Braket::BraketClientConfiguration& clientConfiguration = Aws::Braket::BraketClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        BraketClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        BraketClient(const Aws::Auth::AWSCredentials& credentials,
                     const Aws::Client::ClientConfiguration& clientConfiguration);
 
        BraketClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                     const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~BraketClient();
 
        virtual Model::CancelJobOutcome CancelJob(const Model::CancelJobRequest& request) const;
 
        template<typename CancelJobRequestT = Model::CancelJobRequest>
        Model::CancelJobOutcomeCallable CancelJobCallable(const CancelJobRequestT& request) const
        {
            return SubmitCallable(&BraketClient::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(&BraketClient::CancelJob, request, handler, context);
        }
 
        virtual Model::CancelQuantumTaskOutcome CancelQuantumTask(const Model::CancelQuantumTaskRequest& request) const;
 
        template<typename CancelQuantumTaskRequestT = Model::CancelQuantumTaskRequest>
        Model::CancelQuantumTaskOutcomeCallable CancelQuantumTaskCallable(const CancelQuantumTaskRequestT& request) const
        {
            return SubmitCallable(&BraketClient::CancelQuantumTask, request);
        }
 
        template<typename CancelQuantumTaskRequestT = Model::CancelQuantumTaskRequest>
        void CancelQuantumTaskAsync(const CancelQuantumTaskRequestT& request, const CancelQuantumTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BraketClient::CancelQuantumTask, 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(&BraketClient::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(&BraketClient::CreateJob, request, handler, context);
        }
 
        virtual Model::CreateQuantumTaskOutcome CreateQuantumTask(const Model::CreateQuantumTaskRequest& request) const;
 
        template<typename CreateQuantumTaskRequestT = Model::CreateQuantumTaskRequest>
        Model::CreateQuantumTaskOutcomeCallable CreateQuantumTaskCallable(const CreateQuantumTaskRequestT& request) const
        {
            return SubmitCallable(&BraketClient::CreateQuantumTask, request);
        }
 
        template<typename CreateQuantumTaskRequestT = Model::CreateQuantumTaskRequest>
        void CreateQuantumTaskAsync(const CreateQuantumTaskRequestT& request, const CreateQuantumTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BraketClient::CreateQuantumTask, request, handler, context);
        }
 
        virtual Model::GetDeviceOutcome GetDevice(const Model::GetDeviceRequest& request) const;
 
        template<typename GetDeviceRequestT = Model::GetDeviceRequest>
        Model::GetDeviceOutcomeCallable GetDeviceCallable(const GetDeviceRequestT& request) const
        {
            return SubmitCallable(&BraketClient::GetDevice, request);
        }
 
        template<typename GetDeviceRequestT = Model::GetDeviceRequest>
        void GetDeviceAsync(const GetDeviceRequestT& request, const GetDeviceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BraketClient::GetDevice, request, handler, context);
        }
 
        virtual Model::GetJobOutcome GetJob(const Model::GetJobRequest& request) const;
 
        template<typename GetJobRequestT = Model::GetJobRequest>
        Model::GetJobOutcomeCallable GetJobCallable(const GetJobRequestT& request) const
        {
            return SubmitCallable(&BraketClient::GetJob, request);
        }
 
        template<typename GetJobRequestT = Model::GetJobRequest>
        void GetJobAsync(const GetJobRequestT& request, const GetJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BraketClient::GetJob, request, handler, context);
        }
 
        virtual Model::GetQuantumTaskOutcome GetQuantumTask(const Model::GetQuantumTaskRequest& request) const;
 
        template<typename GetQuantumTaskRequestT = Model::GetQuantumTaskRequest>
        Model::GetQuantumTaskOutcomeCallable GetQuantumTaskCallable(const GetQuantumTaskRequestT& request) const
        {
            return SubmitCallable(&BraketClient::GetQuantumTask, request);
        }
 
        template<typename GetQuantumTaskRequestT = Model::GetQuantumTaskRequest>
        void GetQuantumTaskAsync(const GetQuantumTaskRequestT& request, const GetQuantumTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BraketClient::GetQuantumTask, request, handler, context);
        }
 
        virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const;
 
        template<typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
        Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const
        {
            return SubmitCallable(&BraketClient::ListTagsForResource, request);
        }
 
        template<typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
        void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BraketClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::SearchDevicesOutcome SearchDevices(const Model::SearchDevicesRequest& request) const;
 
        template<typename SearchDevicesRequestT = Model::SearchDevicesRequest>
        Model::SearchDevicesOutcomeCallable SearchDevicesCallable(const SearchDevicesRequestT& request) const
        {
            return SubmitCallable(&BraketClient::SearchDevices, request);
        }
 
        template<typename SearchDevicesRequestT = Model::SearchDevicesRequest>
        void SearchDevicesAsync(const SearchDevicesRequestT& request, const SearchDevicesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BraketClient::SearchDevices, request, handler, context);
        }
 
        virtual Model::SearchJobsOutcome SearchJobs(const Model::SearchJobsRequest& request) const;
 
        template<typename SearchJobsRequestT = Model::SearchJobsRequest>
        Model::SearchJobsOutcomeCallable SearchJobsCallable(const SearchJobsRequestT& request) const
        {
            return SubmitCallable(&BraketClient::SearchJobs, request);
        }
 
        template<typename SearchJobsRequestT = Model::SearchJobsRequest>
        void SearchJobsAsync(const SearchJobsRequestT& request, const SearchJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BraketClient::SearchJobs, request, handler, context);
        }
 
        virtual Model::SearchQuantumTasksOutcome SearchQuantumTasks(const Model::SearchQuantumTasksRequest& request) const;
 
        template<typename SearchQuantumTasksRequestT = Model::SearchQuantumTasksRequest>
        Model::SearchQuantumTasksOutcomeCallable SearchQuantumTasksCallable(const SearchQuantumTasksRequestT& request) const
        {
            return SubmitCallable(&BraketClient::SearchQuantumTasks, request);
        }
 
        template<typename SearchQuantumTasksRequestT = Model::SearchQuantumTasksRequest>
        void SearchQuantumTasksAsync(const SearchQuantumTasksRequestT& request, const SearchQuantumTasksResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BraketClient::SearchQuantumTasks, request, handler, context);
        }
 
        virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const;
 
        template<typename TagResourceRequestT = Model::TagResourceRequest>
        Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const
        {
            return SubmitCallable(&BraketClient::TagResource, request);
        }
 
        template<typename TagResourceRequestT = Model::TagResourceRequest>
        void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BraketClient::TagResource, request, handler, context);
        }
 
        virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;
 
        template<typename UntagResourceRequestT = Model::UntagResourceRequest>
        Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const
        {
            return SubmitCallable(&BraketClient::UntagResource, request);
        }
 
        template<typename UntagResourceRequestT = Model::UntagResourceRequest>
        void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BraketClient::UntagResource, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<BraketEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<BraketClient>;
      void init(const BraketClientConfiguration& clientConfiguration);
 
      BraketClientConfiguration m_clientConfiguration;
      std::shared_ptr<BraketEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace Braket
} // namespace Aws