KinesisAnalyticsClient.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/kinesisanalytics/KinesisAnalyticsPaginationBase.h>
#include <aws/kinesisanalytics/KinesisAnalyticsServiceClientModel.h>
#include <aws/kinesisanalytics/KinesisAnalytics_EXPORTS.h>
 
namespace Aws {
namespace KinesisAnalytics {
class AWS_KINESISANALYTICS_API KinesisAnalyticsClient : public Aws::Client::AWSJsonClient,
                                                        public Aws::Client::ClientWithAsyncTemplateMethods<KinesisAnalyticsClient>,
                                                        public KinesisAnalyticsPaginationBase<KinesisAnalyticsClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef KinesisAnalyticsClientConfiguration ClientConfigurationType;
  typedef KinesisAnalyticsEndpointProvider EndpointProviderType;
 
  KinesisAnalyticsClient(const Aws::KinesisAnalytics::KinesisAnalyticsClientConfiguration& clientConfiguration =
                             Aws::KinesisAnalytics::KinesisAnalyticsClientConfiguration(),
                         std::shared_ptr<KinesisAnalyticsEndpointProviderBase> endpointProvider = nullptr);
 
  KinesisAnalyticsClient(const Aws::Auth::AWSCredentials& credentials,
                         std::shared_ptr<KinesisAnalyticsEndpointProviderBase> endpointProvider = nullptr,
                         const Aws::KinesisAnalytics::KinesisAnalyticsClientConfiguration& clientConfiguration =
                             Aws::KinesisAnalytics::KinesisAnalyticsClientConfiguration());
 
  KinesisAnalyticsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                         std::shared_ptr<KinesisAnalyticsEndpointProviderBase> endpointProvider = nullptr,
                         const Aws::KinesisAnalytics::KinesisAnalyticsClientConfiguration& clientConfiguration =
                             Aws::KinesisAnalytics::KinesisAnalyticsClientConfiguration());
 
  /* Legacy constructors due deprecation */
  KinesisAnalyticsClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  KinesisAnalyticsClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  KinesisAnalyticsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                         const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~KinesisAnalyticsClient();
 
  virtual Model::AddApplicationCloudWatchLoggingOptionOutcome AddApplicationCloudWatchLoggingOption(
      const Model::AddApplicationCloudWatchLoggingOptionRequest& request) const;
 
  template <typename AddApplicationCloudWatchLoggingOptionRequestT = Model::AddApplicationCloudWatchLoggingOptionRequest>
  Model::AddApplicationCloudWatchLoggingOptionOutcomeCallable AddApplicationCloudWatchLoggingOptionCallable(
      const AddApplicationCloudWatchLoggingOptionRequestT& request) const {
    return SubmitCallable(&KinesisAnalyticsClient::AddApplicationCloudWatchLoggingOption, request);
  }
 
  template <typename AddApplicationCloudWatchLoggingOptionRequestT = Model::AddApplicationCloudWatchLoggingOptionRequest>
  void AddApplicationCloudWatchLoggingOptionAsync(const AddApplicationCloudWatchLoggingOptionRequestT& request,
                                                  const AddApplicationCloudWatchLoggingOptionResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisAnalyticsClient::AddApplicationCloudWatchLoggingOption, request, handler, context);
  }
 
  virtual Model::AddApplicationInputOutcome AddApplicationInput(const Model::AddApplicationInputRequest& request) const;
 
  template <typename AddApplicationInputRequestT = Model::AddApplicationInputRequest>
  Model::AddApplicationInputOutcomeCallable AddApplicationInputCallable(const AddApplicationInputRequestT& request) const {
    return SubmitCallable(&KinesisAnalyticsClient::AddApplicationInput, request);
  }
 
  template <typename AddApplicationInputRequestT = Model::AddApplicationInputRequest>
  void AddApplicationInputAsync(const AddApplicationInputRequestT& request, const AddApplicationInputResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisAnalyticsClient::AddApplicationInput, request, handler, context);
  }
 
  virtual Model::AddApplicationInputProcessingConfigurationOutcome AddApplicationInputProcessingConfiguration(
      const Model::AddApplicationInputProcessingConfigurationRequest& request) const;
 
  template <typename AddApplicationInputProcessingConfigurationRequestT = Model::AddApplicationInputProcessingConfigurationRequest>
  Model::AddApplicationInputProcessingConfigurationOutcomeCallable AddApplicationInputProcessingConfigurationCallable(
      const AddApplicationInputProcessingConfigurationRequestT& request) const {
    return SubmitCallable(&KinesisAnalyticsClient::AddApplicationInputProcessingConfiguration, request);
  }
 
  template <typename AddApplicationInputProcessingConfigurationRequestT = Model::AddApplicationInputProcessingConfigurationRequest>
  void AddApplicationInputProcessingConfigurationAsync(
      const AddApplicationInputProcessingConfigurationRequestT& request,
      const AddApplicationInputProcessingConfigurationResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisAnalyticsClient::AddApplicationInputProcessingConfiguration, request, handler, context);
  }
 
  virtual Model::AddApplicationOutputOutcome AddApplicationOutput(const Model::AddApplicationOutputRequest& request) const;
 
  template <typename AddApplicationOutputRequestT = Model::AddApplicationOutputRequest>
  Model::AddApplicationOutputOutcomeCallable AddApplicationOutputCallable(const AddApplicationOutputRequestT& request) const {
    return SubmitCallable(&KinesisAnalyticsClient::AddApplicationOutput, request);
  }
 
  template <typename AddApplicationOutputRequestT = Model::AddApplicationOutputRequest>
  void AddApplicationOutputAsync(const AddApplicationOutputRequestT& request, const AddApplicationOutputResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisAnalyticsClient::AddApplicationOutput, request, handler, context);
  }
 
  virtual Model::AddApplicationReferenceDataSourceOutcome AddApplicationReferenceDataSource(
      const Model::AddApplicationReferenceDataSourceRequest& request) const;
 
  template <typename AddApplicationReferenceDataSourceRequestT = Model::AddApplicationReferenceDataSourceRequest>
  Model::AddApplicationReferenceDataSourceOutcomeCallable AddApplicationReferenceDataSourceCallable(
      const AddApplicationReferenceDataSourceRequestT& request) const {
    return SubmitCallable(&KinesisAnalyticsClient::AddApplicationReferenceDataSource, request);
  }
 
  template <typename AddApplicationReferenceDataSourceRequestT = Model::AddApplicationReferenceDataSourceRequest>
  void AddApplicationReferenceDataSourceAsync(const AddApplicationReferenceDataSourceRequestT& request,
                                              const AddApplicationReferenceDataSourceResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisAnalyticsClient::AddApplicationReferenceDataSource, request, handler, context);
  }
 
  virtual Model::CreateApplicationOutcome CreateApplication(const Model::CreateApplicationRequest& request) const;
 
  template <typename CreateApplicationRequestT = Model::CreateApplicationRequest>
  Model::CreateApplicationOutcomeCallable CreateApplicationCallable(const CreateApplicationRequestT& request) const {
    return SubmitCallable(&KinesisAnalyticsClient::CreateApplication, request);
  }
 
  template <typename CreateApplicationRequestT = Model::CreateApplicationRequest>
  void CreateApplicationAsync(const CreateApplicationRequestT& request, const CreateApplicationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisAnalyticsClient::CreateApplication, request, handler, context);
  }
 
  virtual Model::DeleteApplicationOutcome DeleteApplication(const Model::DeleteApplicationRequest& request) const;
 
  template <typename DeleteApplicationRequestT = Model::DeleteApplicationRequest>
  Model::DeleteApplicationOutcomeCallable DeleteApplicationCallable(const DeleteApplicationRequestT& request) const {
    return SubmitCallable(&KinesisAnalyticsClient::DeleteApplication, request);
  }
 
  template <typename DeleteApplicationRequestT = Model::DeleteApplicationRequest>
  void DeleteApplicationAsync(const DeleteApplicationRequestT& request, const DeleteApplicationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisAnalyticsClient::DeleteApplication, request, handler, context);
  }
 
  virtual Model::DeleteApplicationCloudWatchLoggingOptionOutcome DeleteApplicationCloudWatchLoggingOption(
      const Model::DeleteApplicationCloudWatchLoggingOptionRequest& request) const;
 
  template <typename DeleteApplicationCloudWatchLoggingOptionRequestT = Model::DeleteApplicationCloudWatchLoggingOptionRequest>
  Model::DeleteApplicationCloudWatchLoggingOptionOutcomeCallable DeleteApplicationCloudWatchLoggingOptionCallable(
      const DeleteApplicationCloudWatchLoggingOptionRequestT& request) const {
    return SubmitCallable(&KinesisAnalyticsClient::DeleteApplicationCloudWatchLoggingOption, request);
  }
 
  template <typename DeleteApplicationCloudWatchLoggingOptionRequestT = Model::DeleteApplicationCloudWatchLoggingOptionRequest>
  void DeleteApplicationCloudWatchLoggingOptionAsync(
      const DeleteApplicationCloudWatchLoggingOptionRequestT& request,
      const DeleteApplicationCloudWatchLoggingOptionResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisAnalyticsClient::DeleteApplicationCloudWatchLoggingOption, request, handler, context);
  }
 
  virtual Model::DeleteApplicationInputProcessingConfigurationOutcome DeleteApplicationInputProcessingConfiguration(
      const Model::DeleteApplicationInputProcessingConfigurationRequest& request) const;
 
  template <typename DeleteApplicationInputProcessingConfigurationRequestT = Model::DeleteApplicationInputProcessingConfigurationRequest>
  Model::DeleteApplicationInputProcessingConfigurationOutcomeCallable DeleteApplicationInputProcessingConfigurationCallable(
      const DeleteApplicationInputProcessingConfigurationRequestT& request) const {
    return SubmitCallable(&KinesisAnalyticsClient::DeleteApplicationInputProcessingConfiguration, request);
  }
 
  template <typename DeleteApplicationInputProcessingConfigurationRequestT = Model::DeleteApplicationInputProcessingConfigurationRequest>
  void DeleteApplicationInputProcessingConfigurationAsync(
      const DeleteApplicationInputProcessingConfigurationRequestT& request,
      const DeleteApplicationInputProcessingConfigurationResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisAnalyticsClient::DeleteApplicationInputProcessingConfiguration, request, handler, context);
  }
 
  virtual Model::DeleteApplicationOutputOutcome DeleteApplicationOutput(const Model::DeleteApplicationOutputRequest& request) const;
 
  template <typename DeleteApplicationOutputRequestT = Model::DeleteApplicationOutputRequest>
  Model::DeleteApplicationOutputOutcomeCallable DeleteApplicationOutputCallable(const DeleteApplicationOutputRequestT& request) const {
    return SubmitCallable(&KinesisAnalyticsClient::DeleteApplicationOutput, request);
  }
 
  template <typename DeleteApplicationOutputRequestT = Model::DeleteApplicationOutputRequest>
  void DeleteApplicationOutputAsync(const DeleteApplicationOutputRequestT& request,
                                    const DeleteApplicationOutputResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisAnalyticsClient::DeleteApplicationOutput, request, handler, context);
  }
 
  virtual Model::DeleteApplicationReferenceDataSourceOutcome DeleteApplicationReferenceDataSource(
      const Model::DeleteApplicationReferenceDataSourceRequest& request) const;
 
  template <typename DeleteApplicationReferenceDataSourceRequestT = Model::DeleteApplicationReferenceDataSourceRequest>
  Model::DeleteApplicationReferenceDataSourceOutcomeCallable DeleteApplicationReferenceDataSourceCallable(
      const DeleteApplicationReferenceDataSourceRequestT& request) const {
    return SubmitCallable(&KinesisAnalyticsClient::DeleteApplicationReferenceDataSource, request);
  }
 
  template <typename DeleteApplicationReferenceDataSourceRequestT = Model::DeleteApplicationReferenceDataSourceRequest>
  void DeleteApplicationReferenceDataSourceAsync(const DeleteApplicationReferenceDataSourceRequestT& request,
                                                 const DeleteApplicationReferenceDataSourceResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisAnalyticsClient::DeleteApplicationReferenceDataSource, request, handler, context);
  }
 
  virtual Model::DescribeApplicationOutcome DescribeApplication(const Model::DescribeApplicationRequest& request) const;
 
  template <typename DescribeApplicationRequestT = Model::DescribeApplicationRequest>
  Model::DescribeApplicationOutcomeCallable DescribeApplicationCallable(const DescribeApplicationRequestT& request) const {
    return SubmitCallable(&KinesisAnalyticsClient::DescribeApplication, request);
  }
 
  template <typename DescribeApplicationRequestT = Model::DescribeApplicationRequest>
  void DescribeApplicationAsync(const DescribeApplicationRequestT& request, const DescribeApplicationResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisAnalyticsClient::DescribeApplication, request, handler, context);
  }
 
  virtual Model::DiscoverInputSchemaOutcome DiscoverInputSchema(const Model::DiscoverInputSchemaRequest& request = {}) const;
 
  template <typename DiscoverInputSchemaRequestT = Model::DiscoverInputSchemaRequest>
  Model::DiscoverInputSchemaOutcomeCallable DiscoverInputSchemaCallable(const DiscoverInputSchemaRequestT& request = {}) const {
    return SubmitCallable(&KinesisAnalyticsClient::DiscoverInputSchema, request);
  }
 
  template <typename DiscoverInputSchemaRequestT = Model::DiscoverInputSchemaRequest>
  void DiscoverInputSchemaAsync(const DiscoverInputSchemaResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const DiscoverInputSchemaRequestT& request = {}) const {
    return SubmitAsync(&KinesisAnalyticsClient::DiscoverInputSchema, request, handler, context);
  }
 
  virtual Model::ListApplicationsOutcome ListApplications(const Model::ListApplicationsRequest& request = {}) const;
 
  template <typename ListApplicationsRequestT = Model::ListApplicationsRequest>
  Model::ListApplicationsOutcomeCallable ListApplicationsCallable(const ListApplicationsRequestT& request = {}) const {
    return SubmitCallable(&KinesisAnalyticsClient::ListApplications, request);
  }
 
  template <typename ListApplicationsRequestT = Model::ListApplicationsRequest>
  void ListApplicationsAsync(const ListApplicationsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListApplicationsRequestT& request = {}) const {
    return SubmitAsync(&KinesisAnalyticsClient::ListApplications, 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(&KinesisAnalyticsClient::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(&KinesisAnalyticsClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::StartApplicationOutcome StartApplication(const Model::StartApplicationRequest& request) const;
 
  template <typename StartApplicationRequestT = Model::StartApplicationRequest>
  Model::StartApplicationOutcomeCallable StartApplicationCallable(const StartApplicationRequestT& request) const {
    return SubmitCallable(&KinesisAnalyticsClient::StartApplication, request);
  }
 
  template <typename StartApplicationRequestT = Model::StartApplicationRequest>
  void StartApplicationAsync(const StartApplicationRequestT& request, const StartApplicationResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisAnalyticsClient::StartApplication, request, handler, context);
  }
 
  virtual Model::StopApplicationOutcome StopApplication(const Model::StopApplicationRequest& request) const;
 
  template <typename StopApplicationRequestT = Model::StopApplicationRequest>
  Model::StopApplicationOutcomeCallable StopApplicationCallable(const StopApplicationRequestT& request) const {
    return SubmitCallable(&KinesisAnalyticsClient::StopApplication, request);
  }
 
  template <typename StopApplicationRequestT = Model::StopApplicationRequest>
  void StopApplicationAsync(const StopApplicationRequestT& request, const StopApplicationResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisAnalyticsClient::StopApplication, 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(&KinesisAnalyticsClient::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(&KinesisAnalyticsClient::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(&KinesisAnalyticsClient::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(&KinesisAnalyticsClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateApplicationOutcome UpdateApplication(const Model::UpdateApplicationRequest& request) const;
 
  template <typename UpdateApplicationRequestT = Model::UpdateApplicationRequest>
  Model::UpdateApplicationOutcomeCallable UpdateApplicationCallable(const UpdateApplicationRequestT& request) const {
    return SubmitCallable(&KinesisAnalyticsClient::UpdateApplication, request);
  }
 
  template <typename UpdateApplicationRequestT = Model::UpdateApplicationRequest>
  void UpdateApplicationAsync(const UpdateApplicationRequestT& request, const UpdateApplicationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisAnalyticsClient::UpdateApplication, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<KinesisAnalyticsEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<KinesisAnalyticsClient>;
  void init(const KinesisAnalyticsClientConfiguration& clientConfiguration);
 
  KinesisAnalyticsClientConfiguration m_clientConfiguration;
  std::shared_ptr<KinesisAnalyticsEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace KinesisAnalytics
}  // namespace Aws