MedicalImagingClient.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/medical-imaging/MedicalImagingPaginationBase.h>
#include <aws/medical-imaging/MedicalImagingServiceClientModel.h>
#include <aws/medical-imaging/MedicalImaging_EXPORTS.h>
 
namespace Aws {
namespace MedicalImaging {
class AWS_MEDICALIMAGING_API MedicalImagingClient : public Aws::Client::AWSJsonClient,
                                                    public Aws::Client::ClientWithAsyncTemplateMethods<MedicalImagingClient>,
                                                    public MedicalImagingPaginationBase<MedicalImagingClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef MedicalImagingClientConfiguration ClientConfigurationType;
  typedef MedicalImagingEndpointProvider EndpointProviderType;
 
  MedicalImagingClient(const Aws::MedicalImaging::MedicalImagingClientConfiguration& clientConfiguration =
                           Aws::MedicalImaging::MedicalImagingClientConfiguration(),
                       std::shared_ptr<MedicalImagingEndpointProviderBase> endpointProvider = nullptr);
 
  MedicalImagingClient(const Aws::Auth::AWSCredentials& credentials,
                       std::shared_ptr<MedicalImagingEndpointProviderBase> endpointProvider = nullptr,
                       const Aws::MedicalImaging::MedicalImagingClientConfiguration& clientConfiguration =
                           Aws::MedicalImaging::MedicalImagingClientConfiguration());
 
  MedicalImagingClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                       std::shared_ptr<MedicalImagingEndpointProviderBase> endpointProvider = nullptr,
                       const Aws::MedicalImaging::MedicalImagingClientConfiguration& clientConfiguration =
                           Aws::MedicalImaging::MedicalImagingClientConfiguration());
 
  /* Legacy constructors due deprecation */
  MedicalImagingClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  MedicalImagingClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  MedicalImagingClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                       const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~MedicalImagingClient();
 
  virtual Model::CopyImageSetOutcome CopyImageSet(const Model::CopyImageSetRequest& request) const;
 
  template <typename CopyImageSetRequestT = Model::CopyImageSetRequest>
  Model::CopyImageSetOutcomeCallable CopyImageSetCallable(const CopyImageSetRequestT& request) const {
    return SubmitCallable(&MedicalImagingClient::CopyImageSet, request);
  }
 
  template <typename CopyImageSetRequestT = Model::CopyImageSetRequest>
  void CopyImageSetAsync(const CopyImageSetRequestT& request, const CopyImageSetResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MedicalImagingClient::CopyImageSet, request, handler, context);
  }
 
  virtual Model::CreateDatastoreOutcome CreateDatastore(const Model::CreateDatastoreRequest& request) const;
 
  template <typename CreateDatastoreRequestT = Model::CreateDatastoreRequest>
  Model::CreateDatastoreOutcomeCallable CreateDatastoreCallable(const CreateDatastoreRequestT& request) const {
    return SubmitCallable(&MedicalImagingClient::CreateDatastore, request);
  }
 
  template <typename CreateDatastoreRequestT = Model::CreateDatastoreRequest>
  void CreateDatastoreAsync(const CreateDatastoreRequestT& request, const CreateDatastoreResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MedicalImagingClient::CreateDatastore, request, handler, context);
  }
 
  virtual Model::DeleteDatastoreOutcome DeleteDatastore(const Model::DeleteDatastoreRequest& request) const;
 
  template <typename DeleteDatastoreRequestT = Model::DeleteDatastoreRequest>
  Model::DeleteDatastoreOutcomeCallable DeleteDatastoreCallable(const DeleteDatastoreRequestT& request) const {
    return SubmitCallable(&MedicalImagingClient::DeleteDatastore, request);
  }
 
  template <typename DeleteDatastoreRequestT = Model::DeleteDatastoreRequest>
  void DeleteDatastoreAsync(const DeleteDatastoreRequestT& request, const DeleteDatastoreResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MedicalImagingClient::DeleteDatastore, request, handler, context);
  }
 
  virtual Model::DeleteImageSetOutcome DeleteImageSet(const Model::DeleteImageSetRequest& request) const;
 
  template <typename DeleteImageSetRequestT = Model::DeleteImageSetRequest>
  Model::DeleteImageSetOutcomeCallable DeleteImageSetCallable(const DeleteImageSetRequestT& request) const {
    return SubmitCallable(&MedicalImagingClient::DeleteImageSet, request);
  }
 
  template <typename DeleteImageSetRequestT = Model::DeleteImageSetRequest>
  void DeleteImageSetAsync(const DeleteImageSetRequestT& request, const DeleteImageSetResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MedicalImagingClient::DeleteImageSet, request, handler, context);
  }
 
  virtual Model::GetDICOMImportJobOutcome GetDICOMImportJob(const Model::GetDICOMImportJobRequest& request) const;
 
  template <typename GetDICOMImportJobRequestT = Model::GetDICOMImportJobRequest>
  Model::GetDICOMImportJobOutcomeCallable GetDICOMImportJobCallable(const GetDICOMImportJobRequestT& request) const {
    return SubmitCallable(&MedicalImagingClient::GetDICOMImportJob, request);
  }
 
  template <typename GetDICOMImportJobRequestT = Model::GetDICOMImportJobRequest>
  void GetDICOMImportJobAsync(const GetDICOMImportJobRequestT& request, const GetDICOMImportJobResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MedicalImagingClient::GetDICOMImportJob, request, handler, context);
  }
 
  virtual Model::GetDatastoreOutcome GetDatastore(const Model::GetDatastoreRequest& request) const;
 
  template <typename GetDatastoreRequestT = Model::GetDatastoreRequest>
  Model::GetDatastoreOutcomeCallable GetDatastoreCallable(const GetDatastoreRequestT& request) const {
    return SubmitCallable(&MedicalImagingClient::GetDatastore, request);
  }
 
  template <typename GetDatastoreRequestT = Model::GetDatastoreRequest>
  void GetDatastoreAsync(const GetDatastoreRequestT& request, const GetDatastoreResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MedicalImagingClient::GetDatastore, request, handler, context);
  }
 
  virtual Model::GetImageFrameOutcome GetImageFrame(const Model::GetImageFrameRequest& request) const;
 
  template <typename GetImageFrameRequestT = Model::GetImageFrameRequest>
  Model::GetImageFrameOutcomeCallable GetImageFrameCallable(const GetImageFrameRequestT& request) const {
    return SubmitCallable(&MedicalImagingClient::GetImageFrame, request);
  }
 
  template <typename GetImageFrameRequestT = Model::GetImageFrameRequest>
  void GetImageFrameAsync(const GetImageFrameRequestT& request, const GetImageFrameResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MedicalImagingClient::GetImageFrame, request, handler, context);
  }
 
  virtual Model::GetImageSetOutcome GetImageSet(const Model::GetImageSetRequest& request) const;
 
  template <typename GetImageSetRequestT = Model::GetImageSetRequest>
  Model::GetImageSetOutcomeCallable GetImageSetCallable(const GetImageSetRequestT& request) const {
    return SubmitCallable(&MedicalImagingClient::GetImageSet, request);
  }
 
  template <typename GetImageSetRequestT = Model::GetImageSetRequest>
  void GetImageSetAsync(const GetImageSetRequestT& request, const GetImageSetResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MedicalImagingClient::GetImageSet, request, handler, context);
  }
 
  virtual Model::GetImageSetMetadataOutcome GetImageSetMetadata(const Model::GetImageSetMetadataRequest& request) const;
 
  template <typename GetImageSetMetadataRequestT = Model::GetImageSetMetadataRequest>
  Model::GetImageSetMetadataOutcomeCallable GetImageSetMetadataCallable(const GetImageSetMetadataRequestT& request) const {
    return SubmitCallable(&MedicalImagingClient::GetImageSetMetadata, request);
  }
 
  template <typename GetImageSetMetadataRequestT = Model::GetImageSetMetadataRequest>
  void GetImageSetMetadataAsync(const GetImageSetMetadataRequestT& request, const GetImageSetMetadataResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MedicalImagingClient::GetImageSetMetadata, request, handler, context);
  }
 
  virtual Model::ListDICOMImportJobsOutcome ListDICOMImportJobs(const Model::ListDICOMImportJobsRequest& request) const;
 
  template <typename ListDICOMImportJobsRequestT = Model::ListDICOMImportJobsRequest>
  Model::ListDICOMImportJobsOutcomeCallable ListDICOMImportJobsCallable(const ListDICOMImportJobsRequestT& request) const {
    return SubmitCallable(&MedicalImagingClient::ListDICOMImportJobs, request);
  }
 
  template <typename ListDICOMImportJobsRequestT = Model::ListDICOMImportJobsRequest>
  void ListDICOMImportJobsAsync(const ListDICOMImportJobsRequestT& request, const ListDICOMImportJobsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MedicalImagingClient::ListDICOMImportJobs, request, handler, context);
  }
 
  virtual Model::ListDatastoresOutcome ListDatastores(const Model::ListDatastoresRequest& request = {}) const;
 
  template <typename ListDatastoresRequestT = Model::ListDatastoresRequest>
  Model::ListDatastoresOutcomeCallable ListDatastoresCallable(const ListDatastoresRequestT& request = {}) const {
    return SubmitCallable(&MedicalImagingClient::ListDatastores, request);
  }
 
  template <typename ListDatastoresRequestT = Model::ListDatastoresRequest>
  void ListDatastoresAsync(const ListDatastoresResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const ListDatastoresRequestT& request = {}) const {
    return SubmitAsync(&MedicalImagingClient::ListDatastores, request, handler, context);
  }
 
  virtual Model::ListImageSetVersionsOutcome ListImageSetVersions(const Model::ListImageSetVersionsRequest& request) const;
 
  template <typename ListImageSetVersionsRequestT = Model::ListImageSetVersionsRequest>
  Model::ListImageSetVersionsOutcomeCallable ListImageSetVersionsCallable(const ListImageSetVersionsRequestT& request) const {
    return SubmitCallable(&MedicalImagingClient::ListImageSetVersions, request);
  }
 
  template <typename ListImageSetVersionsRequestT = Model::ListImageSetVersionsRequest>
  void ListImageSetVersionsAsync(const ListImageSetVersionsRequestT& request, const ListImageSetVersionsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MedicalImagingClient::ListImageSetVersions, 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(&MedicalImagingClient::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(&MedicalImagingClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::SearchImageSetsOutcome SearchImageSets(const Model::SearchImageSetsRequest& request) const;
 
  template <typename SearchImageSetsRequestT = Model::SearchImageSetsRequest>
  Model::SearchImageSetsOutcomeCallable SearchImageSetsCallable(const SearchImageSetsRequestT& request) const {
    return SubmitCallable(&MedicalImagingClient::SearchImageSets, request);
  }
 
  template <typename SearchImageSetsRequestT = Model::SearchImageSetsRequest>
  void SearchImageSetsAsync(const SearchImageSetsRequestT& request, const SearchImageSetsResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MedicalImagingClient::SearchImageSets, request, handler, context);
  }
 
  virtual Model::StartDICOMImportJobOutcome StartDICOMImportJob(const Model::StartDICOMImportJobRequest& request) const;
 
  template <typename StartDICOMImportJobRequestT = Model::StartDICOMImportJobRequest>
  Model::StartDICOMImportJobOutcomeCallable StartDICOMImportJobCallable(const StartDICOMImportJobRequestT& request) const {
    return SubmitCallable(&MedicalImagingClient::StartDICOMImportJob, request);
  }
 
  template <typename StartDICOMImportJobRequestT = Model::StartDICOMImportJobRequest>
  void StartDICOMImportJobAsync(const StartDICOMImportJobRequestT& request, const StartDICOMImportJobResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MedicalImagingClient::StartDICOMImportJob, 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(&MedicalImagingClient::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(&MedicalImagingClient::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(&MedicalImagingClient::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(&MedicalImagingClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateImageSetMetadataOutcome UpdateImageSetMetadata(const Model::UpdateImageSetMetadataRequest& request) const;
 
  template <typename UpdateImageSetMetadataRequestT = Model::UpdateImageSetMetadataRequest>
  Model::UpdateImageSetMetadataOutcomeCallable UpdateImageSetMetadataCallable(const UpdateImageSetMetadataRequestT& request) const {
    return SubmitCallable(&MedicalImagingClient::UpdateImageSetMetadata, request);
  }
 
  template <typename UpdateImageSetMetadataRequestT = Model::UpdateImageSetMetadataRequest>
  void UpdateImageSetMetadataAsync(const UpdateImageSetMetadataRequestT& request,
                                   const UpdateImageSetMetadataResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MedicalImagingClient::UpdateImageSetMetadata, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<MedicalImagingEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<MedicalImagingClient>;
  void init(const MedicalImagingClientConfiguration& clientConfiguration);
 
  MedicalImagingClientConfiguration m_clientConfiguration;
  std::shared_ptr<MedicalImagingEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace MedicalImaging
}  // namespace Aws