KeyspacesClient.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/keyspaces/KeyspacesPaginationBase.h>
#include <aws/keyspaces/KeyspacesServiceClientModel.h>
#include <aws/keyspaces/KeyspacesWaiter.h>
#include <aws/keyspaces/Keyspaces_EXPORTS.h>
 
namespace Aws {
namespace Keyspaces {
class AWS_KEYSPACES_API KeyspacesClient : public Aws::Client::AWSJsonClient,
                                          public Aws::Client::ClientWithAsyncTemplateMethods<KeyspacesClient>,
                                          public KeyspacesPaginationBase<KeyspacesClient>,
                                          public KeyspacesWaiter<KeyspacesClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef KeyspacesClientConfiguration ClientConfigurationType;
  typedef KeyspacesEndpointProvider EndpointProviderType;
 
  KeyspacesClient(const Aws::Keyspaces::KeyspacesClientConfiguration& clientConfiguration = Aws::Keyspaces::KeyspacesClientConfiguration(),
                  std::shared_ptr<KeyspacesEndpointProviderBase> endpointProvider = nullptr);
 
  KeyspacesClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<KeyspacesEndpointProviderBase> endpointProvider = nullptr,
                  const Aws::Keyspaces::KeyspacesClientConfiguration& clientConfiguration = Aws::Keyspaces::KeyspacesClientConfiguration());
 
  KeyspacesClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                  std::shared_ptr<KeyspacesEndpointProviderBase> endpointProvider = nullptr,
                  const Aws::Keyspaces::KeyspacesClientConfiguration& clientConfiguration = Aws::Keyspaces::KeyspacesClientConfiguration());
 
  /* Legacy constructors due deprecation */
  KeyspacesClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  KeyspacesClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  KeyspacesClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                  const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~KeyspacesClient();
 
  virtual Model::CreateKeyspaceOutcome CreateKeyspace(const Model::CreateKeyspaceRequest& request) const;
 
  template <typename CreateKeyspaceRequestT = Model::CreateKeyspaceRequest>
  Model::CreateKeyspaceOutcomeCallable CreateKeyspaceCallable(const CreateKeyspaceRequestT& request) const {
    return SubmitCallable(&KeyspacesClient::CreateKeyspace, request);
  }
 
  template <typename CreateKeyspaceRequestT = Model::CreateKeyspaceRequest>
  void CreateKeyspaceAsync(const CreateKeyspaceRequestT& request, const CreateKeyspaceResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KeyspacesClient::CreateKeyspace, request, handler, context);
  }
 
  virtual Model::CreateTableOutcome CreateTable(const Model::CreateTableRequest& request) const;
 
  template <typename CreateTableRequestT = Model::CreateTableRequest>
  Model::CreateTableOutcomeCallable CreateTableCallable(const CreateTableRequestT& request) const {
    return SubmitCallable(&KeyspacesClient::CreateTable, request);
  }
 
  template <typename CreateTableRequestT = Model::CreateTableRequest>
  void CreateTableAsync(const CreateTableRequestT& request, const CreateTableResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KeyspacesClient::CreateTable, request, handler, context);
  }
 
  virtual Model::CreateTypeOutcome CreateType(const Model::CreateTypeRequest& request) const;
 
  template <typename CreateTypeRequestT = Model::CreateTypeRequest>
  Model::CreateTypeOutcomeCallable CreateTypeCallable(const CreateTypeRequestT& request) const {
    return SubmitCallable(&KeyspacesClient::CreateType, request);
  }
 
  template <typename CreateTypeRequestT = Model::CreateTypeRequest>
  void CreateTypeAsync(const CreateTypeRequestT& request, const CreateTypeResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KeyspacesClient::CreateType, request, handler, context);
  }
 
  virtual Model::DeleteKeyspaceOutcome DeleteKeyspace(const Model::DeleteKeyspaceRequest& request) const;
 
  template <typename DeleteKeyspaceRequestT = Model::DeleteKeyspaceRequest>
  Model::DeleteKeyspaceOutcomeCallable DeleteKeyspaceCallable(const DeleteKeyspaceRequestT& request) const {
    return SubmitCallable(&KeyspacesClient::DeleteKeyspace, request);
  }
 
  template <typename DeleteKeyspaceRequestT = Model::DeleteKeyspaceRequest>
  void DeleteKeyspaceAsync(const DeleteKeyspaceRequestT& request, const DeleteKeyspaceResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KeyspacesClient::DeleteKeyspace, request, handler, context);
  }
 
  virtual Model::DeleteTableOutcome DeleteTable(const Model::DeleteTableRequest& request) const;
 
  template <typename DeleteTableRequestT = Model::DeleteTableRequest>
  Model::DeleteTableOutcomeCallable DeleteTableCallable(const DeleteTableRequestT& request) const {
    return SubmitCallable(&KeyspacesClient::DeleteTable, request);
  }
 
  template <typename DeleteTableRequestT = Model::DeleteTableRequest>
  void DeleteTableAsync(const DeleteTableRequestT& request, const DeleteTableResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KeyspacesClient::DeleteTable, request, handler, context);
  }
 
  virtual Model::DeleteTypeOutcome DeleteType(const Model::DeleteTypeRequest& request) const;
 
  template <typename DeleteTypeRequestT = Model::DeleteTypeRequest>
  Model::DeleteTypeOutcomeCallable DeleteTypeCallable(const DeleteTypeRequestT& request) const {
    return SubmitCallable(&KeyspacesClient::DeleteType, request);
  }
 
  template <typename DeleteTypeRequestT = Model::DeleteTypeRequest>
  void DeleteTypeAsync(const DeleteTypeRequestT& request, const DeleteTypeResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KeyspacesClient::DeleteType, request, handler, context);
  }
 
  virtual Model::GetKeyspaceOutcome GetKeyspace(const Model::GetKeyspaceRequest& request) const;
 
  template <typename GetKeyspaceRequestT = Model::GetKeyspaceRequest>
  Model::GetKeyspaceOutcomeCallable GetKeyspaceCallable(const GetKeyspaceRequestT& request) const {
    return SubmitCallable(&KeyspacesClient::GetKeyspace, request);
  }
 
  template <typename GetKeyspaceRequestT = Model::GetKeyspaceRequest>
  void GetKeyspaceAsync(const GetKeyspaceRequestT& request, const GetKeyspaceResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KeyspacesClient::GetKeyspace, request, handler, context);
  }
 
  virtual Model::GetTableOutcome GetTable(const Model::GetTableRequest& request) const;
 
  template <typename GetTableRequestT = Model::GetTableRequest>
  Model::GetTableOutcomeCallable GetTableCallable(const GetTableRequestT& request) const {
    return SubmitCallable(&KeyspacesClient::GetTable, request);
  }
 
  template <typename GetTableRequestT = Model::GetTableRequest>
  void GetTableAsync(const GetTableRequestT& request, const GetTableResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KeyspacesClient::GetTable, request, handler, context);
  }
 
  virtual Model::GetTableAutoScalingSettingsOutcome GetTableAutoScalingSettings(
      const Model::GetTableAutoScalingSettingsRequest& request) const;
 
  template <typename GetTableAutoScalingSettingsRequestT = Model::GetTableAutoScalingSettingsRequest>
  Model::GetTableAutoScalingSettingsOutcomeCallable GetTableAutoScalingSettingsCallable(
      const GetTableAutoScalingSettingsRequestT& request) const {
    return SubmitCallable(&KeyspacesClient::GetTableAutoScalingSettings, request);
  }
 
  template <typename GetTableAutoScalingSettingsRequestT = Model::GetTableAutoScalingSettingsRequest>
  void GetTableAutoScalingSettingsAsync(const GetTableAutoScalingSettingsRequestT& request,
                                        const GetTableAutoScalingSettingsResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KeyspacesClient::GetTableAutoScalingSettings, request, handler, context);
  }
 
  virtual Model::GetTypeOutcome GetType(const Model::GetTypeRequest& request) const;
 
  template <typename GetTypeRequestT = Model::GetTypeRequest>
  Model::GetTypeOutcomeCallable GetTypeCallable(const GetTypeRequestT& request) const {
    return SubmitCallable(&KeyspacesClient::GetType, request);
  }
 
  template <typename GetTypeRequestT = Model::GetTypeRequest>
  void GetTypeAsync(const GetTypeRequestT& request, const GetTypeResponseReceivedHandler& handler,
                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KeyspacesClient::GetType, request, handler, context);
  }
 
  virtual Model::ListKeyspacesOutcome ListKeyspaces(const Model::ListKeyspacesRequest& request = {}) const;
 
  template <typename ListKeyspacesRequestT = Model::ListKeyspacesRequest>
  Model::ListKeyspacesOutcomeCallable ListKeyspacesCallable(const ListKeyspacesRequestT& request = {}) const {
    return SubmitCallable(&KeyspacesClient::ListKeyspaces, request);
  }
 
  template <typename ListKeyspacesRequestT = Model::ListKeyspacesRequest>
  void ListKeyspacesAsync(const ListKeyspacesResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                          const ListKeyspacesRequestT& request = {}) const {
    return SubmitAsync(&KeyspacesClient::ListKeyspaces, request, handler, context);
  }
 
  virtual Model::ListTablesOutcome ListTables(const Model::ListTablesRequest& request) const;
 
  template <typename ListTablesRequestT = Model::ListTablesRequest>
  Model::ListTablesOutcomeCallable ListTablesCallable(const ListTablesRequestT& request) const {
    return SubmitCallable(&KeyspacesClient::ListTables, request);
  }
 
  template <typename ListTablesRequestT = Model::ListTablesRequest>
  void ListTablesAsync(const ListTablesRequestT& request, const ListTablesResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KeyspacesClient::ListTables, 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(&KeyspacesClient::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(&KeyspacesClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::ListTypesOutcome ListTypes(const Model::ListTypesRequest& request) const;
 
  template <typename ListTypesRequestT = Model::ListTypesRequest>
  Model::ListTypesOutcomeCallable ListTypesCallable(const ListTypesRequestT& request) const {
    return SubmitCallable(&KeyspacesClient::ListTypes, request);
  }
 
  template <typename ListTypesRequestT = Model::ListTypesRequest>
  void ListTypesAsync(const ListTypesRequestT& request, const ListTypesResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KeyspacesClient::ListTypes, request, handler, context);
  }
 
  virtual Model::RestoreTableOutcome RestoreTable(const Model::RestoreTableRequest& request) const;
 
  template <typename RestoreTableRequestT = Model::RestoreTableRequest>
  Model::RestoreTableOutcomeCallable RestoreTableCallable(const RestoreTableRequestT& request) const {
    return SubmitCallable(&KeyspacesClient::RestoreTable, request);
  }
 
  template <typename RestoreTableRequestT = Model::RestoreTableRequest>
  void RestoreTableAsync(const RestoreTableRequestT& request, const RestoreTableResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KeyspacesClient::RestoreTable, 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(&KeyspacesClient::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(&KeyspacesClient::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(&KeyspacesClient::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(&KeyspacesClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateKeyspaceOutcome UpdateKeyspace(const Model::UpdateKeyspaceRequest& request) const;
 
  template <typename UpdateKeyspaceRequestT = Model::UpdateKeyspaceRequest>
  Model::UpdateKeyspaceOutcomeCallable UpdateKeyspaceCallable(const UpdateKeyspaceRequestT& request) const {
    return SubmitCallable(&KeyspacesClient::UpdateKeyspace, request);
  }
 
  template <typename UpdateKeyspaceRequestT = Model::UpdateKeyspaceRequest>
  void UpdateKeyspaceAsync(const UpdateKeyspaceRequestT& request, const UpdateKeyspaceResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KeyspacesClient::UpdateKeyspace, request, handler, context);
  }
 
  virtual Model::UpdateTableOutcome UpdateTable(const Model::UpdateTableRequest& request) const;
 
  template <typename UpdateTableRequestT = Model::UpdateTableRequest>
  Model::UpdateTableOutcomeCallable UpdateTableCallable(const UpdateTableRequestT& request) const {
    return SubmitCallable(&KeyspacesClient::UpdateTable, request);
  }
 
  template <typename UpdateTableRequestT = Model::UpdateTableRequest>
  void UpdateTableAsync(const UpdateTableRequestT& request, const UpdateTableResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KeyspacesClient::UpdateTable, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<KeyspacesEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<KeyspacesClient>;
  void init(const KeyspacesClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, KeyspacesError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  KeyspacesClientConfiguration m_clientConfiguration;
  std::shared_ptr<KeyspacesEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace Keyspaces
}  // namespace Aws