KeyspacesClient.h

 
#pragma once
#include <aws/keyspaces/Keyspaces_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/keyspaces/KeyspacesServiceClientModel.h>
 
namespace Aws
{
namespace Keyspaces
{
  class AWS_KEYSPACES_API KeyspacesClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<KeyspacesEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<KeyspacesClient>;
      void init(const KeyspacesClientConfiguration& clientConfiguration);
 
      KeyspacesClientConfiguration m_clientConfiguration;
      std::shared_ptr<KeyspacesEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace Keyspaces
} // namespace Aws