TimestreamQueryClient.h

 
#pragma once
#include <aws/timestream-query/TimestreamQuery_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-query/TimestreamQueryServiceClientModel.h>
 
namespace Aws
{
namespace TimestreamQuery
{
  class AWS_TIMESTREAMQUERY_API TimestreamQueryClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<TimestreamQueryEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<TimestreamQueryClient>;
      void init(const TimestreamQueryClientConfiguration& clientConfiguration);
 
      mutable Aws::Utils::ConcurrentCache<Aws::String, Aws::String> m_endpointsCache;
      TimestreamQueryClientConfiguration m_clientConfiguration;
      std::shared_ptr<TimestreamQueryEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace TimestreamQuery
} // namespace Aws