ApplicationAutoScalingClient.h

 
#pragma once
#include <aws/application-autoscaling/ApplicationAutoScalingPaginationBase.h>
#include <aws/application-autoscaling/ApplicationAutoScalingServiceClientModel.h>
#include <aws/application-autoscaling/ApplicationAutoScalingWaiter.h>
#include <aws/application-autoscaling/ApplicationAutoScaling_EXPORTS.h>
#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>
 
namespace Aws {
namespace ApplicationAutoScaling {
class AWS_APPLICATIONAUTOSCALING_API ApplicationAutoScalingClient
    : public Aws::Client::AWSJsonClient,
      public Aws::Client::ClientWithAsyncTemplateMethods<ApplicationAutoScalingClient>,
      public ApplicationAutoScalingPaginationBase<ApplicationAutoScalingClient>,
      public ApplicationAutoScalingWaiter<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::GetPredictiveScalingForecastOutcome GetPredictiveScalingForecast(
      const Model::GetPredictiveScalingForecastRequest& request) const;
 
  template <typename GetPredictiveScalingForecastRequestT = Model::GetPredictiveScalingForecastRequest>
  Model::GetPredictiveScalingForecastOutcomeCallable GetPredictiveScalingForecastCallable(
      const GetPredictiveScalingForecastRequestT& request) const {
    return SubmitCallable(&ApplicationAutoScalingClient::GetPredictiveScalingForecast, request);
  }
 
  template <typename GetPredictiveScalingForecastRequestT = Model::GetPredictiveScalingForecastRequest>
  void GetPredictiveScalingForecastAsync(const GetPredictiveScalingForecastRequestT& request,
                                         const GetPredictiveScalingForecastResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApplicationAutoScalingClient::GetPredictiveScalingForecast, 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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<ApplicationAutoScalingEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<ApplicationAutoScalingClient>;
  void init(const ApplicationAutoScalingClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, ApplicationAutoScalingError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  ApplicationAutoScalingClientConfiguration m_clientConfiguration;
  std::shared_ptr<ApplicationAutoScalingEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace ApplicationAutoScaling
}  // namespace Aws