SimSpaceWeaverClient.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/simspaceweaver/SimSpaceWeaverPaginationBase.h>
#include <aws/simspaceweaver/SimSpaceWeaverServiceClientModel.h>
#include <aws/simspaceweaver/SimSpaceWeaverWaiter.h>
#include <aws/simspaceweaver/SimSpaceWeaver_EXPORTS.h>
 
namespace Aws {
namespace SimSpaceWeaver {
class AWS_SIMSPACEWEAVER_API SimSpaceWeaverClient : public Aws::Client::AWSJsonClient,
                                                    public Aws::Client::ClientWithAsyncTemplateMethods<SimSpaceWeaverClient>,
                                                    public SimSpaceWeaverPaginationBase<SimSpaceWeaverClient>,
                                                    public SimSpaceWeaverWaiter<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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<SimSpaceWeaverEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<SimSpaceWeaverClient>;
  void init(const SimSpaceWeaverClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, SimSpaceWeaverError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  SimSpaceWeaverClientConfiguration m_clientConfiguration;
  std::shared_ptr<SimSpaceWeaverEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace SimSpaceWeaver
}  // namespace Aws