S3OutpostsClient.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/s3outposts/S3OutpostsPaginationBase.h>
#include <aws/s3outposts/S3OutpostsServiceClientModel.h>
#include <aws/s3outposts/S3OutpostsWaiter.h>
#include <aws/s3outposts/S3Outposts_EXPORTS.h>
 
namespace Aws {
namespace S3Outposts {
class AWS_S3OUTPOSTS_API S3OutpostsClient : public Aws::Client::AWSJsonClient,
                                            public Aws::Client::ClientWithAsyncTemplateMethods<S3OutpostsClient>,
                                            public S3OutpostsPaginationBase<S3OutpostsClient>,
                                            public S3OutpostsWaiter<S3OutpostsClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef S3OutpostsClientConfiguration ClientConfigurationType;
  typedef S3OutpostsEndpointProvider EndpointProviderType;
 
  S3OutpostsClient(
      const Aws::S3Outposts::S3OutpostsClientConfiguration& clientConfiguration = Aws::S3Outposts::S3OutpostsClientConfiguration(),
      std::shared_ptr<S3OutpostsEndpointProviderBase> endpointProvider = nullptr);
 
  S3OutpostsClient(
      const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<S3OutpostsEndpointProviderBase> endpointProvider = nullptr,
      const Aws::S3Outposts::S3OutpostsClientConfiguration& clientConfiguration = Aws::S3Outposts::S3OutpostsClientConfiguration());
 
  S3OutpostsClient(
      const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
      std::shared_ptr<S3OutpostsEndpointProviderBase> endpointProvider = nullptr,
      const Aws::S3Outposts::S3OutpostsClientConfiguration& clientConfiguration = Aws::S3Outposts::S3OutpostsClientConfiguration());
 
  /* Legacy constructors due deprecation */
  S3OutpostsClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  S3OutpostsClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  S3OutpostsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                   const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~S3OutpostsClient();
 
  virtual Model::CreateEndpointOutcome CreateEndpoint(const Model::CreateEndpointRequest& request) const;
 
  template <typename CreateEndpointRequestT = Model::CreateEndpointRequest>
  Model::CreateEndpointOutcomeCallable CreateEndpointCallable(const CreateEndpointRequestT& request) const {
    return SubmitCallable(&S3OutpostsClient::CreateEndpoint, request);
  }
 
  template <typename CreateEndpointRequestT = Model::CreateEndpointRequest>
  void CreateEndpointAsync(const CreateEndpointRequestT& request, const CreateEndpointResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3OutpostsClient::CreateEndpoint, request, handler, context);
  }
 
  virtual Model::DeleteEndpointOutcome DeleteEndpoint(const Model::DeleteEndpointRequest& request) const;
 
  template <typename DeleteEndpointRequestT = Model::DeleteEndpointRequest>
  Model::DeleteEndpointOutcomeCallable DeleteEndpointCallable(const DeleteEndpointRequestT& request) const {
    return SubmitCallable(&S3OutpostsClient::DeleteEndpoint, request);
  }
 
  template <typename DeleteEndpointRequestT = Model::DeleteEndpointRequest>
  void DeleteEndpointAsync(const DeleteEndpointRequestT& request, const DeleteEndpointResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3OutpostsClient::DeleteEndpoint, request, handler, context);
  }
 
  virtual Model::ListEndpointsOutcome ListEndpoints(const Model::ListEndpointsRequest& request = {}) const;
 
  template <typename ListEndpointsRequestT = Model::ListEndpointsRequest>
  Model::ListEndpointsOutcomeCallable ListEndpointsCallable(const ListEndpointsRequestT& request = {}) const {
    return SubmitCallable(&S3OutpostsClient::ListEndpoints, request);
  }
 
  template <typename ListEndpointsRequestT = Model::ListEndpointsRequest>
  void ListEndpointsAsync(const ListEndpointsResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                          const ListEndpointsRequestT& request = {}) const {
    return SubmitAsync(&S3OutpostsClient::ListEndpoints, request, handler, context);
  }
 
  virtual Model::ListOutpostsWithS3Outcome ListOutpostsWithS3(const Model::ListOutpostsWithS3Request& request = {}) const;
 
  template <typename ListOutpostsWithS3RequestT = Model::ListOutpostsWithS3Request>
  Model::ListOutpostsWithS3OutcomeCallable ListOutpostsWithS3Callable(const ListOutpostsWithS3RequestT& request = {}) const {
    return SubmitCallable(&S3OutpostsClient::ListOutpostsWithS3, request);
  }
 
  template <typename ListOutpostsWithS3RequestT = Model::ListOutpostsWithS3Request>
  void ListOutpostsWithS3Async(const ListOutpostsWithS3ResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const ListOutpostsWithS3RequestT& request = {}) const {
    return SubmitAsync(&S3OutpostsClient::ListOutpostsWithS3, request, handler, context);
  }
 
  virtual Model::ListSharedEndpointsOutcome ListSharedEndpoints(const Model::ListSharedEndpointsRequest& request) const;
 
  template <typename ListSharedEndpointsRequestT = Model::ListSharedEndpointsRequest>
  Model::ListSharedEndpointsOutcomeCallable ListSharedEndpointsCallable(const ListSharedEndpointsRequestT& request) const {
    return SubmitCallable(&S3OutpostsClient::ListSharedEndpoints, request);
  }
 
  template <typename ListSharedEndpointsRequestT = Model::ListSharedEndpointsRequest>
  void ListSharedEndpointsAsync(const ListSharedEndpointsRequestT& request, const ListSharedEndpointsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3OutpostsClient::ListSharedEndpoints, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<S3OutpostsEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<S3OutpostsClient>;
  void init(const S3OutpostsClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, S3OutpostsError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  S3OutpostsClientConfiguration m_clientConfiguration;
  std::shared_ptr<S3OutpostsEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace S3Outposts
}  // namespace Aws