DocDBElasticClient.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/docdb-elastic/DocDBElasticPaginationBase.h>
#include <aws/docdb-elastic/DocDBElasticServiceClientModel.h>
#include <aws/docdb-elastic/DocDBElasticWaiter.h>
#include <aws/docdb-elastic/DocDBElastic_EXPORTS.h>
 
namespace Aws {
namespace DocDBElastic {
class AWS_DOCDBELASTIC_API DocDBElasticClient : public Aws::Client::AWSJsonClient,
                                                public Aws::Client::ClientWithAsyncTemplateMethods<DocDBElasticClient>,
                                                public DocDBElasticPaginationBase<DocDBElasticClient>,
                                                public DocDBElasticWaiter<DocDBElasticClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef DocDBElasticClientConfiguration ClientConfigurationType;
  typedef DocDBElasticEndpointProvider EndpointProviderType;
 
  DocDBElasticClient(
      const Aws::DocDBElastic::DocDBElasticClientConfiguration& clientConfiguration = Aws::DocDBElastic::DocDBElasticClientConfiguration(),
      std::shared_ptr<DocDBElasticEndpointProviderBase> endpointProvider = nullptr);
 
  DocDBElasticClient(
      const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<DocDBElasticEndpointProviderBase> endpointProvider = nullptr,
      const Aws::DocDBElastic::DocDBElasticClientConfiguration& clientConfiguration = Aws::DocDBElastic::DocDBElasticClientConfiguration());
 
  DocDBElasticClient(
      const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
      std::shared_ptr<DocDBElasticEndpointProviderBase> endpointProvider = nullptr,
      const Aws::DocDBElastic::DocDBElasticClientConfiguration& clientConfiguration = Aws::DocDBElastic::DocDBElasticClientConfiguration());
 
  /* Legacy constructors due deprecation */
  DocDBElasticClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  DocDBElasticClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  DocDBElasticClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                     const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~DocDBElasticClient();
 
  virtual Model::ApplyPendingMaintenanceActionOutcome ApplyPendingMaintenanceAction(
      const Model::ApplyPendingMaintenanceActionRequest& request) const;
 
  template <typename ApplyPendingMaintenanceActionRequestT = Model::ApplyPendingMaintenanceActionRequest>
  Model::ApplyPendingMaintenanceActionOutcomeCallable ApplyPendingMaintenanceActionCallable(
      const ApplyPendingMaintenanceActionRequestT& request) const {
    return SubmitCallable(&DocDBElasticClient::ApplyPendingMaintenanceAction, request);
  }
 
  template <typename ApplyPendingMaintenanceActionRequestT = Model::ApplyPendingMaintenanceActionRequest>
  void ApplyPendingMaintenanceActionAsync(const ApplyPendingMaintenanceActionRequestT& request,
                                          const ApplyPendingMaintenanceActionResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DocDBElasticClient::ApplyPendingMaintenanceAction, request, handler, context);
  }
 
  virtual Model::CopyClusterSnapshotOutcome CopyClusterSnapshot(const Model::CopyClusterSnapshotRequest& request) const;
 
  template <typename CopyClusterSnapshotRequestT = Model::CopyClusterSnapshotRequest>
  Model::CopyClusterSnapshotOutcomeCallable CopyClusterSnapshotCallable(const CopyClusterSnapshotRequestT& request) const {
    return SubmitCallable(&DocDBElasticClient::CopyClusterSnapshot, request);
  }
 
  template <typename CopyClusterSnapshotRequestT = Model::CopyClusterSnapshotRequest>
  void CopyClusterSnapshotAsync(const CopyClusterSnapshotRequestT& request, const CopyClusterSnapshotResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DocDBElasticClient::CopyClusterSnapshot, request, handler, context);
  }
 
  virtual Model::CreateClusterOutcome CreateCluster(const Model::CreateClusterRequest& request) const;
 
  template <typename CreateClusterRequestT = Model::CreateClusterRequest>
  Model::CreateClusterOutcomeCallable CreateClusterCallable(const CreateClusterRequestT& request) const {
    return SubmitCallable(&DocDBElasticClient::CreateCluster, request);
  }
 
  template <typename CreateClusterRequestT = Model::CreateClusterRequest>
  void CreateClusterAsync(const CreateClusterRequestT& request, const CreateClusterResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DocDBElasticClient::CreateCluster, request, handler, context);
  }
 
  virtual Model::CreateClusterSnapshotOutcome CreateClusterSnapshot(const Model::CreateClusterSnapshotRequest& request) const;
 
  template <typename CreateClusterSnapshotRequestT = Model::CreateClusterSnapshotRequest>
  Model::CreateClusterSnapshotOutcomeCallable CreateClusterSnapshotCallable(const CreateClusterSnapshotRequestT& request) const {
    return SubmitCallable(&DocDBElasticClient::CreateClusterSnapshot, request);
  }
 
  template <typename CreateClusterSnapshotRequestT = Model::CreateClusterSnapshotRequest>
  void CreateClusterSnapshotAsync(const CreateClusterSnapshotRequestT& request, const CreateClusterSnapshotResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DocDBElasticClient::CreateClusterSnapshot, request, handler, context);
  }
 
  virtual Model::DeleteClusterOutcome DeleteCluster(const Model::DeleteClusterRequest& request) const;
 
  template <typename DeleteClusterRequestT = Model::DeleteClusterRequest>
  Model::DeleteClusterOutcomeCallable DeleteClusterCallable(const DeleteClusterRequestT& request) const {
    return SubmitCallable(&DocDBElasticClient::DeleteCluster, request);
  }
 
  template <typename DeleteClusterRequestT = Model::DeleteClusterRequest>
  void DeleteClusterAsync(const DeleteClusterRequestT& request, const DeleteClusterResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DocDBElasticClient::DeleteCluster, request, handler, context);
  }
 
  virtual Model::DeleteClusterSnapshotOutcome DeleteClusterSnapshot(const Model::DeleteClusterSnapshotRequest& request) const;
 
  template <typename DeleteClusterSnapshotRequestT = Model::DeleteClusterSnapshotRequest>
  Model::DeleteClusterSnapshotOutcomeCallable DeleteClusterSnapshotCallable(const DeleteClusterSnapshotRequestT& request) const {
    return SubmitCallable(&DocDBElasticClient::DeleteClusterSnapshot, request);
  }
 
  template <typename DeleteClusterSnapshotRequestT = Model::DeleteClusterSnapshotRequest>
  void DeleteClusterSnapshotAsync(const DeleteClusterSnapshotRequestT& request, const DeleteClusterSnapshotResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DocDBElasticClient::DeleteClusterSnapshot, request, handler, context);
  }
 
  virtual Model::GetClusterOutcome GetCluster(const Model::GetClusterRequest& request) const;
 
  template <typename GetClusterRequestT = Model::GetClusterRequest>
  Model::GetClusterOutcomeCallable GetClusterCallable(const GetClusterRequestT& request) const {
    return SubmitCallable(&DocDBElasticClient::GetCluster, request);
  }
 
  template <typename GetClusterRequestT = Model::GetClusterRequest>
  void GetClusterAsync(const GetClusterRequestT& request, const GetClusterResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DocDBElasticClient::GetCluster, request, handler, context);
  }
 
  virtual Model::GetClusterSnapshotOutcome GetClusterSnapshot(const Model::GetClusterSnapshotRequest& request) const;
 
  template <typename GetClusterSnapshotRequestT = Model::GetClusterSnapshotRequest>
  Model::GetClusterSnapshotOutcomeCallable GetClusterSnapshotCallable(const GetClusterSnapshotRequestT& request) const {
    return SubmitCallable(&DocDBElasticClient::GetClusterSnapshot, request);
  }
 
  template <typename GetClusterSnapshotRequestT = Model::GetClusterSnapshotRequest>
  void GetClusterSnapshotAsync(const GetClusterSnapshotRequestT& request, const GetClusterSnapshotResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DocDBElasticClient::GetClusterSnapshot, request, handler, context);
  }
 
  virtual Model::GetPendingMaintenanceActionOutcome GetPendingMaintenanceAction(
      const Model::GetPendingMaintenanceActionRequest& request) const;
 
  template <typename GetPendingMaintenanceActionRequestT = Model::GetPendingMaintenanceActionRequest>
  Model::GetPendingMaintenanceActionOutcomeCallable GetPendingMaintenanceActionCallable(
      const GetPendingMaintenanceActionRequestT& request) const {
    return SubmitCallable(&DocDBElasticClient::GetPendingMaintenanceAction, request);
  }
 
  template <typename GetPendingMaintenanceActionRequestT = Model::GetPendingMaintenanceActionRequest>
  void GetPendingMaintenanceActionAsync(const GetPendingMaintenanceActionRequestT& request,
                                        const GetPendingMaintenanceActionResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DocDBElasticClient::GetPendingMaintenanceAction, request, handler, context);
  }
 
  virtual Model::ListClusterSnapshotsOutcome ListClusterSnapshots(const Model::ListClusterSnapshotsRequest& request = {}) const;
 
  template <typename ListClusterSnapshotsRequestT = Model::ListClusterSnapshotsRequest>
  Model::ListClusterSnapshotsOutcomeCallable ListClusterSnapshotsCallable(const ListClusterSnapshotsRequestT& request = {}) const {
    return SubmitCallable(&DocDBElasticClient::ListClusterSnapshots, request);
  }
 
  template <typename ListClusterSnapshotsRequestT = Model::ListClusterSnapshotsRequest>
  void ListClusterSnapshotsAsync(const ListClusterSnapshotsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const ListClusterSnapshotsRequestT& request = {}) const {
    return SubmitAsync(&DocDBElasticClient::ListClusterSnapshots, request, handler, context);
  }
 
  virtual Model::ListClustersOutcome ListClusters(const Model::ListClustersRequest& request = {}) const;
 
  template <typename ListClustersRequestT = Model::ListClustersRequest>
  Model::ListClustersOutcomeCallable ListClustersCallable(const ListClustersRequestT& request = {}) const {
    return SubmitCallable(&DocDBElasticClient::ListClusters, request);
  }
 
  template <typename ListClustersRequestT = Model::ListClustersRequest>
  void ListClustersAsync(const ListClustersResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const ListClustersRequestT& request = {}) const {
    return SubmitAsync(&DocDBElasticClient::ListClusters, request, handler, context);
  }
 
  virtual Model::ListPendingMaintenanceActionsOutcome ListPendingMaintenanceActions(
      const Model::ListPendingMaintenanceActionsRequest& request = {}) const;
 
  template <typename ListPendingMaintenanceActionsRequestT = Model::ListPendingMaintenanceActionsRequest>
  Model::ListPendingMaintenanceActionsOutcomeCallable ListPendingMaintenanceActionsCallable(
      const ListPendingMaintenanceActionsRequestT& request = {}) const {
    return SubmitCallable(&DocDBElasticClient::ListPendingMaintenanceActions, request);
  }
 
  template <typename ListPendingMaintenanceActionsRequestT = Model::ListPendingMaintenanceActionsRequest>
  void ListPendingMaintenanceActionsAsync(const ListPendingMaintenanceActionsResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                          const ListPendingMaintenanceActionsRequestT& request = {}) const {
    return SubmitAsync(&DocDBElasticClient::ListPendingMaintenanceActions, 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(&DocDBElasticClient::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(&DocDBElasticClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::RestoreClusterFromSnapshotOutcome RestoreClusterFromSnapshot(
      const Model::RestoreClusterFromSnapshotRequest& request) const;
 
  template <typename RestoreClusterFromSnapshotRequestT = Model::RestoreClusterFromSnapshotRequest>
  Model::RestoreClusterFromSnapshotOutcomeCallable RestoreClusterFromSnapshotCallable(
      const RestoreClusterFromSnapshotRequestT& request) const {
    return SubmitCallable(&DocDBElasticClient::RestoreClusterFromSnapshot, request);
  }
 
  template <typename RestoreClusterFromSnapshotRequestT = Model::RestoreClusterFromSnapshotRequest>
  void RestoreClusterFromSnapshotAsync(const RestoreClusterFromSnapshotRequestT& request,
                                       const RestoreClusterFromSnapshotResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DocDBElasticClient::RestoreClusterFromSnapshot, request, handler, context);
  }
 
  virtual Model::StartClusterOutcome StartCluster(const Model::StartClusterRequest& request) const;
 
  template <typename StartClusterRequestT = Model::StartClusterRequest>
  Model::StartClusterOutcomeCallable StartClusterCallable(const StartClusterRequestT& request) const {
    return SubmitCallable(&DocDBElasticClient::StartCluster, request);
  }
 
  template <typename StartClusterRequestT = Model::StartClusterRequest>
  void StartClusterAsync(const StartClusterRequestT& request, const StartClusterResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DocDBElasticClient::StartCluster, request, handler, context);
  }
 
  virtual Model::StopClusterOutcome StopCluster(const Model::StopClusterRequest& request) const;
 
  template <typename StopClusterRequestT = Model::StopClusterRequest>
  Model::StopClusterOutcomeCallable StopClusterCallable(const StopClusterRequestT& request) const {
    return SubmitCallable(&DocDBElasticClient::StopCluster, request);
  }
 
  template <typename StopClusterRequestT = Model::StopClusterRequest>
  void StopClusterAsync(const StopClusterRequestT& request, const StopClusterResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DocDBElasticClient::StopCluster, 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(&DocDBElasticClient::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(&DocDBElasticClient::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(&DocDBElasticClient::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(&DocDBElasticClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateClusterOutcome UpdateCluster(const Model::UpdateClusterRequest& request) const;
 
  template <typename UpdateClusterRequestT = Model::UpdateClusterRequest>
  Model::UpdateClusterOutcomeCallable UpdateClusterCallable(const UpdateClusterRequestT& request) const {
    return SubmitCallable(&DocDBElasticClient::UpdateCluster, request);
  }
 
  template <typename UpdateClusterRequestT = Model::UpdateClusterRequest>
  void UpdateClusterAsync(const UpdateClusterRequestT& request, const UpdateClusterResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DocDBElasticClient::UpdateCluster, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<DocDBElasticEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<DocDBElasticClient>;
  void init(const DocDBElasticClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, DocDBElasticError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  DocDBElasticClientConfiguration m_clientConfiguration;
  std::shared_ptr<DocDBElasticEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace DocDBElastic
}  // namespace Aws