IoTDataPlaneClient.h

 
#pragma once
#include <aws/iot-data/IoTDataPlane_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/iot-data/IoTDataPlaneServiceClientModel.h>
 
namespace Aws
{
namespace IoTDataPlane
{
  class AWS_IOTDATAPLANE_API IoTDataPlaneClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      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