PCSClient.h

 
#pragma once
#include <aws/pcs/PCS_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/pcs/PCSServiceClientModel.h>
 
namespace Aws
{
namespace PCS
{
  class AWS_PCS_API PCSClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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::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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      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