DAXClient.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/dax/DAXPaginationBase.h>
#include <aws/dax/DAXServiceClientModel.h>
#include <aws/dax/DAXWaiter.h>
#include <aws/dax/DAX_EXPORTS.h>
 
namespace Aws {
namespace DAX {
class AWS_DAX_API DAXClient : public Aws::Client::AWSJsonClient,
                              public Aws::Client::ClientWithAsyncTemplateMethods<DAXClient>,
                              public DAXPaginationBase<DAXClient>,
                              public DAXWaiter<DAXClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef DAXClientConfiguration ClientConfigurationType;
  typedef DAXEndpointProvider EndpointProviderType;
 
  DAXClient(const Aws::DAX::DAXClientConfiguration& clientConfiguration = Aws::DAX::DAXClientConfiguration(),
            std::shared_ptr<DAXEndpointProviderBase> endpointProvider = nullptr);
 
  DAXClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<DAXEndpointProviderBase> endpointProvider = nullptr,
            const Aws::DAX::DAXClientConfiguration& clientConfiguration = Aws::DAX::DAXClientConfiguration());
 
  DAXClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
            std::shared_ptr<DAXEndpointProviderBase> endpointProvider = nullptr,
            const Aws::DAX::DAXClientConfiguration& clientConfiguration = Aws::DAX::DAXClientConfiguration());
 
  /* Legacy constructors due deprecation */
  DAXClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  DAXClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  DAXClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
            const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~DAXClient();
 
  virtual Model::CreateClusterOutcome CreateCluster(const Model::CreateClusterRequest& request) const;
 
  template <typename CreateClusterRequestT = Model::CreateClusterRequest>
  Model::CreateClusterOutcomeCallable CreateClusterCallable(const CreateClusterRequestT& request) const {
    return SubmitCallable(&DAXClient::CreateCluster, request);
  }
 
  template <typename CreateClusterRequestT = Model::CreateClusterRequest>
  void CreateClusterAsync(const CreateClusterRequestT& request, const CreateClusterResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DAXClient::CreateCluster, request, handler, context);
  }
 
  virtual Model::CreateParameterGroupOutcome CreateParameterGroup(const Model::CreateParameterGroupRequest& request) const;
 
  template <typename CreateParameterGroupRequestT = Model::CreateParameterGroupRequest>
  Model::CreateParameterGroupOutcomeCallable CreateParameterGroupCallable(const CreateParameterGroupRequestT& request) const {
    return SubmitCallable(&DAXClient::CreateParameterGroup, request);
  }
 
  template <typename CreateParameterGroupRequestT = Model::CreateParameterGroupRequest>
  void CreateParameterGroupAsync(const CreateParameterGroupRequestT& request, const CreateParameterGroupResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DAXClient::CreateParameterGroup, request, handler, context);
  }
 
  virtual Model::CreateSubnetGroupOutcome CreateSubnetGroup(const Model::CreateSubnetGroupRequest& request) const;
 
  template <typename CreateSubnetGroupRequestT = Model::CreateSubnetGroupRequest>
  Model::CreateSubnetGroupOutcomeCallable CreateSubnetGroupCallable(const CreateSubnetGroupRequestT& request) const {
    return SubmitCallable(&DAXClient::CreateSubnetGroup, request);
  }
 
  template <typename CreateSubnetGroupRequestT = Model::CreateSubnetGroupRequest>
  void CreateSubnetGroupAsync(const CreateSubnetGroupRequestT& request, const CreateSubnetGroupResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DAXClient::CreateSubnetGroup, request, handler, context);
  }
 
  virtual Model::DecreaseReplicationFactorOutcome DecreaseReplicationFactor(const Model::DecreaseReplicationFactorRequest& request) const;
 
  template <typename DecreaseReplicationFactorRequestT = Model::DecreaseReplicationFactorRequest>
  Model::DecreaseReplicationFactorOutcomeCallable DecreaseReplicationFactorCallable(
      const DecreaseReplicationFactorRequestT& request) const {
    return SubmitCallable(&DAXClient::DecreaseReplicationFactor, request);
  }
 
  template <typename DecreaseReplicationFactorRequestT = Model::DecreaseReplicationFactorRequest>
  void DecreaseReplicationFactorAsync(const DecreaseReplicationFactorRequestT& request,
                                      const DecreaseReplicationFactorResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DAXClient::DecreaseReplicationFactor, request, handler, context);
  }
 
  virtual Model::DeleteClusterOutcome DeleteCluster(const Model::DeleteClusterRequest& request) const;
 
  template <typename DeleteClusterRequestT = Model::DeleteClusterRequest>
  Model::DeleteClusterOutcomeCallable DeleteClusterCallable(const DeleteClusterRequestT& request) const {
    return SubmitCallable(&DAXClient::DeleteCluster, request);
  }
 
  template <typename DeleteClusterRequestT = Model::DeleteClusterRequest>
  void DeleteClusterAsync(const DeleteClusterRequestT& request, const DeleteClusterResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DAXClient::DeleteCluster, request, handler, context);
  }
 
  virtual Model::DeleteParameterGroupOutcome DeleteParameterGroup(const Model::DeleteParameterGroupRequest& request) const;
 
  template <typename DeleteParameterGroupRequestT = Model::DeleteParameterGroupRequest>
  Model::DeleteParameterGroupOutcomeCallable DeleteParameterGroupCallable(const DeleteParameterGroupRequestT& request) const {
    return SubmitCallable(&DAXClient::DeleteParameterGroup, request);
  }
 
  template <typename DeleteParameterGroupRequestT = Model::DeleteParameterGroupRequest>
  void DeleteParameterGroupAsync(const DeleteParameterGroupRequestT& request, const DeleteParameterGroupResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DAXClient::DeleteParameterGroup, request, handler, context);
  }
 
  virtual Model::DeleteSubnetGroupOutcome DeleteSubnetGroup(const Model::DeleteSubnetGroupRequest& request) const;
 
  template <typename DeleteSubnetGroupRequestT = Model::DeleteSubnetGroupRequest>
  Model::DeleteSubnetGroupOutcomeCallable DeleteSubnetGroupCallable(const DeleteSubnetGroupRequestT& request) const {
    return SubmitCallable(&DAXClient::DeleteSubnetGroup, request);
  }
 
  template <typename DeleteSubnetGroupRequestT = Model::DeleteSubnetGroupRequest>
  void DeleteSubnetGroupAsync(const DeleteSubnetGroupRequestT& request, const DeleteSubnetGroupResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DAXClient::DeleteSubnetGroup, request, handler, context);
  }
 
  virtual Model::DescribeClustersOutcome DescribeClusters(const Model::DescribeClustersRequest& request = {}) const;
 
  template <typename DescribeClustersRequestT = Model::DescribeClustersRequest>
  Model::DescribeClustersOutcomeCallable DescribeClustersCallable(const DescribeClustersRequestT& request = {}) const {
    return SubmitCallable(&DAXClient::DescribeClusters, request);
  }
 
  template <typename DescribeClustersRequestT = Model::DescribeClustersRequest>
  void DescribeClustersAsync(const DescribeClustersResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const DescribeClustersRequestT& request = {}) const {
    return SubmitAsync(&DAXClient::DescribeClusters, request, handler, context);
  }
 
  virtual Model::DescribeDefaultParametersOutcome DescribeDefaultParameters(
      const Model::DescribeDefaultParametersRequest& request = {}) const;
 
  template <typename DescribeDefaultParametersRequestT = Model::DescribeDefaultParametersRequest>
  Model::DescribeDefaultParametersOutcomeCallable DescribeDefaultParametersCallable(
      const DescribeDefaultParametersRequestT& request = {}) const {
    return SubmitCallable(&DAXClient::DescribeDefaultParameters, request);
  }
 
  template <typename DescribeDefaultParametersRequestT = Model::DescribeDefaultParametersRequest>
  void DescribeDefaultParametersAsync(const DescribeDefaultParametersResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                      const DescribeDefaultParametersRequestT& request = {}) const {
    return SubmitAsync(&DAXClient::DescribeDefaultParameters, request, handler, context);
  }
 
  virtual Model::DescribeEventsOutcome DescribeEvents(const Model::DescribeEventsRequest& request = {}) const;
 
  template <typename DescribeEventsRequestT = Model::DescribeEventsRequest>
  Model::DescribeEventsOutcomeCallable DescribeEventsCallable(const DescribeEventsRequestT& request = {}) const {
    return SubmitCallable(&DAXClient::DescribeEvents, request);
  }
 
  template <typename DescribeEventsRequestT = Model::DescribeEventsRequest>
  void DescribeEventsAsync(const DescribeEventsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const DescribeEventsRequestT& request = {}) const {
    return SubmitAsync(&DAXClient::DescribeEvents, request, handler, context);
  }
 
  virtual Model::DescribeParameterGroupsOutcome DescribeParameterGroups(const Model::DescribeParameterGroupsRequest& request = {}) const;
 
  template <typename DescribeParameterGroupsRequestT = Model::DescribeParameterGroupsRequest>
  Model::DescribeParameterGroupsOutcomeCallable DescribeParameterGroupsCallable(const DescribeParameterGroupsRequestT& request = {}) const {
    return SubmitCallable(&DAXClient::DescribeParameterGroups, request);
  }
 
  template <typename DescribeParameterGroupsRequestT = Model::DescribeParameterGroupsRequest>
  void DescribeParameterGroupsAsync(const DescribeParameterGroupsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const DescribeParameterGroupsRequestT& request = {}) const {
    return SubmitAsync(&DAXClient::DescribeParameterGroups, request, handler, context);
  }
 
  virtual Model::DescribeParametersOutcome DescribeParameters(const Model::DescribeParametersRequest& request) const;
 
  template <typename DescribeParametersRequestT = Model::DescribeParametersRequest>
  Model::DescribeParametersOutcomeCallable DescribeParametersCallable(const DescribeParametersRequestT& request) const {
    return SubmitCallable(&DAXClient::DescribeParameters, request);
  }
 
  template <typename DescribeParametersRequestT = Model::DescribeParametersRequest>
  void DescribeParametersAsync(const DescribeParametersRequestT& request, const DescribeParametersResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DAXClient::DescribeParameters, request, handler, context);
  }
 
  virtual Model::DescribeSubnetGroupsOutcome DescribeSubnetGroups(const Model::DescribeSubnetGroupsRequest& request = {}) const;
 
  template <typename DescribeSubnetGroupsRequestT = Model::DescribeSubnetGroupsRequest>
  Model::DescribeSubnetGroupsOutcomeCallable DescribeSubnetGroupsCallable(const DescribeSubnetGroupsRequestT& request = {}) const {
    return SubmitCallable(&DAXClient::DescribeSubnetGroups, request);
  }
 
  template <typename DescribeSubnetGroupsRequestT = Model::DescribeSubnetGroupsRequest>
  void DescribeSubnetGroupsAsync(const DescribeSubnetGroupsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const DescribeSubnetGroupsRequestT& request = {}) const {
    return SubmitAsync(&DAXClient::DescribeSubnetGroups, request, handler, context);
  }
 
  virtual Model::IncreaseReplicationFactorOutcome IncreaseReplicationFactor(const Model::IncreaseReplicationFactorRequest& request) const;
 
  template <typename IncreaseReplicationFactorRequestT = Model::IncreaseReplicationFactorRequest>
  Model::IncreaseReplicationFactorOutcomeCallable IncreaseReplicationFactorCallable(
      const IncreaseReplicationFactorRequestT& request) const {
    return SubmitCallable(&DAXClient::IncreaseReplicationFactor, request);
  }
 
  template <typename IncreaseReplicationFactorRequestT = Model::IncreaseReplicationFactorRequest>
  void IncreaseReplicationFactorAsync(const IncreaseReplicationFactorRequestT& request,
                                      const IncreaseReplicationFactorResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DAXClient::IncreaseReplicationFactor, request, handler, context);
  }
 
  virtual Model::ListTagsOutcome ListTags(const Model::ListTagsRequest& request) const;
 
  template <typename ListTagsRequestT = Model::ListTagsRequest>
  Model::ListTagsOutcomeCallable ListTagsCallable(const ListTagsRequestT& request) const {
    return SubmitCallable(&DAXClient::ListTags, request);
  }
 
  template <typename ListTagsRequestT = Model::ListTagsRequest>
  void ListTagsAsync(const ListTagsRequestT& request, const ListTagsResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DAXClient::ListTags, request, handler, context);
  }
 
  virtual Model::RebootNodeOutcome RebootNode(const Model::RebootNodeRequest& request) const;
 
  template <typename RebootNodeRequestT = Model::RebootNodeRequest>
  Model::RebootNodeOutcomeCallable RebootNodeCallable(const RebootNodeRequestT& request) const {
    return SubmitCallable(&DAXClient::RebootNode, request);
  }
 
  template <typename RebootNodeRequestT = Model::RebootNodeRequest>
  void RebootNodeAsync(const RebootNodeRequestT& request, const RebootNodeResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DAXClient::RebootNode, 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(&DAXClient::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(&DAXClient::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(&DAXClient::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(&DAXClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateClusterOutcome UpdateCluster(const Model::UpdateClusterRequest& request) const;
 
  template <typename UpdateClusterRequestT = Model::UpdateClusterRequest>
  Model::UpdateClusterOutcomeCallable UpdateClusterCallable(const UpdateClusterRequestT& request) const {
    return SubmitCallable(&DAXClient::UpdateCluster, request);
  }
 
  template <typename UpdateClusterRequestT = Model::UpdateClusterRequest>
  void UpdateClusterAsync(const UpdateClusterRequestT& request, const UpdateClusterResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DAXClient::UpdateCluster, request, handler, context);
  }
 
  virtual Model::UpdateParameterGroupOutcome UpdateParameterGroup(const Model::UpdateParameterGroupRequest& request) const;
 
  template <typename UpdateParameterGroupRequestT = Model::UpdateParameterGroupRequest>
  Model::UpdateParameterGroupOutcomeCallable UpdateParameterGroupCallable(const UpdateParameterGroupRequestT& request) const {
    return SubmitCallable(&DAXClient::UpdateParameterGroup, request);
  }
 
  template <typename UpdateParameterGroupRequestT = Model::UpdateParameterGroupRequest>
  void UpdateParameterGroupAsync(const UpdateParameterGroupRequestT& request, const UpdateParameterGroupResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DAXClient::UpdateParameterGroup, request, handler, context);
  }
 
  virtual Model::UpdateSubnetGroupOutcome UpdateSubnetGroup(const Model::UpdateSubnetGroupRequest& request) const;
 
  template <typename UpdateSubnetGroupRequestT = Model::UpdateSubnetGroupRequest>
  Model::UpdateSubnetGroupOutcomeCallable UpdateSubnetGroupCallable(const UpdateSubnetGroupRequestT& request) const {
    return SubmitCallable(&DAXClient::UpdateSubnetGroup, request);
  }
 
  template <typename UpdateSubnetGroupRequestT = Model::UpdateSubnetGroupRequest>
  void UpdateSubnetGroupAsync(const UpdateSubnetGroupRequestT& request, const UpdateSubnetGroupResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DAXClient::UpdateSubnetGroup, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<DAXEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<DAXClient>;
  void init(const DAXClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, DAXError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  DAXClientConfiguration m_clientConfiguration;
  std::shared_ptr<DAXEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace DAX
}  // namespace Aws