ApplicationAutoScalingClient.h

 
#pragma once
#include <aws/application-autoscaling/ApplicationAutoScaling_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/application-autoscaling/ApplicationAutoScalingServiceClientModel.h>
 
namespace Aws
{
namespace ApplicationAutoScaling
{
  class AWS_APPLICATIONAUTOSCALING_API ApplicationAutoScalingClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<ApplicationAutoScalingClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef ApplicationAutoScalingClientConfiguration ClientConfigurationType;
      typedef ApplicationAutoScalingEndpointProvider EndpointProviderType;
 
        ApplicationAutoScalingClient(const Aws::ApplicationAutoScaling::ApplicationAutoScalingClientConfiguration& clientConfiguration = Aws::ApplicationAutoScaling::ApplicationAutoScalingClientConfiguration(),
                                     std::shared_ptr<ApplicationAutoScalingEndpointProviderBase> endpointProvider = nullptr);
 
        ApplicationAutoScalingClient(const Aws::Auth::AWSCredentials& credentials,
                                     std::shared_ptr<ApplicationAutoScalingEndpointProviderBase> endpointProvider = nullptr,
                                     const Aws::ApplicationAutoScaling::ApplicationAutoScalingClientConfiguration& clientConfiguration = Aws::ApplicationAutoScaling::ApplicationAutoScalingClientConfiguration());
 
        ApplicationAutoScalingClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                                     std::shared_ptr<ApplicationAutoScalingEndpointProviderBase> endpointProvider = nullptr,
                                     const Aws::ApplicationAutoScaling::ApplicationAutoScalingClientConfiguration& clientConfiguration = Aws::ApplicationAutoScaling::ApplicationAutoScalingClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        ApplicationAutoScalingClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        ApplicationAutoScalingClient(const Aws::Auth::AWSCredentials& credentials,
                                     const Aws::Client::ClientConfiguration& clientConfiguration);
 
        ApplicationAutoScalingClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                                     const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~ApplicationAutoScalingClient();
 
        virtual Model::DeleteScalingPolicyOutcome DeleteScalingPolicy(const Model::DeleteScalingPolicyRequest& request) const;
 
        template<typename DeleteScalingPolicyRequestT = Model::DeleteScalingPolicyRequest>
        Model::DeleteScalingPolicyOutcomeCallable DeleteScalingPolicyCallable(const DeleteScalingPolicyRequestT& request) const
        {
            return SubmitCallable(&ApplicationAutoScalingClient::DeleteScalingPolicy, request);
        }
 
        template<typename DeleteScalingPolicyRequestT = Model::DeleteScalingPolicyRequest>
        void DeleteScalingPolicyAsync(const DeleteScalingPolicyRequestT& request, const DeleteScalingPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationAutoScalingClient::DeleteScalingPolicy, request, handler, context);
        }
 
        virtual Model::DeleteScheduledActionOutcome DeleteScheduledAction(const Model::DeleteScheduledActionRequest& request) const;
 
        template<typename DeleteScheduledActionRequestT = Model::DeleteScheduledActionRequest>
        Model::DeleteScheduledActionOutcomeCallable DeleteScheduledActionCallable(const DeleteScheduledActionRequestT& request) const
        {
            return SubmitCallable(&ApplicationAutoScalingClient::DeleteScheduledAction, request);
        }
 
        template<typename DeleteScheduledActionRequestT = Model::DeleteScheduledActionRequest>
        void DeleteScheduledActionAsync(const DeleteScheduledActionRequestT& request, const DeleteScheduledActionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationAutoScalingClient::DeleteScheduledAction, request, handler, context);
        }
 
        virtual Model::DeregisterScalableTargetOutcome DeregisterScalableTarget(const Model::DeregisterScalableTargetRequest& request) const;
 
        template<typename DeregisterScalableTargetRequestT = Model::DeregisterScalableTargetRequest>
        Model::DeregisterScalableTargetOutcomeCallable DeregisterScalableTargetCallable(const DeregisterScalableTargetRequestT& request) const
        {
            return SubmitCallable(&ApplicationAutoScalingClient::DeregisterScalableTarget, request);
        }
 
        template<typename DeregisterScalableTargetRequestT = Model::DeregisterScalableTargetRequest>
        void DeregisterScalableTargetAsync(const DeregisterScalableTargetRequestT& request, const DeregisterScalableTargetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationAutoScalingClient::DeregisterScalableTarget, request, handler, context);
        }
 
        virtual Model::DescribeScalableTargetsOutcome DescribeScalableTargets(const Model::DescribeScalableTargetsRequest& request) const;
 
        template<typename DescribeScalableTargetsRequestT = Model::DescribeScalableTargetsRequest>
        Model::DescribeScalableTargetsOutcomeCallable DescribeScalableTargetsCallable(const DescribeScalableTargetsRequestT& request) const
        {
            return SubmitCallable(&ApplicationAutoScalingClient::DescribeScalableTargets, request);
        }
 
        template<typename DescribeScalableTargetsRequestT = Model::DescribeScalableTargetsRequest>
        void DescribeScalableTargetsAsync(const DescribeScalableTargetsRequestT& request, const DescribeScalableTargetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationAutoScalingClient::DescribeScalableTargets, request, handler, context);
        }
 
        virtual Model::DescribeScalingActivitiesOutcome DescribeScalingActivities(const Model::DescribeScalingActivitiesRequest& request) const;
 
        template<typename DescribeScalingActivitiesRequestT = Model::DescribeScalingActivitiesRequest>
        Model::DescribeScalingActivitiesOutcomeCallable DescribeScalingActivitiesCallable(const DescribeScalingActivitiesRequestT& request) const
        {
            return SubmitCallable(&ApplicationAutoScalingClient::DescribeScalingActivities, request);
        }
 
        template<typename DescribeScalingActivitiesRequestT = Model::DescribeScalingActivitiesRequest>
        void DescribeScalingActivitiesAsync(const DescribeScalingActivitiesRequestT& request, const DescribeScalingActivitiesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationAutoScalingClient::DescribeScalingActivities, request, handler, context);
        }
 
        virtual Model::DescribeScalingPoliciesOutcome DescribeScalingPolicies(const Model::DescribeScalingPoliciesRequest& request) const;
 
        template<typename DescribeScalingPoliciesRequestT = Model::DescribeScalingPoliciesRequest>
        Model::DescribeScalingPoliciesOutcomeCallable DescribeScalingPoliciesCallable(const DescribeScalingPoliciesRequestT& request) const
        {
            return SubmitCallable(&ApplicationAutoScalingClient::DescribeScalingPolicies, request);
        }
 
        template<typename DescribeScalingPoliciesRequestT = Model::DescribeScalingPoliciesRequest>
        void DescribeScalingPoliciesAsync(const DescribeScalingPoliciesRequestT& request, const DescribeScalingPoliciesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationAutoScalingClient::DescribeScalingPolicies, request, handler, context);
        }
 
        virtual Model::DescribeScheduledActionsOutcome DescribeScheduledActions(const Model::DescribeScheduledActionsRequest& request) const;
 
        template<typename DescribeScheduledActionsRequestT = Model::DescribeScheduledActionsRequest>
        Model::DescribeScheduledActionsOutcomeCallable DescribeScheduledActionsCallable(const DescribeScheduledActionsRequestT& request) const
        {
            return SubmitCallable(&ApplicationAutoScalingClient::DescribeScheduledActions, request);
        }
 
        template<typename DescribeScheduledActionsRequestT = Model::DescribeScheduledActionsRequest>
        void DescribeScheduledActionsAsync(const DescribeScheduledActionsRequestT& request, const DescribeScheduledActionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationAutoScalingClient::DescribeScheduledActions, 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(&ApplicationAutoScalingClient::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(&ApplicationAutoScalingClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::PutScalingPolicyOutcome PutScalingPolicy(const Model::PutScalingPolicyRequest& request) const;
 
        template<typename PutScalingPolicyRequestT = Model::PutScalingPolicyRequest>
        Model::PutScalingPolicyOutcomeCallable PutScalingPolicyCallable(const PutScalingPolicyRequestT& request) const
        {
            return SubmitCallable(&ApplicationAutoScalingClient::PutScalingPolicy, request);
        }
 
        template<typename PutScalingPolicyRequestT = Model::PutScalingPolicyRequest>
        void PutScalingPolicyAsync(const PutScalingPolicyRequestT& request, const PutScalingPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationAutoScalingClient::PutScalingPolicy, request, handler, context);
        }
 
        virtual Model::PutScheduledActionOutcome PutScheduledAction(const Model::PutScheduledActionRequest& request) const;
 
        template<typename PutScheduledActionRequestT = Model::PutScheduledActionRequest>
        Model::PutScheduledActionOutcomeCallable PutScheduledActionCallable(const PutScheduledActionRequestT& request) const
        {
            return SubmitCallable(&ApplicationAutoScalingClient::PutScheduledAction, request);
        }
 
        template<typename PutScheduledActionRequestT = Model::PutScheduledActionRequest>
        void PutScheduledActionAsync(const PutScheduledActionRequestT& request, const PutScheduledActionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationAutoScalingClient::PutScheduledAction, request, handler, context);
        }
 
        virtual Model::RegisterScalableTargetOutcome RegisterScalableTarget(const Model::RegisterScalableTargetRequest& request) const;
 
        template<typename RegisterScalableTargetRequestT = Model::RegisterScalableTargetRequest>
        Model::RegisterScalableTargetOutcomeCallable RegisterScalableTargetCallable(const RegisterScalableTargetRequestT& request) const
        {
            return SubmitCallable(&ApplicationAutoScalingClient::RegisterScalableTarget, request);
        }
 
        template<typename RegisterScalableTargetRequestT = Model::RegisterScalableTargetRequest>
        void RegisterScalableTargetAsync(const RegisterScalableTargetRequestT& request, const RegisterScalableTargetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationAutoScalingClient::RegisterScalableTarget, 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(&ApplicationAutoScalingClient::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(&ApplicationAutoScalingClient::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(&ApplicationAutoScalingClient::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(&ApplicationAutoScalingClient::UntagResource, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<ApplicationAutoScalingEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<ApplicationAutoScalingClient>;
      void init(const ApplicationAutoScalingClientConfiguration& clientConfiguration);
 
      ApplicationAutoScalingClientConfiguration m_clientConfiguration;
      std::shared_ptr<ApplicationAutoScalingEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace ApplicationAutoScaling
} // namespace Aws