CodeGuruProfilerClient.h

 
#pragma once
#include <aws/codeguruprofiler/CodeGuruProfiler_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/codeguruprofiler/CodeGuruProfilerServiceClientModel.h>
 
namespace Aws
{
namespace CodeGuruProfiler
{
  class AWS_CODEGURUPROFILER_API CodeGuruProfilerClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<CodeGuruProfilerClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef CodeGuruProfilerClientConfiguration ClientConfigurationType;
      typedef CodeGuruProfilerEndpointProvider EndpointProviderType;
 
        CodeGuruProfilerClient(const Aws::CodeGuruProfiler::CodeGuruProfilerClientConfiguration& clientConfiguration = Aws::CodeGuruProfiler::CodeGuruProfilerClientConfiguration(),
                               std::shared_ptr<CodeGuruProfilerEndpointProviderBase> endpointProvider = nullptr);
 
        CodeGuruProfilerClient(const Aws::Auth::AWSCredentials& credentials,
                               std::shared_ptr<CodeGuruProfilerEndpointProviderBase> endpointProvider = nullptr,
                               const Aws::CodeGuruProfiler::CodeGuruProfilerClientConfiguration& clientConfiguration = Aws::CodeGuruProfiler::CodeGuruProfilerClientConfiguration());
 
        CodeGuruProfilerClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                               std::shared_ptr<CodeGuruProfilerEndpointProviderBase> endpointProvider = nullptr,
                               const Aws::CodeGuruProfiler::CodeGuruProfilerClientConfiguration& clientConfiguration = Aws::CodeGuruProfiler::CodeGuruProfilerClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        CodeGuruProfilerClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        CodeGuruProfilerClient(const Aws::Auth::AWSCredentials& credentials,
                               const Aws::Client::ClientConfiguration& clientConfiguration);
 
        CodeGuruProfilerClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                               const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~CodeGuruProfilerClient();
 
        virtual Model::AddNotificationChannelsOutcome AddNotificationChannels(const Model::AddNotificationChannelsRequest& request) const;
 
        template<typename AddNotificationChannelsRequestT = Model::AddNotificationChannelsRequest>
        Model::AddNotificationChannelsOutcomeCallable AddNotificationChannelsCallable(const AddNotificationChannelsRequestT& request) const
        {
            return SubmitCallable(&CodeGuruProfilerClient::AddNotificationChannels, request);
        }
 
        template<typename AddNotificationChannelsRequestT = Model::AddNotificationChannelsRequest>
        void AddNotificationChannelsAsync(const AddNotificationChannelsRequestT& request, const AddNotificationChannelsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeGuruProfilerClient::AddNotificationChannels, request, handler, context);
        }
 
        virtual Model::BatchGetFrameMetricDataOutcome BatchGetFrameMetricData(const Model::BatchGetFrameMetricDataRequest& request) const;
 
        template<typename BatchGetFrameMetricDataRequestT = Model::BatchGetFrameMetricDataRequest>
        Model::BatchGetFrameMetricDataOutcomeCallable BatchGetFrameMetricDataCallable(const BatchGetFrameMetricDataRequestT& request) const
        {
            return SubmitCallable(&CodeGuruProfilerClient::BatchGetFrameMetricData, request);
        }
 
        template<typename BatchGetFrameMetricDataRequestT = Model::BatchGetFrameMetricDataRequest>
        void BatchGetFrameMetricDataAsync(const BatchGetFrameMetricDataRequestT& request, const BatchGetFrameMetricDataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeGuruProfilerClient::BatchGetFrameMetricData, request, handler, context);
        }
 
        virtual Model::ConfigureAgentOutcome ConfigureAgent(const Model::ConfigureAgentRequest& request) const;
 
        template<typename ConfigureAgentRequestT = Model::ConfigureAgentRequest>
        Model::ConfigureAgentOutcomeCallable ConfigureAgentCallable(const ConfigureAgentRequestT& request) const
        {
            return SubmitCallable(&CodeGuruProfilerClient::ConfigureAgent, request);
        }
 
        template<typename ConfigureAgentRequestT = Model::ConfigureAgentRequest>
        void ConfigureAgentAsync(const ConfigureAgentRequestT& request, const ConfigureAgentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeGuruProfilerClient::ConfigureAgent, request, handler, context);
        }
 
        virtual Model::CreateProfilingGroupOutcome CreateProfilingGroup(const Model::CreateProfilingGroupRequest& request) const;
 
        template<typename CreateProfilingGroupRequestT = Model::CreateProfilingGroupRequest>
        Model::CreateProfilingGroupOutcomeCallable CreateProfilingGroupCallable(const CreateProfilingGroupRequestT& request) const
        {
            return SubmitCallable(&CodeGuruProfilerClient::CreateProfilingGroup, request);
        }
 
        template<typename CreateProfilingGroupRequestT = Model::CreateProfilingGroupRequest>
        void CreateProfilingGroupAsync(const CreateProfilingGroupRequestT& request, const CreateProfilingGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeGuruProfilerClient::CreateProfilingGroup, request, handler, context);
        }
 
        virtual Model::DeleteProfilingGroupOutcome DeleteProfilingGroup(const Model::DeleteProfilingGroupRequest& request) const;
 
        template<typename DeleteProfilingGroupRequestT = Model::DeleteProfilingGroupRequest>
        Model::DeleteProfilingGroupOutcomeCallable DeleteProfilingGroupCallable(const DeleteProfilingGroupRequestT& request) const
        {
            return SubmitCallable(&CodeGuruProfilerClient::DeleteProfilingGroup, request);
        }
 
        template<typename DeleteProfilingGroupRequestT = Model::DeleteProfilingGroupRequest>
        void DeleteProfilingGroupAsync(const DeleteProfilingGroupRequestT& request, const DeleteProfilingGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeGuruProfilerClient::DeleteProfilingGroup, request, handler, context);
        }
 
        virtual Model::DescribeProfilingGroupOutcome DescribeProfilingGroup(const Model::DescribeProfilingGroupRequest& request) const;
 
        template<typename DescribeProfilingGroupRequestT = Model::DescribeProfilingGroupRequest>
        Model::DescribeProfilingGroupOutcomeCallable DescribeProfilingGroupCallable(const DescribeProfilingGroupRequestT& request) const
        {
            return SubmitCallable(&CodeGuruProfilerClient::DescribeProfilingGroup, request);
        }
 
        template<typename DescribeProfilingGroupRequestT = Model::DescribeProfilingGroupRequest>
        void DescribeProfilingGroupAsync(const DescribeProfilingGroupRequestT& request, const DescribeProfilingGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeGuruProfilerClient::DescribeProfilingGroup, request, handler, context);
        }
 
        virtual Model::GetFindingsReportAccountSummaryOutcome GetFindingsReportAccountSummary(const Model::GetFindingsReportAccountSummaryRequest& request = {}) const;
 
        template<typename GetFindingsReportAccountSummaryRequestT = Model::GetFindingsReportAccountSummaryRequest>
        Model::GetFindingsReportAccountSummaryOutcomeCallable GetFindingsReportAccountSummaryCallable(const GetFindingsReportAccountSummaryRequestT& request = {}) const
        {
            return SubmitCallable(&CodeGuruProfilerClient::GetFindingsReportAccountSummary, request);
        }
 
        template<typename GetFindingsReportAccountSummaryRequestT = Model::GetFindingsReportAccountSummaryRequest>
        void GetFindingsReportAccountSummaryAsync(const GetFindingsReportAccountSummaryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetFindingsReportAccountSummaryRequestT& request = {}) const
        {
            return SubmitAsync(&CodeGuruProfilerClient::GetFindingsReportAccountSummary, request, handler, context);
        }
 
        virtual Model::GetNotificationConfigurationOutcome GetNotificationConfiguration(const Model::GetNotificationConfigurationRequest& request) const;
 
        template<typename GetNotificationConfigurationRequestT = Model::GetNotificationConfigurationRequest>
        Model::GetNotificationConfigurationOutcomeCallable GetNotificationConfigurationCallable(const GetNotificationConfigurationRequestT& request) const
        {
            return SubmitCallable(&CodeGuruProfilerClient::GetNotificationConfiguration, request);
        }
 
        template<typename GetNotificationConfigurationRequestT = Model::GetNotificationConfigurationRequest>
        void GetNotificationConfigurationAsync(const GetNotificationConfigurationRequestT& request, const GetNotificationConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeGuruProfilerClient::GetNotificationConfiguration, request, handler, context);
        }
 
        virtual Model::GetPolicyOutcome GetPolicy(const Model::GetPolicyRequest& request) const;
 
        template<typename GetPolicyRequestT = Model::GetPolicyRequest>
        Model::GetPolicyOutcomeCallable GetPolicyCallable(const GetPolicyRequestT& request) const
        {
            return SubmitCallable(&CodeGuruProfilerClient::GetPolicy, request);
        }
 
        template<typename GetPolicyRequestT = Model::GetPolicyRequest>
        void GetPolicyAsync(const GetPolicyRequestT& request, const GetPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeGuruProfilerClient::GetPolicy, request, handler, context);
        }
 
        virtual Model::GetProfileOutcome GetProfile(const Model::GetProfileRequest& request) const;
 
        template<typename GetProfileRequestT = Model::GetProfileRequest>
        Model::GetProfileOutcomeCallable GetProfileCallable(const GetProfileRequestT& request) const
        {
            return SubmitCallable(&CodeGuruProfilerClient::GetProfile, request);
        }
 
        template<typename GetProfileRequestT = Model::GetProfileRequest>
        void GetProfileAsync(const GetProfileRequestT& request, const GetProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeGuruProfilerClient::GetProfile, request, handler, context);
        }
 
        virtual Model::GetRecommendationsOutcome GetRecommendations(const Model::GetRecommendationsRequest& request) const;
 
        template<typename GetRecommendationsRequestT = Model::GetRecommendationsRequest>
        Model::GetRecommendationsOutcomeCallable GetRecommendationsCallable(const GetRecommendationsRequestT& request) const
        {
            return SubmitCallable(&CodeGuruProfilerClient::GetRecommendations, request);
        }
 
        template<typename GetRecommendationsRequestT = Model::GetRecommendationsRequest>
        void GetRecommendationsAsync(const GetRecommendationsRequestT& request, const GetRecommendationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeGuruProfilerClient::GetRecommendations, request, handler, context);
        }
 
        virtual Model::ListFindingsReportsOutcome ListFindingsReports(const Model::ListFindingsReportsRequest& request) const;
 
        template<typename ListFindingsReportsRequestT = Model::ListFindingsReportsRequest>
        Model::ListFindingsReportsOutcomeCallable ListFindingsReportsCallable(const ListFindingsReportsRequestT& request) const
        {
            return SubmitCallable(&CodeGuruProfilerClient::ListFindingsReports, request);
        }
 
        template<typename ListFindingsReportsRequestT = Model::ListFindingsReportsRequest>
        void ListFindingsReportsAsync(const ListFindingsReportsRequestT& request, const ListFindingsReportsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeGuruProfilerClient::ListFindingsReports, request, handler, context);
        }
 
        virtual Model::ListProfileTimesOutcome ListProfileTimes(const Model::ListProfileTimesRequest& request) const;
 
        template<typename ListProfileTimesRequestT = Model::ListProfileTimesRequest>
        Model::ListProfileTimesOutcomeCallable ListProfileTimesCallable(const ListProfileTimesRequestT& request) const
        {
            return SubmitCallable(&CodeGuruProfilerClient::ListProfileTimes, request);
        }
 
        template<typename ListProfileTimesRequestT = Model::ListProfileTimesRequest>
        void ListProfileTimesAsync(const ListProfileTimesRequestT& request, const ListProfileTimesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeGuruProfilerClient::ListProfileTimes, request, handler, context);
        }
 
        virtual Model::ListProfilingGroupsOutcome ListProfilingGroups(const Model::ListProfilingGroupsRequest& request = {}) const;
 
        template<typename ListProfilingGroupsRequestT = Model::ListProfilingGroupsRequest>
        Model::ListProfilingGroupsOutcomeCallable ListProfilingGroupsCallable(const ListProfilingGroupsRequestT& request = {}) const
        {
            return SubmitCallable(&CodeGuruProfilerClient::ListProfilingGroups, request);
        }
 
        template<typename ListProfilingGroupsRequestT = Model::ListProfilingGroupsRequest>
        void ListProfilingGroupsAsync(const ListProfilingGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListProfilingGroupsRequestT& request = {}) const
        {
            return SubmitAsync(&CodeGuruProfilerClient::ListProfilingGroups, 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(&CodeGuruProfilerClient::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(&CodeGuruProfilerClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::PostAgentProfileOutcome PostAgentProfile(const Model::PostAgentProfileRequest& request) const;
 
        template<typename PostAgentProfileRequestT = Model::PostAgentProfileRequest>
        Model::PostAgentProfileOutcomeCallable PostAgentProfileCallable(const PostAgentProfileRequestT& request) const
        {
            return SubmitCallable(&CodeGuruProfilerClient::PostAgentProfile, request);
        }
 
        template<typename PostAgentProfileRequestT = Model::PostAgentProfileRequest>
        void PostAgentProfileAsync(const PostAgentProfileRequestT& request, const PostAgentProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeGuruProfilerClient::PostAgentProfile, request, handler, context);
        }
 
        virtual Model::PutPermissionOutcome PutPermission(const Model::PutPermissionRequest& request) const;
 
        template<typename PutPermissionRequestT = Model::PutPermissionRequest>
        Model::PutPermissionOutcomeCallable PutPermissionCallable(const PutPermissionRequestT& request) const
        {
            return SubmitCallable(&CodeGuruProfilerClient::PutPermission, request);
        }
 
        template<typename PutPermissionRequestT = Model::PutPermissionRequest>
        void PutPermissionAsync(const PutPermissionRequestT& request, const PutPermissionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeGuruProfilerClient::PutPermission, request, handler, context);
        }
 
        virtual Model::RemoveNotificationChannelOutcome RemoveNotificationChannel(const Model::RemoveNotificationChannelRequest& request) const;
 
        template<typename RemoveNotificationChannelRequestT = Model::RemoveNotificationChannelRequest>
        Model::RemoveNotificationChannelOutcomeCallable RemoveNotificationChannelCallable(const RemoveNotificationChannelRequestT& request) const
        {
            return SubmitCallable(&CodeGuruProfilerClient::RemoveNotificationChannel, request);
        }
 
        template<typename RemoveNotificationChannelRequestT = Model::RemoveNotificationChannelRequest>
        void RemoveNotificationChannelAsync(const RemoveNotificationChannelRequestT& request, const RemoveNotificationChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeGuruProfilerClient::RemoveNotificationChannel, request, handler, context);
        }
 
        virtual Model::RemovePermissionOutcome RemovePermission(const Model::RemovePermissionRequest& request) const;
 
        template<typename RemovePermissionRequestT = Model::RemovePermissionRequest>
        Model::RemovePermissionOutcomeCallable RemovePermissionCallable(const RemovePermissionRequestT& request) const
        {
            return SubmitCallable(&CodeGuruProfilerClient::RemovePermission, request);
        }
 
        template<typename RemovePermissionRequestT = Model::RemovePermissionRequest>
        void RemovePermissionAsync(const RemovePermissionRequestT& request, const RemovePermissionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeGuruProfilerClient::RemovePermission, request, handler, context);
        }
 
        virtual Model::SubmitFeedbackOutcome SubmitFeedback(const Model::SubmitFeedbackRequest& request) const;
 
        template<typename SubmitFeedbackRequestT = Model::SubmitFeedbackRequest>
        Model::SubmitFeedbackOutcomeCallable SubmitFeedbackCallable(const SubmitFeedbackRequestT& request) const
        {
            return SubmitCallable(&CodeGuruProfilerClient::SubmitFeedback, request);
        }
 
        template<typename SubmitFeedbackRequestT = Model::SubmitFeedbackRequest>
        void SubmitFeedbackAsync(const SubmitFeedbackRequestT& request, const SubmitFeedbackResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeGuruProfilerClient::SubmitFeedback, 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(&CodeGuruProfilerClient::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(&CodeGuruProfilerClient::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(&CodeGuruProfilerClient::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(&CodeGuruProfilerClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateProfilingGroupOutcome UpdateProfilingGroup(const Model::UpdateProfilingGroupRequest& request) const;
 
        template<typename UpdateProfilingGroupRequestT = Model::UpdateProfilingGroupRequest>
        Model::UpdateProfilingGroupOutcomeCallable UpdateProfilingGroupCallable(const UpdateProfilingGroupRequestT& request) const
        {
            return SubmitCallable(&CodeGuruProfilerClient::UpdateProfilingGroup, request);
        }
 
        template<typename UpdateProfilingGroupRequestT = Model::UpdateProfilingGroupRequest>
        void UpdateProfilingGroupAsync(const UpdateProfilingGroupRequestT& request, const UpdateProfilingGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeGuruProfilerClient::UpdateProfilingGroup, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<CodeGuruProfilerEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<CodeGuruProfilerClient>;
      void init(const CodeGuruProfilerClientConfiguration& clientConfiguration);
 
      CodeGuruProfilerClientConfiguration m_clientConfiguration;
      std::shared_ptr<CodeGuruProfilerEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace CodeGuruProfiler
} // namespace Aws