KeyspacesStreamsClient.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/keyspacesstreams/KeyspacesStreamsPaginationBase.h>
#include <aws/keyspacesstreams/KeyspacesStreamsServiceClientModel.h>
#include <aws/keyspacesstreams/KeyspacesStreamsWaiter.h>
#include <aws/keyspacesstreams/KeyspacesStreams_EXPORTS.h>
 
namespace Aws {
namespace KeyspacesStreams {
class AWS_KEYSPACESSTREAMS_API KeyspacesStreamsClient : public Aws::Client::AWSJsonClient,
                                                        public Aws::Client::ClientWithAsyncTemplateMethods<KeyspacesStreamsClient>,
                                                        public KeyspacesStreamsPaginationBase<KeyspacesStreamsClient>,
                                                        public KeyspacesStreamsWaiter<KeyspacesStreamsClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef KeyspacesStreamsClientConfiguration ClientConfigurationType;
  typedef KeyspacesStreamsEndpointProvider EndpointProviderType;
 
  KeyspacesStreamsClient(const Aws::KeyspacesStreams::KeyspacesStreamsClientConfiguration& clientConfiguration =
                             Aws::KeyspacesStreams::KeyspacesStreamsClientConfiguration(),
                         std::shared_ptr<KeyspacesStreamsEndpointProviderBase> endpointProvider = nullptr);
 
  KeyspacesStreamsClient(const Aws::Auth::AWSCredentials& credentials,
                         std::shared_ptr<KeyspacesStreamsEndpointProviderBase> endpointProvider = nullptr,
                         const Aws::KeyspacesStreams::KeyspacesStreamsClientConfiguration& clientConfiguration =
                             Aws::KeyspacesStreams::KeyspacesStreamsClientConfiguration());
 
  KeyspacesStreamsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                         std::shared_ptr<KeyspacesStreamsEndpointProviderBase> endpointProvider = nullptr,
                         const Aws::KeyspacesStreams::KeyspacesStreamsClientConfiguration& clientConfiguration =
                             Aws::KeyspacesStreams::KeyspacesStreamsClientConfiguration());
 
  /* Legacy constructors due deprecation */
  KeyspacesStreamsClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  KeyspacesStreamsClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  KeyspacesStreamsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                         const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~KeyspacesStreamsClient();
 
  virtual Model::GetRecordsOutcome GetRecords(const Model::GetRecordsRequest& request) const;
 
  template <typename GetRecordsRequestT = Model::GetRecordsRequest>
  Model::GetRecordsOutcomeCallable GetRecordsCallable(const GetRecordsRequestT& request) const {
    return SubmitCallable(&KeyspacesStreamsClient::GetRecords, request);
  }
 
  template <typename GetRecordsRequestT = Model::GetRecordsRequest>
  void GetRecordsAsync(const GetRecordsRequestT& request, const GetRecordsResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KeyspacesStreamsClient::GetRecords, request, handler, context);
  }
 
  virtual Model::GetShardIteratorOutcome GetShardIterator(const Model::GetShardIteratorRequest& request) const;
 
  template <typename GetShardIteratorRequestT = Model::GetShardIteratorRequest>
  Model::GetShardIteratorOutcomeCallable GetShardIteratorCallable(const GetShardIteratorRequestT& request) const {
    return SubmitCallable(&KeyspacesStreamsClient::GetShardIterator, request);
  }
 
  template <typename GetShardIteratorRequestT = Model::GetShardIteratorRequest>
  void GetShardIteratorAsync(const GetShardIteratorRequestT& request, const GetShardIteratorResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KeyspacesStreamsClient::GetShardIterator, request, handler, context);
  }
 
  virtual Model::GetStreamOutcome GetStream(const Model::GetStreamRequest& request) const;
 
  template <typename GetStreamRequestT = Model::GetStreamRequest>
  Model::GetStreamOutcomeCallable GetStreamCallable(const GetStreamRequestT& request) const {
    return SubmitCallable(&KeyspacesStreamsClient::GetStream, request);
  }
 
  template <typename GetStreamRequestT = Model::GetStreamRequest>
  void GetStreamAsync(const GetStreamRequestT& request, const GetStreamResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KeyspacesStreamsClient::GetStream, request, handler, context);
  }
 
  virtual Model::ListStreamsOutcome ListStreams(const Model::ListStreamsRequest& request = {}) const;
 
  template <typename ListStreamsRequestT = Model::ListStreamsRequest>
  Model::ListStreamsOutcomeCallable ListStreamsCallable(const ListStreamsRequestT& request = {}) const {
    return SubmitCallable(&KeyspacesStreamsClient::ListStreams, request);
  }
 
  template <typename ListStreamsRequestT = Model::ListStreamsRequest>
  void ListStreamsAsync(const ListStreamsResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                        const ListStreamsRequestT& request = {}) const {
    return SubmitAsync(&KeyspacesStreamsClient::ListStreams, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<KeyspacesStreamsEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<KeyspacesStreamsClient>;
  void init(const KeyspacesStreamsClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, KeyspacesStreamsError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  KeyspacesStreamsClientConfiguration m_clientConfiguration;
  std::shared_ptr<KeyspacesStreamsEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace KeyspacesStreams
}  // namespace Aws