EBSClient.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/ebs/EBSServiceClientModel.h>
#include <aws/ebs/EBS_EXPORTS.h>
 
namespace Aws {
namespace EBS {
class AWS_EBS_API EBSClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<EBSClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef EBSClientConfiguration ClientConfigurationType;
  typedef EBSEndpointProvider EndpointProviderType;
 
  EBSClient(const Aws::EBS::EBSClientConfiguration& clientConfiguration = Aws::EBS::EBSClientConfiguration(),
            std::shared_ptr<EBSEndpointProviderBase> endpointProvider = nullptr);
 
  EBSClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<EBSEndpointProviderBase> endpointProvider = nullptr,
            const Aws::EBS::EBSClientConfiguration& clientConfiguration = Aws::EBS::EBSClientConfiguration());
 
  EBSClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
            std::shared_ptr<EBSEndpointProviderBase> endpointProvider = nullptr,
            const Aws::EBS::EBSClientConfiguration& clientConfiguration = Aws::EBS::EBSClientConfiguration());
 
  /* Legacy constructors due deprecation */
  EBSClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  EBSClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  EBSClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
            const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~EBSClient();
 
  virtual Model::CompleteSnapshotOutcome CompleteSnapshot(const Model::CompleteSnapshotRequest& request) const;
 
  template <typename CompleteSnapshotRequestT = Model::CompleteSnapshotRequest>
  Model::CompleteSnapshotOutcomeCallable CompleteSnapshotCallable(const CompleteSnapshotRequestT& request) const {
    return SubmitCallable(&EBSClient::CompleteSnapshot, request);
  }
 
  template <typename CompleteSnapshotRequestT = Model::CompleteSnapshotRequest>
  void CompleteSnapshotAsync(const CompleteSnapshotRequestT& request, const CompleteSnapshotResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EBSClient::CompleteSnapshot, request, handler, context);
  }
 
  virtual Model::GetSnapshotBlockOutcome GetSnapshotBlock(const Model::GetSnapshotBlockRequest& request) const;
 
  template <typename GetSnapshotBlockRequestT = Model::GetSnapshotBlockRequest>
  Model::GetSnapshotBlockOutcomeCallable GetSnapshotBlockCallable(const GetSnapshotBlockRequestT& request) const {
    return SubmitCallable(&EBSClient::GetSnapshotBlock, request);
  }
 
  template <typename GetSnapshotBlockRequestT = Model::GetSnapshotBlockRequest>
  void GetSnapshotBlockAsync(const GetSnapshotBlockRequestT& request, const GetSnapshotBlockResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EBSClient::GetSnapshotBlock, request, handler, context);
  }
 
  virtual Model::ListChangedBlocksOutcome ListChangedBlocks(const Model::ListChangedBlocksRequest& request) const;
 
  template <typename ListChangedBlocksRequestT = Model::ListChangedBlocksRequest>
  Model::ListChangedBlocksOutcomeCallable ListChangedBlocksCallable(const ListChangedBlocksRequestT& request) const {
    return SubmitCallable(&EBSClient::ListChangedBlocks, request);
  }
 
  template <typename ListChangedBlocksRequestT = Model::ListChangedBlocksRequest>
  void ListChangedBlocksAsync(const ListChangedBlocksRequestT& request, const ListChangedBlocksResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EBSClient::ListChangedBlocks, request, handler, context);
  }
 
  virtual Model::ListSnapshotBlocksOutcome ListSnapshotBlocks(const Model::ListSnapshotBlocksRequest& request) const;
 
  template <typename ListSnapshotBlocksRequestT = Model::ListSnapshotBlocksRequest>
  Model::ListSnapshotBlocksOutcomeCallable ListSnapshotBlocksCallable(const ListSnapshotBlocksRequestT& request) const {
    return SubmitCallable(&EBSClient::ListSnapshotBlocks, request);
  }
 
  template <typename ListSnapshotBlocksRequestT = Model::ListSnapshotBlocksRequest>
  void ListSnapshotBlocksAsync(const ListSnapshotBlocksRequestT& request, const ListSnapshotBlocksResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EBSClient::ListSnapshotBlocks, request, handler, context);
  }
 
  virtual Model::PutSnapshotBlockOutcome PutSnapshotBlock(const Model::PutSnapshotBlockRequest& request) const;
 
  template <typename PutSnapshotBlockRequestT = Model::PutSnapshotBlockRequest>
  Model::PutSnapshotBlockOutcomeCallable PutSnapshotBlockCallable(const PutSnapshotBlockRequestT& request) const {
    return SubmitCallable(&EBSClient::PutSnapshotBlock, request);
  }
 
  template <typename PutSnapshotBlockRequestT = Model::PutSnapshotBlockRequest>
  void PutSnapshotBlockAsync(const PutSnapshotBlockRequestT& request, const PutSnapshotBlockResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EBSClient::PutSnapshotBlock, request, handler, context);
  }
 
  virtual Model::StartSnapshotOutcome StartSnapshot(const Model::StartSnapshotRequest& request) const;
 
  template <typename StartSnapshotRequestT = Model::StartSnapshotRequest>
  Model::StartSnapshotOutcomeCallable StartSnapshotCallable(const StartSnapshotRequestT& request) const {
    return SubmitCallable(&EBSClient::StartSnapshot, request);
  }
 
  template <typename StartSnapshotRequestT = Model::StartSnapshotRequest>
  void StartSnapshotAsync(const StartSnapshotRequestT& request, const StartSnapshotResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EBSClient::StartSnapshot, request, handler, context);
  }
 
  void OverrideEndpoint(const Aws::String& endpoint);
  std::shared_ptr<EBSEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<EBSClient>;
  void init(const EBSClientConfiguration& clientConfiguration);
 
  EBSClientConfiguration m_clientConfiguration;
  std::shared_ptr<EBSEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace EBS
}  // namespace Aws