TimestreamWriteClient.h

 
#pragma once
#include <aws/timestream-write/TimestreamWrite_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/timestream-write/TimestreamWriteServiceClientModel.h>
 
namespace Aws
{
namespace TimestreamWrite
{
  class AWS_TIMESTREAMWRITE_API TimestreamWriteClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<TimestreamWriteClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef TimestreamWriteClientConfiguration ClientConfigurationType;
      typedef TimestreamWriteEndpointProvider EndpointProviderType;
 
        TimestreamWriteClient(const Aws::TimestreamWrite::TimestreamWriteClientConfiguration& clientConfiguration = Aws::TimestreamWrite::TimestreamWriteClientConfiguration(),
                              std::shared_ptr<TimestreamWriteEndpointProviderBase> endpointProvider = nullptr);
 
        TimestreamWriteClient(const Aws::Auth::AWSCredentials& credentials,
                              std::shared_ptr<TimestreamWriteEndpointProviderBase> endpointProvider = nullptr,
                              const Aws::TimestreamWrite::TimestreamWriteClientConfiguration& clientConfiguration = Aws::TimestreamWrite::TimestreamWriteClientConfiguration());
 
        TimestreamWriteClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                              std::shared_ptr<TimestreamWriteEndpointProviderBase> endpointProvider = nullptr,
                              const Aws::TimestreamWrite::TimestreamWriteClientConfiguration& clientConfiguration = Aws::TimestreamWrite::TimestreamWriteClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        TimestreamWriteClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        TimestreamWriteClient(const Aws::Auth::AWSCredentials& credentials,
                              const Aws::Client::ClientConfiguration& clientConfiguration);
 
        TimestreamWriteClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                              const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~TimestreamWriteClient();
 
        virtual Model::CreateBatchLoadTaskOutcome CreateBatchLoadTask(const Model::CreateBatchLoadTaskRequest& request) const;
 
        template<typename CreateBatchLoadTaskRequestT = Model::CreateBatchLoadTaskRequest>
        Model::CreateBatchLoadTaskOutcomeCallable CreateBatchLoadTaskCallable(const CreateBatchLoadTaskRequestT& request) const
        {
            return SubmitCallable(&TimestreamWriteClient::CreateBatchLoadTask, request);
        }
 
        template<typename CreateBatchLoadTaskRequestT = Model::CreateBatchLoadTaskRequest>
        void CreateBatchLoadTaskAsync(const CreateBatchLoadTaskRequestT& request, const CreateBatchLoadTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TimestreamWriteClient::CreateBatchLoadTask, request, handler, context);
        }
 
        virtual Model::CreateDatabaseOutcome CreateDatabase(const Model::CreateDatabaseRequest& request) const;
 
        template<typename CreateDatabaseRequestT = Model::CreateDatabaseRequest>
        Model::CreateDatabaseOutcomeCallable CreateDatabaseCallable(const CreateDatabaseRequestT& request) const
        {
            return SubmitCallable(&TimestreamWriteClient::CreateDatabase, request);
        }
 
        template<typename CreateDatabaseRequestT = Model::CreateDatabaseRequest>
        void CreateDatabaseAsync(const CreateDatabaseRequestT& request, const CreateDatabaseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TimestreamWriteClient::CreateDatabase, 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(&TimestreamWriteClient::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(&TimestreamWriteClient::CreateTable, request, handler, context);
        }
 
        virtual Model::DeleteDatabaseOutcome DeleteDatabase(const Model::DeleteDatabaseRequest& request) const;
 
        template<typename DeleteDatabaseRequestT = Model::DeleteDatabaseRequest>
        Model::DeleteDatabaseOutcomeCallable DeleteDatabaseCallable(const DeleteDatabaseRequestT& request) const
        {
            return SubmitCallable(&TimestreamWriteClient::DeleteDatabase, request);
        }
 
        template<typename DeleteDatabaseRequestT = Model::DeleteDatabaseRequest>
        void DeleteDatabaseAsync(const DeleteDatabaseRequestT& request, const DeleteDatabaseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TimestreamWriteClient::DeleteDatabase, 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(&TimestreamWriteClient::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(&TimestreamWriteClient::DeleteTable, request, handler, context);
        }
 
        virtual Model::DescribeBatchLoadTaskOutcome DescribeBatchLoadTask(const Model::DescribeBatchLoadTaskRequest& request) const;
 
        template<typename DescribeBatchLoadTaskRequestT = Model::DescribeBatchLoadTaskRequest>
        Model::DescribeBatchLoadTaskOutcomeCallable DescribeBatchLoadTaskCallable(const DescribeBatchLoadTaskRequestT& request) const
        {
            return SubmitCallable(&TimestreamWriteClient::DescribeBatchLoadTask, request);
        }
 
        template<typename DescribeBatchLoadTaskRequestT = Model::DescribeBatchLoadTaskRequest>
        void DescribeBatchLoadTaskAsync(const DescribeBatchLoadTaskRequestT& request, const DescribeBatchLoadTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TimestreamWriteClient::DescribeBatchLoadTask, request, handler, context);
        }
 
        virtual Model::DescribeDatabaseOutcome DescribeDatabase(const Model::DescribeDatabaseRequest& request) const;
 
        template<typename DescribeDatabaseRequestT = Model::DescribeDatabaseRequest>
        Model::DescribeDatabaseOutcomeCallable DescribeDatabaseCallable(const DescribeDatabaseRequestT& request) const
        {
            return SubmitCallable(&TimestreamWriteClient::DescribeDatabase, request);
        }
 
        template<typename DescribeDatabaseRequestT = Model::DescribeDatabaseRequest>
        void DescribeDatabaseAsync(const DescribeDatabaseRequestT& request, const DescribeDatabaseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TimestreamWriteClient::DescribeDatabase, request, handler, context);
        }
 
        virtual Model::DescribeEndpointsOutcome DescribeEndpoints(const Model::DescribeEndpointsRequest& request = {}) const;
 
        template<typename DescribeEndpointsRequestT = Model::DescribeEndpointsRequest>
        Model::DescribeEndpointsOutcomeCallable DescribeEndpointsCallable(const DescribeEndpointsRequestT& request = {}) const
        {
            return SubmitCallable(&TimestreamWriteClient::DescribeEndpoints, request);
        }
 
        template<typename DescribeEndpointsRequestT = Model::DescribeEndpointsRequest>
        void DescribeEndpointsAsync(const DescribeEndpointsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeEndpointsRequestT& request = {}) const
        {
            return SubmitAsync(&TimestreamWriteClient::DescribeEndpoints, request, handler, context);
        }
 
        virtual Model::DescribeTableOutcome DescribeTable(const Model::DescribeTableRequest& request) const;
 
        template<typename DescribeTableRequestT = Model::DescribeTableRequest>
        Model::DescribeTableOutcomeCallable DescribeTableCallable(const DescribeTableRequestT& request) const
        {
            return SubmitCallable(&TimestreamWriteClient::DescribeTable, request);
        }
 
        template<typename DescribeTableRequestT = Model::DescribeTableRequest>
        void DescribeTableAsync(const DescribeTableRequestT& request, const DescribeTableResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TimestreamWriteClient::DescribeTable, request, handler, context);
        }
 
        virtual Model::ListBatchLoadTasksOutcome ListBatchLoadTasks(const Model::ListBatchLoadTasksRequest& request = {}) const;
 
        template<typename ListBatchLoadTasksRequestT = Model::ListBatchLoadTasksRequest>
        Model::ListBatchLoadTasksOutcomeCallable ListBatchLoadTasksCallable(const ListBatchLoadTasksRequestT& request = {}) const
        {
            return SubmitCallable(&TimestreamWriteClient::ListBatchLoadTasks, request);
        }
 
        template<typename ListBatchLoadTasksRequestT = Model::ListBatchLoadTasksRequest>
        void ListBatchLoadTasksAsync(const ListBatchLoadTasksResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListBatchLoadTasksRequestT& request = {}) const
        {
            return SubmitAsync(&TimestreamWriteClient::ListBatchLoadTasks, request, handler, context);
        }
 
        virtual Model::ListDatabasesOutcome ListDatabases(const Model::ListDatabasesRequest& request = {}) const;
 
        template<typename ListDatabasesRequestT = Model::ListDatabasesRequest>
        Model::ListDatabasesOutcomeCallable ListDatabasesCallable(const ListDatabasesRequestT& request = {}) const
        {
            return SubmitCallable(&TimestreamWriteClient::ListDatabases, request);
        }
 
        template<typename ListDatabasesRequestT = Model::ListDatabasesRequest>
        void ListDatabasesAsync(const ListDatabasesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListDatabasesRequestT& request = {}) const
        {
            return SubmitAsync(&TimestreamWriteClient::ListDatabases, 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(&TimestreamWriteClient::ListTables, request);
        }
 
        template<typename ListTablesRequestT = Model::ListTablesRequest>
        void ListTablesAsync(const ListTablesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListTablesRequestT& request = {}) const
        {
            return SubmitAsync(&TimestreamWriteClient::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(&TimestreamWriteClient::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(&TimestreamWriteClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::ResumeBatchLoadTaskOutcome ResumeBatchLoadTask(const Model::ResumeBatchLoadTaskRequest& request) const;
 
        template<typename ResumeBatchLoadTaskRequestT = Model::ResumeBatchLoadTaskRequest>
        Model::ResumeBatchLoadTaskOutcomeCallable ResumeBatchLoadTaskCallable(const ResumeBatchLoadTaskRequestT& request) const
        {
            return SubmitCallable(&TimestreamWriteClient::ResumeBatchLoadTask, request);
        }
 
        template<typename ResumeBatchLoadTaskRequestT = Model::ResumeBatchLoadTaskRequest>
        void ResumeBatchLoadTaskAsync(const ResumeBatchLoadTaskRequestT& request, const ResumeBatchLoadTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TimestreamWriteClient::ResumeBatchLoadTask, 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(&TimestreamWriteClient::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(&TimestreamWriteClient::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(&TimestreamWriteClient::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(&TimestreamWriteClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateDatabaseOutcome UpdateDatabase(const Model::UpdateDatabaseRequest& request) const;
 
        template<typename UpdateDatabaseRequestT = Model::UpdateDatabaseRequest>
        Model::UpdateDatabaseOutcomeCallable UpdateDatabaseCallable(const UpdateDatabaseRequestT& request) const
        {
            return SubmitCallable(&TimestreamWriteClient::UpdateDatabase, request);
        }
 
        template<typename UpdateDatabaseRequestT = Model::UpdateDatabaseRequest>
        void UpdateDatabaseAsync(const UpdateDatabaseRequestT& request, const UpdateDatabaseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TimestreamWriteClient::UpdateDatabase, 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(&TimestreamWriteClient::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(&TimestreamWriteClient::UpdateTable, request, handler, context);
        }
 
        virtual Model::WriteRecordsOutcome WriteRecords(const Model::WriteRecordsRequest& request) const;
 
        template<typename WriteRecordsRequestT = Model::WriteRecordsRequest>
        Model::WriteRecordsOutcomeCallable WriteRecordsCallable(const WriteRecordsRequestT& request) const
        {
            return SubmitCallable(&TimestreamWriteClient::WriteRecords, request);
        }
 
        template<typename WriteRecordsRequestT = Model::WriteRecordsRequest>
        void WriteRecordsAsync(const WriteRecordsRequestT& request, const WriteRecordsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TimestreamWriteClient::WriteRecords, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<TimestreamWriteEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<TimestreamWriteClient>;
      void init(const TimestreamWriteClientConfiguration& clientConfiguration);
 
      mutable Aws::Utils::ConcurrentCache<Aws::String, Aws::String> m_endpointsCache;
      TimestreamWriteClientConfiguration m_clientConfiguration;
      std::shared_ptr<TimestreamWriteEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace TimestreamWrite
} // namespace Aws