TimestreamQueryClient.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-query/TimestreamQueryPaginationBase.h>
#include <aws/timestream-query/TimestreamQueryServiceClientModel.h>
#include <aws/timestream-query/TimestreamQueryWaiter.h>
#include <aws/timestream-query/TimestreamQuery_EXPORTS.h>
 
namespace Aws {
namespace TimestreamQuery {
class AWS_TIMESTREAMQUERY_API TimestreamQueryClient : public Aws::Client::AWSJsonClient,
                                                      public Aws::Client::ClientWithAsyncTemplateMethods<TimestreamQueryClient>,
                                                      public TimestreamQueryPaginationBase<TimestreamQueryClient>,
                                                      public TimestreamQueryWaiter<TimestreamQueryClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef TimestreamQueryClientConfiguration ClientConfigurationType;
  typedef TimestreamQueryEndpointProvider EndpointProviderType;
 
  TimestreamQueryClient(const Aws::TimestreamQuery::TimestreamQueryClientConfiguration& clientConfiguration =
                            Aws::TimestreamQuery::TimestreamQueryClientConfiguration(),
                        std::shared_ptr<TimestreamQueryEndpointProviderBase> endpointProvider = nullptr);
 
  TimestreamQueryClient(const Aws::Auth::AWSCredentials& credentials,
                        std::shared_ptr<TimestreamQueryEndpointProviderBase> endpointProvider = nullptr,
                        const Aws::TimestreamQuery::TimestreamQueryClientConfiguration& clientConfiguration =
                            Aws::TimestreamQuery::TimestreamQueryClientConfiguration());
 
  TimestreamQueryClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                        std::shared_ptr<TimestreamQueryEndpointProviderBase> endpointProvider = nullptr,
                        const Aws::TimestreamQuery::TimestreamQueryClientConfiguration& clientConfiguration =
                            Aws::TimestreamQuery::TimestreamQueryClientConfiguration());
 
  /* Legacy constructors due deprecation */
  TimestreamQueryClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  TimestreamQueryClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  TimestreamQueryClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                        const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~TimestreamQueryClient();
 
  virtual Model::CancelQueryOutcome CancelQuery(const Model::CancelQueryRequest& request) const;
 
  template <typename CancelQueryRequestT = Model::CancelQueryRequest>
  Model::CancelQueryOutcomeCallable CancelQueryCallable(const CancelQueryRequestT& request) const {
    return SubmitCallable(&TimestreamQueryClient::CancelQuery, request);
  }
 
  template <typename CancelQueryRequestT = Model::CancelQueryRequest>
  void CancelQueryAsync(const CancelQueryRequestT& request, const CancelQueryResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TimestreamQueryClient::CancelQuery, request, handler, context);
  }
 
  virtual Model::CreateScheduledQueryOutcome CreateScheduledQuery(const Model::CreateScheduledQueryRequest& request) const;
 
  template <typename CreateScheduledQueryRequestT = Model::CreateScheduledQueryRequest>
  Model::CreateScheduledQueryOutcomeCallable CreateScheduledQueryCallable(const CreateScheduledQueryRequestT& request) const {
    return SubmitCallable(&TimestreamQueryClient::CreateScheduledQuery, request);
  }
 
  template <typename CreateScheduledQueryRequestT = Model::CreateScheduledQueryRequest>
  void CreateScheduledQueryAsync(const CreateScheduledQueryRequestT& request, const CreateScheduledQueryResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TimestreamQueryClient::CreateScheduledQuery, request, handler, context);
  }
 
  virtual Model::DeleteScheduledQueryOutcome DeleteScheduledQuery(const Model::DeleteScheduledQueryRequest& request) const;
 
  template <typename DeleteScheduledQueryRequestT = Model::DeleteScheduledQueryRequest>
  Model::DeleteScheduledQueryOutcomeCallable DeleteScheduledQueryCallable(const DeleteScheduledQueryRequestT& request) const {
    return SubmitCallable(&TimestreamQueryClient::DeleteScheduledQuery, request);
  }
 
  template <typename DeleteScheduledQueryRequestT = Model::DeleteScheduledQueryRequest>
  void DeleteScheduledQueryAsync(const DeleteScheduledQueryRequestT& request, const DeleteScheduledQueryResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TimestreamQueryClient::DeleteScheduledQuery, request, handler, context);
  }
 
  virtual Model::DescribeAccountSettingsOutcome DescribeAccountSettings(const Model::DescribeAccountSettingsRequest& request = {}) const;
 
  template <typename DescribeAccountSettingsRequestT = Model::DescribeAccountSettingsRequest>
  Model::DescribeAccountSettingsOutcomeCallable DescribeAccountSettingsCallable(const DescribeAccountSettingsRequestT& request = {}) const {
    return SubmitCallable(&TimestreamQueryClient::DescribeAccountSettings, request);
  }
 
  template <typename DescribeAccountSettingsRequestT = Model::DescribeAccountSettingsRequest>
  void DescribeAccountSettingsAsync(const DescribeAccountSettingsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const DescribeAccountSettingsRequestT& request = {}) const {
    return SubmitAsync(&TimestreamQueryClient::DescribeAccountSettings, 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(&TimestreamQueryClient::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(&TimestreamQueryClient::DescribeEndpoints, request, handler, context);
  }
 
  virtual Model::DescribeScheduledQueryOutcome DescribeScheduledQuery(const Model::DescribeScheduledQueryRequest& request) const;
 
  template <typename DescribeScheduledQueryRequestT = Model::DescribeScheduledQueryRequest>
  Model::DescribeScheduledQueryOutcomeCallable DescribeScheduledQueryCallable(const DescribeScheduledQueryRequestT& request) const {
    return SubmitCallable(&TimestreamQueryClient::DescribeScheduledQuery, request);
  }
 
  template <typename DescribeScheduledQueryRequestT = Model::DescribeScheduledQueryRequest>
  void DescribeScheduledQueryAsync(const DescribeScheduledQueryRequestT& request,
                                   const DescribeScheduledQueryResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TimestreamQueryClient::DescribeScheduledQuery, request, handler, context);
  }
 
  virtual Model::ExecuteScheduledQueryOutcome ExecuteScheduledQuery(const Model::ExecuteScheduledQueryRequest& request) const;
 
  template <typename ExecuteScheduledQueryRequestT = Model::ExecuteScheduledQueryRequest>
  Model::ExecuteScheduledQueryOutcomeCallable ExecuteScheduledQueryCallable(const ExecuteScheduledQueryRequestT& request) const {
    return SubmitCallable(&TimestreamQueryClient::ExecuteScheduledQuery, request);
  }
 
  template <typename ExecuteScheduledQueryRequestT = Model::ExecuteScheduledQueryRequest>
  void ExecuteScheduledQueryAsync(const ExecuteScheduledQueryRequestT& request, const ExecuteScheduledQueryResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TimestreamQueryClient::ExecuteScheduledQuery, request, handler, context);
  }
 
  virtual Model::ListScheduledQueriesOutcome ListScheduledQueries(const Model::ListScheduledQueriesRequest& request = {}) const;
 
  template <typename ListScheduledQueriesRequestT = Model::ListScheduledQueriesRequest>
  Model::ListScheduledQueriesOutcomeCallable ListScheduledQueriesCallable(const ListScheduledQueriesRequestT& request = {}) const {
    return SubmitCallable(&TimestreamQueryClient::ListScheduledQueries, request);
  }
 
  template <typename ListScheduledQueriesRequestT = Model::ListScheduledQueriesRequest>
  void ListScheduledQueriesAsync(const ListScheduledQueriesResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const ListScheduledQueriesRequestT& request = {}) const {
    return SubmitAsync(&TimestreamQueryClient::ListScheduledQueries, 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(&TimestreamQueryClient::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(&TimestreamQueryClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::PrepareQueryOutcome PrepareQuery(const Model::PrepareQueryRequest& request) const;
 
  template <typename PrepareQueryRequestT = Model::PrepareQueryRequest>
  Model::PrepareQueryOutcomeCallable PrepareQueryCallable(const PrepareQueryRequestT& request) const {
    return SubmitCallable(&TimestreamQueryClient::PrepareQuery, request);
  }
 
  template <typename PrepareQueryRequestT = Model::PrepareQueryRequest>
  void PrepareQueryAsync(const PrepareQueryRequestT& request, const PrepareQueryResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TimestreamQueryClient::PrepareQuery, request, handler, context);
  }
 
  virtual Model::QueryOutcome Query(const Model::QueryRequest& request) const;
 
  template <typename QueryRequestT = Model::QueryRequest>
  Model::QueryOutcomeCallable QueryCallable(const QueryRequestT& request) const {
    return SubmitCallable(&TimestreamQueryClient::Query, request);
  }
 
  template <typename QueryRequestT = Model::QueryRequest>
  void QueryAsync(const QueryRequestT& request, const QueryResponseReceivedHandler& handler,
                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TimestreamQueryClient::Query, 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(&TimestreamQueryClient::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(&TimestreamQueryClient::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(&TimestreamQueryClient::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(&TimestreamQueryClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateAccountSettingsOutcome UpdateAccountSettings(const Model::UpdateAccountSettingsRequest& request = {}) const;
 
  template <typename UpdateAccountSettingsRequestT = Model::UpdateAccountSettingsRequest>
  Model::UpdateAccountSettingsOutcomeCallable UpdateAccountSettingsCallable(const UpdateAccountSettingsRequestT& request = {}) const {
    return SubmitCallable(&TimestreamQueryClient::UpdateAccountSettings, request);
  }
 
  template <typename UpdateAccountSettingsRequestT = Model::UpdateAccountSettingsRequest>
  void UpdateAccountSettingsAsync(const UpdateAccountSettingsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                  const UpdateAccountSettingsRequestT& request = {}) const {
    return SubmitAsync(&TimestreamQueryClient::UpdateAccountSettings, request, handler, context);
  }
 
  virtual Model::UpdateScheduledQueryOutcome UpdateScheduledQuery(const Model::UpdateScheduledQueryRequest& request) const;
 
  template <typename UpdateScheduledQueryRequestT = Model::UpdateScheduledQueryRequest>
  Model::UpdateScheduledQueryOutcomeCallable UpdateScheduledQueryCallable(const UpdateScheduledQueryRequestT& request) const {
    return SubmitCallable(&TimestreamQueryClient::UpdateScheduledQuery, request);
  }
 
  template <typename UpdateScheduledQueryRequestT = Model::UpdateScheduledQueryRequest>
  void UpdateScheduledQueryAsync(const UpdateScheduledQueryRequestT& request, const UpdateScheduledQueryResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TimestreamQueryClient::UpdateScheduledQuery, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<TimestreamQueryEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<TimestreamQueryClient>;
  void init(const TimestreamQueryClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, TimestreamQueryError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  mutable Aws::Utils::ConcurrentCache<Aws::String, Aws::String> m_endpointsCache;
  TimestreamQueryClientConfiguration m_clientConfiguration;
  std::shared_ptr<TimestreamQueryEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace TimestreamQuery
}  // namespace Aws