PIClient.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/pi/PIPaginationBase.h>
#include <aws/pi/PIServiceClientModel.h>
#include <aws/pi/PIWaiter.h>
#include <aws/pi/PI_EXPORTS.h>
 
namespace Aws {
namespace PI {
class AWS_PI_API PIClient : public Aws::Client::AWSJsonClient,
                            public Aws::Client::ClientWithAsyncTemplateMethods<PIClient>,
                            public PIPaginationBase<PIClient>,
                            public PIWaiter<PIClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef PIClientConfiguration ClientConfigurationType;
  typedef PIEndpointProvider EndpointProviderType;
 
  PIClient(const Aws::PI::PIClientConfiguration& clientConfiguration = Aws::PI::PIClientConfiguration(),
           std::shared_ptr<PIEndpointProviderBase> endpointProvider = nullptr);
 
  PIClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<PIEndpointProviderBase> endpointProvider = nullptr,
           const Aws::PI::PIClientConfiguration& clientConfiguration = Aws::PI::PIClientConfiguration());
 
  PIClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
           std::shared_ptr<PIEndpointProviderBase> endpointProvider = nullptr,
           const Aws::PI::PIClientConfiguration& clientConfiguration = Aws::PI::PIClientConfiguration());
 
  /* Legacy constructors due deprecation */
  PIClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  PIClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  PIClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
           const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~PIClient();
 
  virtual Model::CreatePerformanceAnalysisReportOutcome CreatePerformanceAnalysisReport(
      const Model::CreatePerformanceAnalysisReportRequest& request) const;
 
  template <typename CreatePerformanceAnalysisReportRequestT = Model::CreatePerformanceAnalysisReportRequest>
  Model::CreatePerformanceAnalysisReportOutcomeCallable CreatePerformanceAnalysisReportCallable(
      const CreatePerformanceAnalysisReportRequestT& request) const {
    return SubmitCallable(&PIClient::CreatePerformanceAnalysisReport, request);
  }
 
  template <typename CreatePerformanceAnalysisReportRequestT = Model::CreatePerformanceAnalysisReportRequest>
  void CreatePerformanceAnalysisReportAsync(const CreatePerformanceAnalysisReportRequestT& request,
                                            const CreatePerformanceAnalysisReportResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PIClient::CreatePerformanceAnalysisReport, request, handler, context);
  }
 
  virtual Model::DeletePerformanceAnalysisReportOutcome DeletePerformanceAnalysisReport(
      const Model::DeletePerformanceAnalysisReportRequest& request) const;
 
  template <typename DeletePerformanceAnalysisReportRequestT = Model::DeletePerformanceAnalysisReportRequest>
  Model::DeletePerformanceAnalysisReportOutcomeCallable DeletePerformanceAnalysisReportCallable(
      const DeletePerformanceAnalysisReportRequestT& request) const {
    return SubmitCallable(&PIClient::DeletePerformanceAnalysisReport, request);
  }
 
  template <typename DeletePerformanceAnalysisReportRequestT = Model::DeletePerformanceAnalysisReportRequest>
  void DeletePerformanceAnalysisReportAsync(const DeletePerformanceAnalysisReportRequestT& request,
                                            const DeletePerformanceAnalysisReportResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PIClient::DeletePerformanceAnalysisReport, request, handler, context);
  }
 
  virtual Model::DescribeDimensionKeysOutcome DescribeDimensionKeys(const Model::DescribeDimensionKeysRequest& request) const;
 
  template <typename DescribeDimensionKeysRequestT = Model::DescribeDimensionKeysRequest>
  Model::DescribeDimensionKeysOutcomeCallable DescribeDimensionKeysCallable(const DescribeDimensionKeysRequestT& request) const {
    return SubmitCallable(&PIClient::DescribeDimensionKeys, request);
  }
 
  template <typename DescribeDimensionKeysRequestT = Model::DescribeDimensionKeysRequest>
  void DescribeDimensionKeysAsync(const DescribeDimensionKeysRequestT& request, const DescribeDimensionKeysResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PIClient::DescribeDimensionKeys, request, handler, context);
  }
 
  virtual Model::GetDimensionKeyDetailsOutcome GetDimensionKeyDetails(const Model::GetDimensionKeyDetailsRequest& request) const;
 
  template <typename GetDimensionKeyDetailsRequestT = Model::GetDimensionKeyDetailsRequest>
  Model::GetDimensionKeyDetailsOutcomeCallable GetDimensionKeyDetailsCallable(const GetDimensionKeyDetailsRequestT& request) const {
    return SubmitCallable(&PIClient::GetDimensionKeyDetails, request);
  }
 
  template <typename GetDimensionKeyDetailsRequestT = Model::GetDimensionKeyDetailsRequest>
  void GetDimensionKeyDetailsAsync(const GetDimensionKeyDetailsRequestT& request,
                                   const GetDimensionKeyDetailsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PIClient::GetDimensionKeyDetails, request, handler, context);
  }
 
  virtual Model::GetPerformanceAnalysisReportOutcome GetPerformanceAnalysisReport(
      const Model::GetPerformanceAnalysisReportRequest& request) const;
 
  template <typename GetPerformanceAnalysisReportRequestT = Model::GetPerformanceAnalysisReportRequest>
  Model::GetPerformanceAnalysisReportOutcomeCallable GetPerformanceAnalysisReportCallable(
      const GetPerformanceAnalysisReportRequestT& request) const {
    return SubmitCallable(&PIClient::GetPerformanceAnalysisReport, request);
  }
 
  template <typename GetPerformanceAnalysisReportRequestT = Model::GetPerformanceAnalysisReportRequest>
  void GetPerformanceAnalysisReportAsync(const GetPerformanceAnalysisReportRequestT& request,
                                         const GetPerformanceAnalysisReportResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PIClient::GetPerformanceAnalysisReport, request, handler, context);
  }
 
  virtual Model::GetResourceMetadataOutcome GetResourceMetadata(const Model::GetResourceMetadataRequest& request) const;
 
  template <typename GetResourceMetadataRequestT = Model::GetResourceMetadataRequest>
  Model::GetResourceMetadataOutcomeCallable GetResourceMetadataCallable(const GetResourceMetadataRequestT& request) const {
    return SubmitCallable(&PIClient::GetResourceMetadata, request);
  }
 
  template <typename GetResourceMetadataRequestT = Model::GetResourceMetadataRequest>
  void GetResourceMetadataAsync(const GetResourceMetadataRequestT& request, const GetResourceMetadataResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PIClient::GetResourceMetadata, request, handler, context);
  }
 
  virtual Model::GetResourceMetricsOutcome GetResourceMetrics(const Model::GetResourceMetricsRequest& request) const;
 
  template <typename GetResourceMetricsRequestT = Model::GetResourceMetricsRequest>
  Model::GetResourceMetricsOutcomeCallable GetResourceMetricsCallable(const GetResourceMetricsRequestT& request) const {
    return SubmitCallable(&PIClient::GetResourceMetrics, request);
  }
 
  template <typename GetResourceMetricsRequestT = Model::GetResourceMetricsRequest>
  void GetResourceMetricsAsync(const GetResourceMetricsRequestT& request, const GetResourceMetricsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PIClient::GetResourceMetrics, request, handler, context);
  }
 
  virtual Model::ListAvailableResourceDimensionsOutcome ListAvailableResourceDimensions(
      const Model::ListAvailableResourceDimensionsRequest& request) const;
 
  template <typename ListAvailableResourceDimensionsRequestT = Model::ListAvailableResourceDimensionsRequest>
  Model::ListAvailableResourceDimensionsOutcomeCallable ListAvailableResourceDimensionsCallable(
      const ListAvailableResourceDimensionsRequestT& request) const {
    return SubmitCallable(&PIClient::ListAvailableResourceDimensions, request);
  }
 
  template <typename ListAvailableResourceDimensionsRequestT = Model::ListAvailableResourceDimensionsRequest>
  void ListAvailableResourceDimensionsAsync(const ListAvailableResourceDimensionsRequestT& request,
                                            const ListAvailableResourceDimensionsResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PIClient::ListAvailableResourceDimensions, request, handler, context);
  }
 
  virtual Model::ListAvailableResourceMetricsOutcome ListAvailableResourceMetrics(
      const Model::ListAvailableResourceMetricsRequest& request) const;
 
  template <typename ListAvailableResourceMetricsRequestT = Model::ListAvailableResourceMetricsRequest>
  Model::ListAvailableResourceMetricsOutcomeCallable ListAvailableResourceMetricsCallable(
      const ListAvailableResourceMetricsRequestT& request) const {
    return SubmitCallable(&PIClient::ListAvailableResourceMetrics, request);
  }
 
  template <typename ListAvailableResourceMetricsRequestT = Model::ListAvailableResourceMetricsRequest>
  void ListAvailableResourceMetricsAsync(const ListAvailableResourceMetricsRequestT& request,
                                         const ListAvailableResourceMetricsResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PIClient::ListAvailableResourceMetrics, request, handler, context);
  }
 
  virtual Model::ListPerformanceAnalysisReportsOutcome ListPerformanceAnalysisReports(
      const Model::ListPerformanceAnalysisReportsRequest& request) const;
 
  template <typename ListPerformanceAnalysisReportsRequestT = Model::ListPerformanceAnalysisReportsRequest>
  Model::ListPerformanceAnalysisReportsOutcomeCallable ListPerformanceAnalysisReportsCallable(
      const ListPerformanceAnalysisReportsRequestT& request) const {
    return SubmitCallable(&PIClient::ListPerformanceAnalysisReports, request);
  }
 
  template <typename ListPerformanceAnalysisReportsRequestT = Model::ListPerformanceAnalysisReportsRequest>
  void ListPerformanceAnalysisReportsAsync(const ListPerformanceAnalysisReportsRequestT& request,
                                           const ListPerformanceAnalysisReportsResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PIClient::ListPerformanceAnalysisReports, 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(&PIClient::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(&PIClient::ListTagsForResource, 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(&PIClient::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(&PIClient::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(&PIClient::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(&PIClient::UntagResource, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<PIEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<PIClient>;
  void init(const PIClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, PIError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  PIClientConfiguration m_clientConfiguration;
  std::shared_ptr<PIEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace PI
}  // namespace Aws