SagemakerJobRuntimeClient.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/sagemakerjobruntime/SagemakerJobRuntimePaginationBase.h>
#include <aws/sagemakerjobruntime/SagemakerJobRuntimeServiceClientModel.h>
#include <aws/sagemakerjobruntime/SagemakerJobRuntimeWaiter.h>
#include <aws/sagemakerjobruntime/SagemakerJobRuntime_EXPORTS.h>
 
namespace Aws {
namespace SagemakerJobRuntime {
class AWS_SAGEMAKERJOBRUNTIME_API SagemakerJobRuntimeClient : public Aws::Client::AWSJsonClient,
                                                              public Aws::Client::ClientWithAsyncTemplateMethods<SagemakerJobRuntimeClient>,
                                                              public SagemakerJobRuntimePaginationBase<SagemakerJobRuntimeClient>,
                                                              public SagemakerJobRuntimeWaiter<SagemakerJobRuntimeClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef SagemakerJobRuntimeClientConfiguration ClientConfigurationType;
  typedef SagemakerJobRuntimeEndpointProvider EndpointProviderType;
 
  SagemakerJobRuntimeClient(const Aws::SagemakerJobRuntime::SagemakerJobRuntimeClientConfiguration& clientConfiguration =
                                Aws::SagemakerJobRuntime::SagemakerJobRuntimeClientConfiguration(),
                            std::shared_ptr<SagemakerJobRuntimeEndpointProviderBase> endpointProvider = nullptr);
 
  SagemakerJobRuntimeClient(const Aws::Auth::AWSCredentials& credentials,
                            std::shared_ptr<SagemakerJobRuntimeEndpointProviderBase> endpointProvider = nullptr,
                            const Aws::SagemakerJobRuntime::SagemakerJobRuntimeClientConfiguration& clientConfiguration =
                                Aws::SagemakerJobRuntime::SagemakerJobRuntimeClientConfiguration());
 
  SagemakerJobRuntimeClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                            std::shared_ptr<SagemakerJobRuntimeEndpointProviderBase> endpointProvider = nullptr,
                            const Aws::SagemakerJobRuntime::SagemakerJobRuntimeClientConfiguration& clientConfiguration =
                                Aws::SagemakerJobRuntime::SagemakerJobRuntimeClientConfiguration());
 
  /* Legacy constructors due deprecation */
  SagemakerJobRuntimeClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  SagemakerJobRuntimeClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  SagemakerJobRuntimeClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                            const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~SagemakerJobRuntimeClient();
 
  virtual Model::CompleteRolloutOutcome CompleteRollout(const Model::CompleteRolloutRequest& request) const;
 
  template <typename CompleteRolloutRequestT = Model::CompleteRolloutRequest>
  Model::CompleteRolloutOutcomeCallable CompleteRolloutCallable(const CompleteRolloutRequestT& request) const {
    return SubmitCallable(&SagemakerJobRuntimeClient::CompleteRollout, request);
  }
 
  template <typename CompleteRolloutRequestT = Model::CompleteRolloutRequest>
  void CompleteRolloutAsync(const CompleteRolloutRequestT& request, const CompleteRolloutResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SagemakerJobRuntimeClient::CompleteRollout, request, handler, context);
  }
 
  virtual Model::SampleOutcome Sample(const Model::SampleRequest& request) const;
 
  template <typename SampleRequestT = Model::SampleRequest>
  Model::SampleOutcomeCallable SampleCallable(const SampleRequestT& request) const {
    return SubmitCallable(&SagemakerJobRuntimeClient::Sample, request);
  }
 
  template <typename SampleRequestT = Model::SampleRequest>
  void SampleAsync(const SampleRequestT& request, const SampleResponseReceivedHandler& handler,
                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SagemakerJobRuntimeClient::Sample, request, handler, context);
  }
 
  virtual Model::SampleWithResponseStreamOutcome SampleWithResponseStream(const Model::SampleWithResponseStreamRequest& request) const;
 
  template <typename SampleWithResponseStreamRequestT = Model::SampleWithResponseStreamRequest>
  Model::SampleWithResponseStreamOutcomeCallable SampleWithResponseStreamCallable(const SampleWithResponseStreamRequestT& request) const {
    return SubmitCallable(&SagemakerJobRuntimeClient::SampleWithResponseStream, request);
  }
 
  template <typename SampleWithResponseStreamRequestT = Model::SampleWithResponseStreamRequest>
  void SampleWithResponseStreamAsync(const SampleWithResponseStreamRequestT& request,
                                     const SampleWithResponseStreamResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SagemakerJobRuntimeClient::SampleWithResponseStream, request, handler, context);
  }
 
  virtual Model::UpdateRewardOutcome UpdateReward(const Model::UpdateRewardRequest& request) const;
 
  template <typename UpdateRewardRequestT = Model::UpdateRewardRequest>
  Model::UpdateRewardOutcomeCallable UpdateRewardCallable(const UpdateRewardRequestT& request) const {
    return SubmitCallable(&SagemakerJobRuntimeClient::UpdateReward, request);
  }
 
  template <typename UpdateRewardRequestT = Model::UpdateRewardRequest>
  void UpdateRewardAsync(const UpdateRewardRequestT& request, const UpdateRewardResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SagemakerJobRuntimeClient::UpdateReward, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<SagemakerJobRuntimeEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<SagemakerJobRuntimeClient>;
  void init(const SagemakerJobRuntimeClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, SagemakerJobRuntimeError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  SagemakerJobRuntimeClientConfiguration m_clientConfiguration;
  std::shared_ptr<SagemakerJobRuntimeEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace SagemakerJobRuntime
}  // namespace Aws