PCSClient.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/pcs/PCSPaginationBase.h>
#include <aws/pcs/PCSServiceClientModel.h>
#include <aws/pcs/PCS_EXPORTS.h>
 
namespace Aws {
namespace PCS {
class AWS_PCS_API PCSClient : public Aws::Client::AWSJsonClient,
                              public Aws::Client::ClientWithAsyncTemplateMethods<PCSClient>,
                              public PCSPaginationBase<PCSClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef PCSClientConfiguration ClientConfigurationType;
  typedef PCSEndpointProvider EndpointProviderType;
 
  PCSClient(const Aws::PCS::PCSClientConfiguration& clientConfiguration = Aws::PCS::PCSClientConfiguration(),
            std::shared_ptr<PCSEndpointProviderBase> endpointProvider = nullptr);
 
  PCSClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<PCSEndpointProviderBase> endpointProvider = nullptr,
            const Aws::PCS::PCSClientConfiguration& clientConfiguration = Aws::PCS::PCSClientConfiguration());
 
  PCSClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
            std::shared_ptr<PCSEndpointProviderBase> endpointProvider = nullptr,
            const Aws::PCS::PCSClientConfiguration& clientConfiguration = Aws::PCS::PCSClientConfiguration());
 
  /* Legacy constructors due deprecation */
  PCSClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  PCSClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  PCSClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
            const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~PCSClient();
 
  virtual Model::CreateClusterOutcome CreateCluster(const Model::CreateClusterRequest& request) const;
 
  template <typename CreateClusterRequestT = Model::CreateClusterRequest>
  Model::CreateClusterOutcomeCallable CreateClusterCallable(const CreateClusterRequestT& request) const {
    return SubmitCallable(&PCSClient::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(&PCSClient::CreateCluster, request, handler, context);
  }
 
  virtual Model::CreateComputeNodeGroupOutcome CreateComputeNodeGroup(const Model::CreateComputeNodeGroupRequest& request) const;
 
  template <typename CreateComputeNodeGroupRequestT = Model::CreateComputeNodeGroupRequest>
  Model::CreateComputeNodeGroupOutcomeCallable CreateComputeNodeGroupCallable(const CreateComputeNodeGroupRequestT& request) const {
    return SubmitCallable(&PCSClient::CreateComputeNodeGroup, request);
  }
 
  template <typename CreateComputeNodeGroupRequestT = Model::CreateComputeNodeGroupRequest>
  void CreateComputeNodeGroupAsync(const CreateComputeNodeGroupRequestT& request,
                                   const CreateComputeNodeGroupResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PCSClient::CreateComputeNodeGroup, request, handler, context);
  }
 
  virtual Model::CreateQueueOutcome CreateQueue(const Model::CreateQueueRequest& request) const;
 
  template <typename CreateQueueRequestT = Model::CreateQueueRequest>
  Model::CreateQueueOutcomeCallable CreateQueueCallable(const CreateQueueRequestT& request) const {
    return SubmitCallable(&PCSClient::CreateQueue, request);
  }
 
  template <typename CreateQueueRequestT = Model::CreateQueueRequest>
  void CreateQueueAsync(const CreateQueueRequestT& request, const CreateQueueResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PCSClient::CreateQueue, 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(&PCSClient::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(&PCSClient::DeleteCluster, request, handler, context);
  }
 
  virtual Model::DeleteComputeNodeGroupOutcome DeleteComputeNodeGroup(const Model::DeleteComputeNodeGroupRequest& request) const;
 
  template <typename DeleteComputeNodeGroupRequestT = Model::DeleteComputeNodeGroupRequest>
  Model::DeleteComputeNodeGroupOutcomeCallable DeleteComputeNodeGroupCallable(const DeleteComputeNodeGroupRequestT& request) const {
    return SubmitCallable(&PCSClient::DeleteComputeNodeGroup, request);
  }
 
  template <typename DeleteComputeNodeGroupRequestT = Model::DeleteComputeNodeGroupRequest>
  void DeleteComputeNodeGroupAsync(const DeleteComputeNodeGroupRequestT& request,
                                   const DeleteComputeNodeGroupResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PCSClient::DeleteComputeNodeGroup, request, handler, context);
  }
 
  virtual Model::DeleteQueueOutcome DeleteQueue(const Model::DeleteQueueRequest& request) const;
 
  template <typename DeleteQueueRequestT = Model::DeleteQueueRequest>
  Model::DeleteQueueOutcomeCallable DeleteQueueCallable(const DeleteQueueRequestT& request) const {
    return SubmitCallable(&PCSClient::DeleteQueue, request);
  }
 
  template <typename DeleteQueueRequestT = Model::DeleteQueueRequest>
  void DeleteQueueAsync(const DeleteQueueRequestT& request, const DeleteQueueResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PCSClient::DeleteQueue, request, handler, context);
  }
 
  virtual Model::GetClusterOutcome GetCluster(const Model::GetClusterRequest& request) const;
 
  template <typename GetClusterRequestT = Model::GetClusterRequest>
  Model::GetClusterOutcomeCallable GetClusterCallable(const GetClusterRequestT& request) const {
    return SubmitCallable(&PCSClient::GetCluster, request);
  }
 
  template <typename GetClusterRequestT = Model::GetClusterRequest>
  void GetClusterAsync(const GetClusterRequestT& request, const GetClusterResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PCSClient::GetCluster, request, handler, context);
  }
 
  virtual Model::GetComputeNodeGroupOutcome GetComputeNodeGroup(const Model::GetComputeNodeGroupRequest& request) const;
 
  template <typename GetComputeNodeGroupRequestT = Model::GetComputeNodeGroupRequest>
  Model::GetComputeNodeGroupOutcomeCallable GetComputeNodeGroupCallable(const GetComputeNodeGroupRequestT& request) const {
    return SubmitCallable(&PCSClient::GetComputeNodeGroup, request);
  }
 
  template <typename GetComputeNodeGroupRequestT = Model::GetComputeNodeGroupRequest>
  void GetComputeNodeGroupAsync(const GetComputeNodeGroupRequestT& request, const GetComputeNodeGroupResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PCSClient::GetComputeNodeGroup, request, handler, context);
  }
 
  virtual Model::GetQueueOutcome GetQueue(const Model::GetQueueRequest& request) const;
 
  template <typename GetQueueRequestT = Model::GetQueueRequest>
  Model::GetQueueOutcomeCallable GetQueueCallable(const GetQueueRequestT& request) const {
    return SubmitCallable(&PCSClient::GetQueue, request);
  }
 
  template <typename GetQueueRequestT = Model::GetQueueRequest>
  void GetQueueAsync(const GetQueueRequestT& request, const GetQueueResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PCSClient::GetQueue, request, handler, context);
  }
 
  virtual Model::ListClustersOutcome ListClusters(const Model::ListClustersRequest& request = {}) const;
 
  template <typename ListClustersRequestT = Model::ListClustersRequest>
  Model::ListClustersOutcomeCallable ListClustersCallable(const ListClustersRequestT& request = {}) const {
    return SubmitCallable(&PCSClient::ListClusters, request);
  }
 
  template <typename ListClustersRequestT = Model::ListClustersRequest>
  void ListClustersAsync(const ListClustersResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const ListClustersRequestT& request = {}) const {
    return SubmitAsync(&PCSClient::ListClusters, request, handler, context);
  }
 
  virtual Model::ListComputeNodeGroupsOutcome ListComputeNodeGroups(const Model::ListComputeNodeGroupsRequest& request) const;
 
  template <typename ListComputeNodeGroupsRequestT = Model::ListComputeNodeGroupsRequest>
  Model::ListComputeNodeGroupsOutcomeCallable ListComputeNodeGroupsCallable(const ListComputeNodeGroupsRequestT& request) const {
    return SubmitCallable(&PCSClient::ListComputeNodeGroups, request);
  }
 
  template <typename ListComputeNodeGroupsRequestT = Model::ListComputeNodeGroupsRequest>
  void ListComputeNodeGroupsAsync(const ListComputeNodeGroupsRequestT& request, const ListComputeNodeGroupsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PCSClient::ListComputeNodeGroups, request, handler, context);
  }
 
  virtual Model::ListQueuesOutcome ListQueues(const Model::ListQueuesRequest& request) const;
 
  template <typename ListQueuesRequestT = Model::ListQueuesRequest>
  Model::ListQueuesOutcomeCallable ListQueuesCallable(const ListQueuesRequestT& request) const {
    return SubmitCallable(&PCSClient::ListQueues, request);
  }
 
  template <typename ListQueuesRequestT = Model::ListQueuesRequest>
  void ListQueuesAsync(const ListQueuesRequestT& request, const ListQueuesResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PCSClient::ListQueues, request, handler, context);
  }
 
  virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const;
 
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const {
    return SubmitCallable(&PCSClient::ListTagsForResource, request);
  }
 
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PCSClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::RegisterComputeNodeGroupInstanceOutcome RegisterComputeNodeGroupInstance(
      const Model::RegisterComputeNodeGroupInstanceRequest& request) const;
 
  template <typename RegisterComputeNodeGroupInstanceRequestT = Model::RegisterComputeNodeGroupInstanceRequest>
  Model::RegisterComputeNodeGroupInstanceOutcomeCallable RegisterComputeNodeGroupInstanceCallable(
      const RegisterComputeNodeGroupInstanceRequestT& request) const {
    return SubmitCallable(&PCSClient::RegisterComputeNodeGroupInstance, request);
  }
 
  template <typename RegisterComputeNodeGroupInstanceRequestT = Model::RegisterComputeNodeGroupInstanceRequest>
  void RegisterComputeNodeGroupInstanceAsync(const RegisterComputeNodeGroupInstanceRequestT& request,
                                             const RegisterComputeNodeGroupInstanceResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PCSClient::RegisterComputeNodeGroupInstance, 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(&PCSClient::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(&PCSClient::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(&PCSClient::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(&PCSClient::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(&PCSClient::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(&PCSClient::UpdateCluster, request, handler, context);
  }
 
  virtual Model::UpdateComputeNodeGroupOutcome UpdateComputeNodeGroup(const Model::UpdateComputeNodeGroupRequest& request) const;
 
  template <typename UpdateComputeNodeGroupRequestT = Model::UpdateComputeNodeGroupRequest>
  Model::UpdateComputeNodeGroupOutcomeCallable UpdateComputeNodeGroupCallable(const UpdateComputeNodeGroupRequestT& request) const {
    return SubmitCallable(&PCSClient::UpdateComputeNodeGroup, request);
  }
 
  template <typename UpdateComputeNodeGroupRequestT = Model::UpdateComputeNodeGroupRequest>
  void UpdateComputeNodeGroupAsync(const UpdateComputeNodeGroupRequestT& request,
                                   const UpdateComputeNodeGroupResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PCSClient::UpdateComputeNodeGroup, request, handler, context);
  }
 
  virtual Model::UpdateQueueOutcome UpdateQueue(const Model::UpdateQueueRequest& request) const;
 
  template <typename UpdateQueueRequestT = Model::UpdateQueueRequest>
  Model::UpdateQueueOutcomeCallable UpdateQueueCallable(const UpdateQueueRequestT& request) const {
    return SubmitCallable(&PCSClient::UpdateQueue, request);
  }
 
  template <typename UpdateQueueRequestT = Model::UpdateQueueRequest>
  void UpdateQueueAsync(const UpdateQueueRequestT& request, const UpdateQueueResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PCSClient::UpdateQueue, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<PCSEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<PCSClient>;
  void init(const PCSClientConfiguration& clientConfiguration);
 
  PCSClientConfiguration m_clientConfiguration;
  std::shared_ptr<PCSEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace PCS
}  // namespace Aws