SimpleDBClient.h

 
#pragma once
#include <aws/core/AmazonSerializableWebServiceRequest.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/xml/XmlSerializer.h>
#include <aws/sdb/SimpleDBPaginationBase.h>
#include <aws/sdb/SimpleDBServiceClientModel.h>
#include <aws/sdb/SimpleDBWaiter.h>
#include <aws/sdb/SimpleDB_EXPORTS.h>
 
namespace Aws {
namespace SimpleDB {
class AWS_SIMPLEDB_API SimpleDBClient : public Aws::Client::AWSXMLClient,
                                        public Aws::Client::ClientWithAsyncTemplateMethods<SimpleDBClient>,
                                        public SimpleDBPaginationBase<SimpleDBClient>,
                                        public SimpleDBWaiter<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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<SimpleDBEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<SimpleDBClient>;
  void init(const SimpleDBClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, SimpleDBError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  SimpleDBClientConfiguration m_clientConfiguration;
  std::shared_ptr<SimpleDBEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace SimpleDB
}  // namespace Aws