BraketClient.h

 
#pragma once
#include <aws/braket/BraketPaginationBase.h>
#include <aws/braket/BraketServiceClientModel.h>
#include <aws/braket/BraketWaiter.h>
#include <aws/braket/Braket_EXPORTS.h>
#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>
 
namespace Aws {
namespace Braket {
class AWS_BRAKET_API BraketClient : public Aws::Client::AWSJsonClient,
                                    public Aws::Client::ClientWithAsyncTemplateMethods<BraketClient>,
                                    public BraketPaginationBase<BraketClient>,
                                    public BraketWaiter<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::CreateSpendingLimitOutcome CreateSpendingLimit(const Model::CreateSpendingLimitRequest& request) const;
 
  template <typename CreateSpendingLimitRequestT = Model::CreateSpendingLimitRequest>
  Model::CreateSpendingLimitOutcomeCallable CreateSpendingLimitCallable(const CreateSpendingLimitRequestT& request) const {
    return SubmitCallable(&BraketClient::CreateSpendingLimit, request);
  }
 
  template <typename CreateSpendingLimitRequestT = Model::CreateSpendingLimitRequest>
  void CreateSpendingLimitAsync(const CreateSpendingLimitRequestT& request, const CreateSpendingLimitResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BraketClient::CreateSpendingLimit, request, handler, context);
  }
 
  virtual Model::DeleteSpendingLimitOutcome DeleteSpendingLimit(const Model::DeleteSpendingLimitRequest& request) const;
 
  template <typename DeleteSpendingLimitRequestT = Model::DeleteSpendingLimitRequest>
  Model::DeleteSpendingLimitOutcomeCallable DeleteSpendingLimitCallable(const DeleteSpendingLimitRequestT& request) const {
    return SubmitCallable(&BraketClient::DeleteSpendingLimit, request);
  }
 
  template <typename DeleteSpendingLimitRequestT = Model::DeleteSpendingLimitRequest>
  void DeleteSpendingLimitAsync(const DeleteSpendingLimitRequestT& request, const DeleteSpendingLimitResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BraketClient::DeleteSpendingLimit, 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::SearchSpendingLimitsOutcome SearchSpendingLimits(const Model::SearchSpendingLimitsRequest& request = {}) const;
 
  template <typename SearchSpendingLimitsRequestT = Model::SearchSpendingLimitsRequest>
  Model::SearchSpendingLimitsOutcomeCallable SearchSpendingLimitsCallable(const SearchSpendingLimitsRequestT& request = {}) const {
    return SubmitCallable(&BraketClient::SearchSpendingLimits, request);
  }
 
  template <typename SearchSpendingLimitsRequestT = Model::SearchSpendingLimitsRequest>
  void SearchSpendingLimitsAsync(const SearchSpendingLimitsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const SearchSpendingLimitsRequestT& request = {}) const {
    return SubmitAsync(&BraketClient::SearchSpendingLimits, 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);
  }
 
  virtual Model::UpdateSpendingLimitOutcome UpdateSpendingLimit(const Model::UpdateSpendingLimitRequest& request) const;
 
  template <typename UpdateSpendingLimitRequestT = Model::UpdateSpendingLimitRequest>
  Model::UpdateSpendingLimitOutcomeCallable UpdateSpendingLimitCallable(const UpdateSpendingLimitRequestT& request) const {
    return SubmitCallable(&BraketClient::UpdateSpendingLimit, request);
  }
 
  template <typename UpdateSpendingLimitRequestT = Model::UpdateSpendingLimitRequest>
  void UpdateSpendingLimitAsync(const UpdateSpendingLimitRequestT& request, const UpdateSpendingLimitResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BraketClient::UpdateSpendingLimit, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<BraketEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<BraketClient>;
  void init(const BraketClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, BraketError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  BraketClientConfiguration m_clientConfiguration;
  std::shared_ptr<BraketEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace Braket
}  // namespace Aws