SchedulerClient.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/scheduler/SchedulerPaginationBase.h>
#include <aws/scheduler/SchedulerServiceClientModel.h>
#include <aws/scheduler/SchedulerWaiter.h>
#include <aws/scheduler/Scheduler_EXPORTS.h>
 
namespace Aws {
namespace Scheduler {
class AWS_SCHEDULER_API SchedulerClient : public Aws::Client::AWSJsonClient,
                                          public Aws::Client::ClientWithAsyncTemplateMethods<SchedulerClient>,
                                          public SchedulerPaginationBase<SchedulerClient>,
                                          public SchedulerWaiter<SchedulerClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef SchedulerClientConfiguration ClientConfigurationType;
  typedef SchedulerEndpointProvider EndpointProviderType;
 
  SchedulerClient(const Aws::Scheduler::SchedulerClientConfiguration& clientConfiguration = Aws::Scheduler::SchedulerClientConfiguration(),
                  std::shared_ptr<SchedulerEndpointProviderBase> endpointProvider = nullptr);
 
  SchedulerClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<SchedulerEndpointProviderBase> endpointProvider = nullptr,
                  const Aws::Scheduler::SchedulerClientConfiguration& clientConfiguration = Aws::Scheduler::SchedulerClientConfiguration());
 
  SchedulerClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                  std::shared_ptr<SchedulerEndpointProviderBase> endpointProvider = nullptr,
                  const Aws::Scheduler::SchedulerClientConfiguration& clientConfiguration = Aws::Scheduler::SchedulerClientConfiguration());
 
  /* Legacy constructors due deprecation */
  SchedulerClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  SchedulerClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  SchedulerClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                  const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~SchedulerClient();
 
  virtual Model::CreateScheduleOutcome CreateSchedule(const Model::CreateScheduleRequest& request) const;
 
  template <typename CreateScheduleRequestT = Model::CreateScheduleRequest>
  Model::CreateScheduleOutcomeCallable CreateScheduleCallable(const CreateScheduleRequestT& request) const {
    return SubmitCallable(&SchedulerClient::CreateSchedule, request);
  }
 
  template <typename CreateScheduleRequestT = Model::CreateScheduleRequest>
  void CreateScheduleAsync(const CreateScheduleRequestT& request, const CreateScheduleResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SchedulerClient::CreateSchedule, request, handler, context);
  }
 
  virtual Model::CreateScheduleGroupOutcome CreateScheduleGroup(const Model::CreateScheduleGroupRequest& request) const;
 
  template <typename CreateScheduleGroupRequestT = Model::CreateScheduleGroupRequest>
  Model::CreateScheduleGroupOutcomeCallable CreateScheduleGroupCallable(const CreateScheduleGroupRequestT& request) const {
    return SubmitCallable(&SchedulerClient::CreateScheduleGroup, request);
  }
 
  template <typename CreateScheduleGroupRequestT = Model::CreateScheduleGroupRequest>
  void CreateScheduleGroupAsync(const CreateScheduleGroupRequestT& request, const CreateScheduleGroupResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SchedulerClient::CreateScheduleGroup, request, handler, context);
  }
 
  virtual Model::DeleteScheduleOutcome DeleteSchedule(const Model::DeleteScheduleRequest& request) const;
 
  template <typename DeleteScheduleRequestT = Model::DeleteScheduleRequest>
  Model::DeleteScheduleOutcomeCallable DeleteScheduleCallable(const DeleteScheduleRequestT& request) const {
    return SubmitCallable(&SchedulerClient::DeleteSchedule, request);
  }
 
  template <typename DeleteScheduleRequestT = Model::DeleteScheduleRequest>
  void DeleteScheduleAsync(const DeleteScheduleRequestT& request, const DeleteScheduleResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SchedulerClient::DeleteSchedule, request, handler, context);
  }
 
  virtual Model::DeleteScheduleGroupOutcome DeleteScheduleGroup(const Model::DeleteScheduleGroupRequest& request) const;
 
  template <typename DeleteScheduleGroupRequestT = Model::DeleteScheduleGroupRequest>
  Model::DeleteScheduleGroupOutcomeCallable DeleteScheduleGroupCallable(const DeleteScheduleGroupRequestT& request) const {
    return SubmitCallable(&SchedulerClient::DeleteScheduleGroup, request);
  }
 
  template <typename DeleteScheduleGroupRequestT = Model::DeleteScheduleGroupRequest>
  void DeleteScheduleGroupAsync(const DeleteScheduleGroupRequestT& request, const DeleteScheduleGroupResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SchedulerClient::DeleteScheduleGroup, request, handler, context);
  }
 
  virtual Model::GetScheduleOutcome GetSchedule(const Model::GetScheduleRequest& request) const;
 
  template <typename GetScheduleRequestT = Model::GetScheduleRequest>
  Model::GetScheduleOutcomeCallable GetScheduleCallable(const GetScheduleRequestT& request) const {
    return SubmitCallable(&SchedulerClient::GetSchedule, request);
  }
 
  template <typename GetScheduleRequestT = Model::GetScheduleRequest>
  void GetScheduleAsync(const GetScheduleRequestT& request, const GetScheduleResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SchedulerClient::GetSchedule, request, handler, context);
  }
 
  virtual Model::GetScheduleGroupOutcome GetScheduleGroup(const Model::GetScheduleGroupRequest& request) const;
 
  template <typename GetScheduleGroupRequestT = Model::GetScheduleGroupRequest>
  Model::GetScheduleGroupOutcomeCallable GetScheduleGroupCallable(const GetScheduleGroupRequestT& request) const {
    return SubmitCallable(&SchedulerClient::GetScheduleGroup, request);
  }
 
  template <typename GetScheduleGroupRequestT = Model::GetScheduleGroupRequest>
  void GetScheduleGroupAsync(const GetScheduleGroupRequestT& request, const GetScheduleGroupResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SchedulerClient::GetScheduleGroup, request, handler, context);
  }
 
  virtual Model::ListScheduleGroupsOutcome ListScheduleGroups(const Model::ListScheduleGroupsRequest& request = {}) const;
 
  template <typename ListScheduleGroupsRequestT = Model::ListScheduleGroupsRequest>
  Model::ListScheduleGroupsOutcomeCallable ListScheduleGroupsCallable(const ListScheduleGroupsRequestT& request = {}) const {
    return SubmitCallable(&SchedulerClient::ListScheduleGroups, request);
  }
 
  template <typename ListScheduleGroupsRequestT = Model::ListScheduleGroupsRequest>
  void ListScheduleGroupsAsync(const ListScheduleGroupsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const ListScheduleGroupsRequestT& request = {}) const {
    return SubmitAsync(&SchedulerClient::ListScheduleGroups, request, handler, context);
  }
 
  virtual Model::ListSchedulesOutcome ListSchedules(const Model::ListSchedulesRequest& request = {}) const;
 
  template <typename ListSchedulesRequestT = Model::ListSchedulesRequest>
  Model::ListSchedulesOutcomeCallable ListSchedulesCallable(const ListSchedulesRequestT& request = {}) const {
    return SubmitCallable(&SchedulerClient::ListSchedules, request);
  }
 
  template <typename ListSchedulesRequestT = Model::ListSchedulesRequest>
  void ListSchedulesAsync(const ListSchedulesResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                          const ListSchedulesRequestT& request = {}) const {
    return SubmitAsync(&SchedulerClient::ListSchedules, 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(&SchedulerClient::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(&SchedulerClient::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(&SchedulerClient::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(&SchedulerClient::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(&SchedulerClient::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(&SchedulerClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateScheduleOutcome UpdateSchedule(const Model::UpdateScheduleRequest& request) const;
 
  template <typename UpdateScheduleRequestT = Model::UpdateScheduleRequest>
  Model::UpdateScheduleOutcomeCallable UpdateScheduleCallable(const UpdateScheduleRequestT& request) const {
    return SubmitCallable(&SchedulerClient::UpdateSchedule, request);
  }
 
  template <typename UpdateScheduleRequestT = Model::UpdateScheduleRequest>
  void UpdateScheduleAsync(const UpdateScheduleRequestT& request, const UpdateScheduleResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SchedulerClient::UpdateSchedule, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<SchedulerEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<SchedulerClient>;
  void init(const SchedulerClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, SchedulerError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  SchedulerClientConfiguration m_clientConfiguration;
  std::shared_ptr<SchedulerEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace Scheduler
}  // namespace Aws