IoTDataPlaneClient.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/iot-data/IoTDataPlanePaginationBase.h>
#include <aws/iot-data/IoTDataPlaneServiceClientModel.h>
#include <aws/iot-data/IoTDataPlane_EXPORTS.h>
 
namespace Aws {
namespace IoTDataPlane {
class AWS_IOTDATAPLANE_API IoTDataPlaneClient : public Aws::Client::AWSJsonClient,
                                                public Aws::Client::ClientWithAsyncTemplateMethods<IoTDataPlaneClient>,
                                                public IoTDataPlanePaginationBase<IoTDataPlaneClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef IoTDataPlaneClientConfiguration ClientConfigurationType;
  typedef IoTDataPlaneEndpointProvider EndpointProviderType;
 
  IoTDataPlaneClient(
      const Aws::IoTDataPlane::IoTDataPlaneClientConfiguration& clientConfiguration = Aws::IoTDataPlane::IoTDataPlaneClientConfiguration(),
      std::shared_ptr<IoTDataPlaneEndpointProviderBase> endpointProvider = nullptr);
 
  IoTDataPlaneClient(
      const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<IoTDataPlaneEndpointProviderBase> endpointProvider = nullptr,
      const Aws::IoTDataPlane::IoTDataPlaneClientConfiguration& clientConfiguration = Aws::IoTDataPlane::IoTDataPlaneClientConfiguration());
 
  IoTDataPlaneClient(
      const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
      std::shared_ptr<IoTDataPlaneEndpointProviderBase> endpointProvider = nullptr,
      const Aws::IoTDataPlane::IoTDataPlaneClientConfiguration& clientConfiguration = Aws::IoTDataPlane::IoTDataPlaneClientConfiguration());
 
  /* Legacy constructors due deprecation */
  IoTDataPlaneClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  IoTDataPlaneClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  IoTDataPlaneClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                     const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~IoTDataPlaneClient();
 
  virtual Model::DeleteConnectionOutcome DeleteConnection(const Model::DeleteConnectionRequest& request) const;
 
  template <typename DeleteConnectionRequestT = Model::DeleteConnectionRequest>
  Model::DeleteConnectionOutcomeCallable DeleteConnectionCallable(const DeleteConnectionRequestT& request) const {
    return SubmitCallable(&IoTDataPlaneClient::DeleteConnection, request);
  }
 
  template <typename DeleteConnectionRequestT = Model::DeleteConnectionRequest>
  void DeleteConnectionAsync(const DeleteConnectionRequestT& request, const DeleteConnectionResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTDataPlaneClient::DeleteConnection, request, handler, context);
  }
 
  virtual Model::DeleteThingShadowOutcome DeleteThingShadow(const Model::DeleteThingShadowRequest& request) const;
 
  template <typename DeleteThingShadowRequestT = Model::DeleteThingShadowRequest>
  Model::DeleteThingShadowOutcomeCallable DeleteThingShadowCallable(const DeleteThingShadowRequestT& request) const {
    return SubmitCallable(&IoTDataPlaneClient::DeleteThingShadow, request);
  }
 
  template <typename DeleteThingShadowRequestT = Model::DeleteThingShadowRequest>
  void DeleteThingShadowAsync(const DeleteThingShadowRequestT& request, const DeleteThingShadowResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTDataPlaneClient::DeleteThingShadow, request, handler, context);
  }
 
  virtual Model::GetRetainedMessageOutcome GetRetainedMessage(const Model::GetRetainedMessageRequest& request) const;
 
  template <typename GetRetainedMessageRequestT = Model::GetRetainedMessageRequest>
  Model::GetRetainedMessageOutcomeCallable GetRetainedMessageCallable(const GetRetainedMessageRequestT& request) const {
    return SubmitCallable(&IoTDataPlaneClient::GetRetainedMessage, request);
  }
 
  template <typename GetRetainedMessageRequestT = Model::GetRetainedMessageRequest>
  void GetRetainedMessageAsync(const GetRetainedMessageRequestT& request, const GetRetainedMessageResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTDataPlaneClient::GetRetainedMessage, request, handler, context);
  }
 
  virtual Model::GetThingShadowOutcome GetThingShadow(const Model::GetThingShadowRequest& request) const;
 
  template <typename GetThingShadowRequestT = Model::GetThingShadowRequest>
  Model::GetThingShadowOutcomeCallable GetThingShadowCallable(const GetThingShadowRequestT& request) const {
    return SubmitCallable(&IoTDataPlaneClient::GetThingShadow, request);
  }
 
  template <typename GetThingShadowRequestT = Model::GetThingShadowRequest>
  void GetThingShadowAsync(const GetThingShadowRequestT& request, const GetThingShadowResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTDataPlaneClient::GetThingShadow, request, handler, context);
  }
 
  virtual Model::ListNamedShadowsForThingOutcome ListNamedShadowsForThing(const Model::ListNamedShadowsForThingRequest& request) const;
 
  template <typename ListNamedShadowsForThingRequestT = Model::ListNamedShadowsForThingRequest>
  Model::ListNamedShadowsForThingOutcomeCallable ListNamedShadowsForThingCallable(const ListNamedShadowsForThingRequestT& request) const {
    return SubmitCallable(&IoTDataPlaneClient::ListNamedShadowsForThing, request);
  }
 
  template <typename ListNamedShadowsForThingRequestT = Model::ListNamedShadowsForThingRequest>
  void ListNamedShadowsForThingAsync(const ListNamedShadowsForThingRequestT& request,
                                     const ListNamedShadowsForThingResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTDataPlaneClient::ListNamedShadowsForThing, request, handler, context);
  }
 
  virtual Model::ListRetainedMessagesOutcome ListRetainedMessages(const Model::ListRetainedMessagesRequest& request = {}) const;
 
  template <typename ListRetainedMessagesRequestT = Model::ListRetainedMessagesRequest>
  Model::ListRetainedMessagesOutcomeCallable ListRetainedMessagesCallable(const ListRetainedMessagesRequestT& request = {}) const {
    return SubmitCallable(&IoTDataPlaneClient::ListRetainedMessages, request);
  }
 
  template <typename ListRetainedMessagesRequestT = Model::ListRetainedMessagesRequest>
  void ListRetainedMessagesAsync(const ListRetainedMessagesResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const ListRetainedMessagesRequestT& request = {}) const {
    return SubmitAsync(&IoTDataPlaneClient::ListRetainedMessages, request, handler, context);
  }
 
  virtual Model::PublishOutcome Publish(const Model::PublishRequest& request) const;
 
  template <typename PublishRequestT = Model::PublishRequest>
  Model::PublishOutcomeCallable PublishCallable(const PublishRequestT& request) const {
    return SubmitCallable(&IoTDataPlaneClient::Publish, request);
  }
 
  template <typename PublishRequestT = Model::PublishRequest>
  void PublishAsync(const PublishRequestT& request, const PublishResponseReceivedHandler& handler,
                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTDataPlaneClient::Publish, request, handler, context);
  }
 
  virtual Model::UpdateThingShadowOutcome UpdateThingShadow(const Model::UpdateThingShadowRequest& request) const;
 
  template <typename UpdateThingShadowRequestT = Model::UpdateThingShadowRequest>
  Model::UpdateThingShadowOutcomeCallable UpdateThingShadowCallable(const UpdateThingShadowRequestT& request) const {
    return SubmitCallable(&IoTDataPlaneClient::UpdateThingShadow, request);
  }
 
  template <typename UpdateThingShadowRequestT = Model::UpdateThingShadowRequest>
  void UpdateThingShadowAsync(const UpdateThingShadowRequestT& request, const UpdateThingShadowResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTDataPlaneClient::UpdateThingShadow, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<IoTDataPlaneEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<IoTDataPlaneClient>;
  void init(const IoTDataPlaneClientConfiguration& clientConfiguration);
 
  IoTDataPlaneClientConfiguration m_clientConfiguration;
  std::shared_ptr<IoTDataPlaneEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace IoTDataPlane
}  // namespace Aws