SimSpaceWeaverClient.h

 
#pragma once
#include <aws/simspaceweaver/SimSpaceWeaver_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/simspaceweaver/SimSpaceWeaverServiceClientModel.h>
 
namespace Aws
{
namespace SimSpaceWeaver
{
  class AWS_SIMSPACEWEAVER_API SimSpaceWeaverClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<SimSpaceWeaverClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef SimSpaceWeaverClientConfiguration ClientConfigurationType;
      typedef SimSpaceWeaverEndpointProvider EndpointProviderType;
 
        SimSpaceWeaverClient(const Aws::SimSpaceWeaver::SimSpaceWeaverClientConfiguration& clientConfiguration = Aws::SimSpaceWeaver::SimSpaceWeaverClientConfiguration(),
                             std::shared_ptr<SimSpaceWeaverEndpointProviderBase> endpointProvider = nullptr);
 
        SimSpaceWeaverClient(const Aws::Auth::AWSCredentials& credentials,
                             std::shared_ptr<SimSpaceWeaverEndpointProviderBase> endpointProvider = nullptr,
                             const Aws::SimSpaceWeaver::SimSpaceWeaverClientConfiguration& clientConfiguration = Aws::SimSpaceWeaver::SimSpaceWeaverClientConfiguration());
 
        SimSpaceWeaverClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                             std::shared_ptr<SimSpaceWeaverEndpointProviderBase> endpointProvider = nullptr,
                             const Aws::SimSpaceWeaver::SimSpaceWeaverClientConfiguration& clientConfiguration = Aws::SimSpaceWeaver::SimSpaceWeaverClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        SimSpaceWeaverClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        SimSpaceWeaverClient(const Aws::Auth::AWSCredentials& credentials,
                             const Aws::Client::ClientConfiguration& clientConfiguration);
 
        SimSpaceWeaverClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                             const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~SimSpaceWeaverClient();
 
        virtual Model::CreateSnapshotOutcome CreateSnapshot(const Model::CreateSnapshotRequest& request) const;
 
        template<typename CreateSnapshotRequestT = Model::CreateSnapshotRequest>
        Model::CreateSnapshotOutcomeCallable CreateSnapshotCallable(const CreateSnapshotRequestT& request) const
        {
            return SubmitCallable(&SimSpaceWeaverClient::CreateSnapshot, request);
        }
 
        template<typename CreateSnapshotRequestT = Model::CreateSnapshotRequest>
        void CreateSnapshotAsync(const CreateSnapshotRequestT& request, const CreateSnapshotResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SimSpaceWeaverClient::CreateSnapshot, request, handler, context);
        }
 
        virtual Model::DeleteAppOutcome DeleteApp(const Model::DeleteAppRequest& request) const;
 
        template<typename DeleteAppRequestT = Model::DeleteAppRequest>
        Model::DeleteAppOutcomeCallable DeleteAppCallable(const DeleteAppRequestT& request) const
        {
            return SubmitCallable(&SimSpaceWeaverClient::DeleteApp, request);
        }
 
        template<typename DeleteAppRequestT = Model::DeleteAppRequest>
        void DeleteAppAsync(const DeleteAppRequestT& request, const DeleteAppResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SimSpaceWeaverClient::DeleteApp, request, handler, context);
        }
 
        virtual Model::DeleteSimulationOutcome DeleteSimulation(const Model::DeleteSimulationRequest& request) const;
 
        template<typename DeleteSimulationRequestT = Model::DeleteSimulationRequest>
        Model::DeleteSimulationOutcomeCallable DeleteSimulationCallable(const DeleteSimulationRequestT& request) const
        {
            return SubmitCallable(&SimSpaceWeaverClient::DeleteSimulation, request);
        }
 
        template<typename DeleteSimulationRequestT = Model::DeleteSimulationRequest>
        void DeleteSimulationAsync(const DeleteSimulationRequestT& request, const DeleteSimulationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SimSpaceWeaverClient::DeleteSimulation, request, handler, context);
        }
 
        virtual Model::DescribeAppOutcome DescribeApp(const Model::DescribeAppRequest& request) const;
 
        template<typename DescribeAppRequestT = Model::DescribeAppRequest>
        Model::DescribeAppOutcomeCallable DescribeAppCallable(const DescribeAppRequestT& request) const
        {
            return SubmitCallable(&SimSpaceWeaverClient::DescribeApp, request);
        }
 
        template<typename DescribeAppRequestT = Model::DescribeAppRequest>
        void DescribeAppAsync(const DescribeAppRequestT& request, const DescribeAppResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SimSpaceWeaverClient::DescribeApp, request, handler, context);
        }
 
        virtual Model::DescribeSimulationOutcome DescribeSimulation(const Model::DescribeSimulationRequest& request) const;
 
        template<typename DescribeSimulationRequestT = Model::DescribeSimulationRequest>
        Model::DescribeSimulationOutcomeCallable DescribeSimulationCallable(const DescribeSimulationRequestT& request) const
        {
            return SubmitCallable(&SimSpaceWeaverClient::DescribeSimulation, request);
        }
 
        template<typename DescribeSimulationRequestT = Model::DescribeSimulationRequest>
        void DescribeSimulationAsync(const DescribeSimulationRequestT& request, const DescribeSimulationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SimSpaceWeaverClient::DescribeSimulation, request, handler, context);
        }
 
        virtual Model::ListAppsOutcome ListApps(const Model::ListAppsRequest& request) const;
 
        template<typename ListAppsRequestT = Model::ListAppsRequest>
        Model::ListAppsOutcomeCallable ListAppsCallable(const ListAppsRequestT& request) const
        {
            return SubmitCallable(&SimSpaceWeaverClient::ListApps, request);
        }
 
        template<typename ListAppsRequestT = Model::ListAppsRequest>
        void ListAppsAsync(const ListAppsRequestT& request, const ListAppsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SimSpaceWeaverClient::ListApps, request, handler, context);
        }
 
        virtual Model::ListSimulationsOutcome ListSimulations(const Model::ListSimulationsRequest& request = {}) const;
 
        template<typename ListSimulationsRequestT = Model::ListSimulationsRequest>
        Model::ListSimulationsOutcomeCallable ListSimulationsCallable(const ListSimulationsRequestT& request = {}) const
        {
            return SubmitCallable(&SimSpaceWeaverClient::ListSimulations, request);
        }
 
        template<typename ListSimulationsRequestT = Model::ListSimulationsRequest>
        void ListSimulationsAsync(const ListSimulationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListSimulationsRequestT& request = {}) const
        {
            return SubmitAsync(&SimSpaceWeaverClient::ListSimulations, 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(&SimSpaceWeaverClient::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(&SimSpaceWeaverClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::StartAppOutcome StartApp(const Model::StartAppRequest& request) const;
 
        template<typename StartAppRequestT = Model::StartAppRequest>
        Model::StartAppOutcomeCallable StartAppCallable(const StartAppRequestT& request) const
        {
            return SubmitCallable(&SimSpaceWeaverClient::StartApp, request);
        }
 
        template<typename StartAppRequestT = Model::StartAppRequest>
        void StartAppAsync(const StartAppRequestT& request, const StartAppResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SimSpaceWeaverClient::StartApp, request, handler, context);
        }
 
        virtual Model::StartClockOutcome StartClock(const Model::StartClockRequest& request) const;
 
        template<typename StartClockRequestT = Model::StartClockRequest>
        Model::StartClockOutcomeCallable StartClockCallable(const StartClockRequestT& request) const
        {
            return SubmitCallable(&SimSpaceWeaverClient::StartClock, request);
        }
 
        template<typename StartClockRequestT = Model::StartClockRequest>
        void StartClockAsync(const StartClockRequestT& request, const StartClockResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SimSpaceWeaverClient::StartClock, request, handler, context);
        }
 
        virtual Model::StartSimulationOutcome StartSimulation(const Model::StartSimulationRequest& request) const;
 
        template<typename StartSimulationRequestT = Model::StartSimulationRequest>
        Model::StartSimulationOutcomeCallable StartSimulationCallable(const StartSimulationRequestT& request) const
        {
            return SubmitCallable(&SimSpaceWeaverClient::StartSimulation, request);
        }
 
        template<typename StartSimulationRequestT = Model::StartSimulationRequest>
        void StartSimulationAsync(const StartSimulationRequestT& request, const StartSimulationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SimSpaceWeaverClient::StartSimulation, request, handler, context);
        }
 
        virtual Model::StopAppOutcome StopApp(const Model::StopAppRequest& request) const;
 
        template<typename StopAppRequestT = Model::StopAppRequest>
        Model::StopAppOutcomeCallable StopAppCallable(const StopAppRequestT& request) const
        {
            return SubmitCallable(&SimSpaceWeaverClient::StopApp, request);
        }
 
        template<typename StopAppRequestT = Model::StopAppRequest>
        void StopAppAsync(const StopAppRequestT& request, const StopAppResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SimSpaceWeaverClient::StopApp, request, handler, context);
        }
 
        virtual Model::StopClockOutcome StopClock(const Model::StopClockRequest& request) const;
 
        template<typename StopClockRequestT = Model::StopClockRequest>
        Model::StopClockOutcomeCallable StopClockCallable(const StopClockRequestT& request) const
        {
            return SubmitCallable(&SimSpaceWeaverClient::StopClock, request);
        }
 
        template<typename StopClockRequestT = Model::StopClockRequest>
        void StopClockAsync(const StopClockRequestT& request, const StopClockResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SimSpaceWeaverClient::StopClock, request, handler, context);
        }
 
        virtual Model::StopSimulationOutcome StopSimulation(const Model::StopSimulationRequest& request) const;
 
        template<typename StopSimulationRequestT = Model::StopSimulationRequest>
        Model::StopSimulationOutcomeCallable StopSimulationCallable(const StopSimulationRequestT& request) const
        {
            return SubmitCallable(&SimSpaceWeaverClient::StopSimulation, request);
        }
 
        template<typename StopSimulationRequestT = Model::StopSimulationRequest>
        void StopSimulationAsync(const StopSimulationRequestT& request, const StopSimulationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SimSpaceWeaverClient::StopSimulation, 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(&SimSpaceWeaverClient::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(&SimSpaceWeaverClient::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(&SimSpaceWeaverClient::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(&SimSpaceWeaverClient::UntagResource, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<SimSpaceWeaverEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<SimSpaceWeaverClient>;
      void init(const SimSpaceWeaverClientConfiguration& clientConfiguration);
 
      SimSpaceWeaverClientConfiguration m_clientConfiguration;
      std::shared_ptr<SimSpaceWeaverEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace SimSpaceWeaver
} // namespace Aws