TimestreamWriteClient.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/timestream-write/TimestreamWriteServiceClientModel.h>
#include <aws/timestream-write/TimestreamWrite_EXPORTS.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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual 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