SimpleDBClient.h

 
#pragma once
#include <aws/sdb/SimpleDB_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/AmazonSerializableWebServiceRequest.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/xml/XmlSerializer.h>
#include <aws/sdb/SimpleDBServiceClientModel.h>
 
namespace Aws
{
namespace SimpleDB
{
  class AWS_SIMPLEDB_API SimpleDBClient : public Aws::Client::AWSXMLClient, public Aws::Client::ClientWithAsyncTemplateMethods<SimpleDBClient>
  {
    public:
      typedef Aws::Client::AWSXMLClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef SimpleDBClientConfiguration ClientConfigurationType;
      typedef SimpleDBEndpointProvider EndpointProviderType;
 
        SimpleDBClient(const Aws::SimpleDB::SimpleDBClientConfiguration& clientConfiguration = Aws::SimpleDB::SimpleDBClientConfiguration(),
                       std::shared_ptr<SimpleDBEndpointProviderBase> endpointProvider = nullptr);
 
        SimpleDBClient(const Aws::Auth::AWSCredentials& credentials,
                       std::shared_ptr<SimpleDBEndpointProviderBase> endpointProvider = nullptr,
                       const Aws::SimpleDB::SimpleDBClientConfiguration& clientConfiguration = Aws::SimpleDB::SimpleDBClientConfiguration());
 
        SimpleDBClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                       std::shared_ptr<SimpleDBEndpointProviderBase> endpointProvider = nullptr,
                       const Aws::SimpleDB::SimpleDBClientConfiguration& clientConfiguration = Aws::SimpleDB::SimpleDBClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        SimpleDBClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        SimpleDBClient(const Aws::Auth::AWSCredentials& credentials,
                       const Aws::Client::ClientConfiguration& clientConfiguration);
 
        SimpleDBClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                       const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~SimpleDBClient();
 
 
        Aws::String ConvertRequestToPresignedUrl(const Aws::AmazonSerializableWebServiceRequest& requestToConvert, const char* region) const;
 
 
        virtual Model::BatchDeleteAttributesOutcome BatchDeleteAttributes(const Model::BatchDeleteAttributesRequest& request) const;
 
        template<typename BatchDeleteAttributesRequestT = Model::BatchDeleteAttributesRequest>
        Model::BatchDeleteAttributesOutcomeCallable BatchDeleteAttributesCallable(const BatchDeleteAttributesRequestT& request) const
        {
            return SubmitCallable(&SimpleDBClient::BatchDeleteAttributes, request);
        }
 
        template<typename BatchDeleteAttributesRequestT = Model::BatchDeleteAttributesRequest>
        void BatchDeleteAttributesAsync(const BatchDeleteAttributesRequestT& request, const BatchDeleteAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SimpleDBClient::BatchDeleteAttributes, request, handler, context);
        }
 
        virtual Model::BatchPutAttributesOutcome BatchPutAttributes(const Model::BatchPutAttributesRequest& request) const;
 
        template<typename BatchPutAttributesRequestT = Model::BatchPutAttributesRequest>
        Model::BatchPutAttributesOutcomeCallable BatchPutAttributesCallable(const BatchPutAttributesRequestT& request) const
        {
            return SubmitCallable(&SimpleDBClient::BatchPutAttributes, request);
        }
 
        template<typename BatchPutAttributesRequestT = Model::BatchPutAttributesRequest>
        void BatchPutAttributesAsync(const BatchPutAttributesRequestT& request, const BatchPutAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SimpleDBClient::BatchPutAttributes, request, handler, context);
        }
 
        virtual Model::CreateDomainOutcome CreateDomain(const Model::CreateDomainRequest& request) const;
 
        template<typename CreateDomainRequestT = Model::CreateDomainRequest>
        Model::CreateDomainOutcomeCallable CreateDomainCallable(const CreateDomainRequestT& request) const
        {
            return SubmitCallable(&SimpleDBClient::CreateDomain, request);
        }
 
        template<typename CreateDomainRequestT = Model::CreateDomainRequest>
        void CreateDomainAsync(const CreateDomainRequestT& request, const CreateDomainResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SimpleDBClient::CreateDomain, request, handler, context);
        }
 
        virtual Model::DeleteAttributesOutcome DeleteAttributes(const Model::DeleteAttributesRequest& request) const;
 
        template<typename DeleteAttributesRequestT = Model::DeleteAttributesRequest>
        Model::DeleteAttributesOutcomeCallable DeleteAttributesCallable(const DeleteAttributesRequestT& request) const
        {
            return SubmitCallable(&SimpleDBClient::DeleteAttributes, request);
        }
 
        template<typename DeleteAttributesRequestT = Model::DeleteAttributesRequest>
        void DeleteAttributesAsync(const DeleteAttributesRequestT& request, const DeleteAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SimpleDBClient::DeleteAttributes, request, handler, context);
        }
 
        virtual Model::DeleteDomainOutcome DeleteDomain(const Model::DeleteDomainRequest& request) const;
 
        template<typename DeleteDomainRequestT = Model::DeleteDomainRequest>
        Model::DeleteDomainOutcomeCallable DeleteDomainCallable(const DeleteDomainRequestT& request) const
        {
            return SubmitCallable(&SimpleDBClient::DeleteDomain, request);
        }
 
        template<typename DeleteDomainRequestT = Model::DeleteDomainRequest>
        void DeleteDomainAsync(const DeleteDomainRequestT& request, const DeleteDomainResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SimpleDBClient::DeleteDomain, request, handler, context);
        }
 
        virtual Model::DomainMetadataOutcome DomainMetadata(const Model::DomainMetadataRequest& request) const;
 
        template<typename DomainMetadataRequestT = Model::DomainMetadataRequest>
        Model::DomainMetadataOutcomeCallable DomainMetadataCallable(const DomainMetadataRequestT& request) const
        {
            return SubmitCallable(&SimpleDBClient::DomainMetadata, request);
        }
 
        template<typename DomainMetadataRequestT = Model::DomainMetadataRequest>
        void DomainMetadataAsync(const DomainMetadataRequestT& request, const DomainMetadataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SimpleDBClient::DomainMetadata, request, handler, context);
        }
 
        virtual Model::GetAttributesOutcome GetAttributes(const Model::GetAttributesRequest& request) const;
 
        template<typename GetAttributesRequestT = Model::GetAttributesRequest>
        Model::GetAttributesOutcomeCallable GetAttributesCallable(const GetAttributesRequestT& request) const
        {
            return SubmitCallable(&SimpleDBClient::GetAttributes, request);
        }
 
        template<typename GetAttributesRequestT = Model::GetAttributesRequest>
        void GetAttributesAsync(const GetAttributesRequestT& request, const GetAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SimpleDBClient::GetAttributes, request, handler, context);
        }
 
        virtual Model::ListDomainsOutcome ListDomains(const Model::ListDomainsRequest& request = {}) const;
 
        template<typename ListDomainsRequestT = Model::ListDomainsRequest>
        Model::ListDomainsOutcomeCallable ListDomainsCallable(const ListDomainsRequestT& request = {}) const
        {
            return SubmitCallable(&SimpleDBClient::ListDomains, request);
        }
 
        template<typename ListDomainsRequestT = Model::ListDomainsRequest>
        void ListDomainsAsync(const ListDomainsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListDomainsRequestT& request = {}) const
        {
            return SubmitAsync(&SimpleDBClient::ListDomains, request, handler, context);
        }
 
        virtual Model::PutAttributesOutcome PutAttributes(const Model::PutAttributesRequest& request) const;
 
        template<typename PutAttributesRequestT = Model::PutAttributesRequest>
        Model::PutAttributesOutcomeCallable PutAttributesCallable(const PutAttributesRequestT& request) const
        {
            return SubmitCallable(&SimpleDBClient::PutAttributes, request);
        }
 
        template<typename PutAttributesRequestT = Model::PutAttributesRequest>
        void PutAttributesAsync(const PutAttributesRequestT& request, const PutAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SimpleDBClient::PutAttributes, request, handler, context);
        }
 
        virtual Model::SelectOutcome Select(const Model::SelectRequest& request) const;
 
        template<typename SelectRequestT = Model::SelectRequest>
        Model::SelectOutcomeCallable SelectCallable(const SelectRequestT& request) const
        {
            return SubmitCallable(&SimpleDBClient::Select, request);
        }
 
        template<typename SelectRequestT = Model::SelectRequest>
        void SelectAsync(const SelectRequestT& request, const SelectResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SimpleDBClient::Select, request, handler, context);
        }
 
 
        void OverrideEndpoint(const Aws::String& endpoint);
        std::shared_ptr<SimpleDBEndpointProviderBase>& accessEndpointProvider();
  private:
        friend class Aws::Client::ClientWithAsyncTemplateMethods<SimpleDBClient>;
        void init(const SimpleDBClientConfiguration& clientConfiguration);
 
        SimpleDBClientConfiguration m_clientConfiguration;
        std::shared_ptr<SimpleDBEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace SimpleDB
} // namespace Aws