GeoRoutesClient.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/geo-routes/GeoRoutesPaginationBase.h>
#include <aws/geo-routes/GeoRoutesServiceClientModel.h>
#include <aws/geo-routes/GeoRoutesWaiter.h>
#include <aws/geo-routes/GeoRoutes_EXPORTS.h>
 
namespace Aws {
namespace GeoRoutes {
class AWS_GEOROUTES_API GeoRoutesClient : public Aws::Client::AWSJsonClient,
                                          public Aws::Client::ClientWithAsyncTemplateMethods<GeoRoutesClient>,
                                          public GeoRoutesPaginationBase<GeoRoutesClient>,
                                          public GeoRoutesWaiter<GeoRoutesClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef GeoRoutesClientConfiguration ClientConfigurationType;
  typedef GeoRoutesEndpointProvider EndpointProviderType;
 
  GeoRoutesClient(const Aws::GeoRoutes::GeoRoutesClientConfiguration& clientConfiguration = Aws::GeoRoutes::GeoRoutesClientConfiguration(),
                  std::shared_ptr<GeoRoutesEndpointProviderBase> endpointProvider = nullptr);
 
  GeoRoutesClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<GeoRoutesEndpointProviderBase> endpointProvider = nullptr,
                  const Aws::GeoRoutes::GeoRoutesClientConfiguration& clientConfiguration = Aws::GeoRoutes::GeoRoutesClientConfiguration());
 
  GeoRoutesClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                  std::shared_ptr<GeoRoutesEndpointProviderBase> endpointProvider = nullptr,
                  const Aws::GeoRoutes::GeoRoutesClientConfiguration& clientConfiguration = Aws::GeoRoutes::GeoRoutesClientConfiguration());
 
  /* Legacy constructors due deprecation */
  GeoRoutesClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  GeoRoutesClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  GeoRoutesClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                  const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~GeoRoutesClient();
 
  virtual Model::CalculateIsolinesOutcome CalculateIsolines(const Model::CalculateIsolinesRequest& request) const;
 
  template <typename CalculateIsolinesRequestT = Model::CalculateIsolinesRequest>
  Model::CalculateIsolinesOutcomeCallable CalculateIsolinesCallable(const CalculateIsolinesRequestT& request) const {
    return SubmitCallable(&GeoRoutesClient::CalculateIsolines, request);
  }
 
  template <typename CalculateIsolinesRequestT = Model::CalculateIsolinesRequest>
  void CalculateIsolinesAsync(const CalculateIsolinesRequestT& request, const CalculateIsolinesResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GeoRoutesClient::CalculateIsolines, request, handler, context);
  }
 
  virtual Model::CalculateRouteMatrixOutcome CalculateRouteMatrix(const Model::CalculateRouteMatrixRequest& request) const;
 
  template <typename CalculateRouteMatrixRequestT = Model::CalculateRouteMatrixRequest>
  Model::CalculateRouteMatrixOutcomeCallable CalculateRouteMatrixCallable(const CalculateRouteMatrixRequestT& request) const {
    return SubmitCallable(&GeoRoutesClient::CalculateRouteMatrix, request);
  }
 
  template <typename CalculateRouteMatrixRequestT = Model::CalculateRouteMatrixRequest>
  void CalculateRouteMatrixAsync(const CalculateRouteMatrixRequestT& request, const CalculateRouteMatrixResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GeoRoutesClient::CalculateRouteMatrix, request, handler, context);
  }
 
  virtual Model::CalculateRoutesOutcome CalculateRoutes(const Model::CalculateRoutesRequest& request) const;
 
  template <typename CalculateRoutesRequestT = Model::CalculateRoutesRequest>
  Model::CalculateRoutesOutcomeCallable CalculateRoutesCallable(const CalculateRoutesRequestT& request) const {
    return SubmitCallable(&GeoRoutesClient::CalculateRoutes, request);
  }
 
  template <typename CalculateRoutesRequestT = Model::CalculateRoutesRequest>
  void CalculateRoutesAsync(const CalculateRoutesRequestT& request, const CalculateRoutesResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GeoRoutesClient::CalculateRoutes, request, handler, context);
  }
 
  virtual Model::OptimizeWaypointsOutcome OptimizeWaypoints(const Model::OptimizeWaypointsRequest& request) const;
 
  template <typename OptimizeWaypointsRequestT = Model::OptimizeWaypointsRequest>
  Model::OptimizeWaypointsOutcomeCallable OptimizeWaypointsCallable(const OptimizeWaypointsRequestT& request) const {
    return SubmitCallable(&GeoRoutesClient::OptimizeWaypoints, request);
  }
 
  template <typename OptimizeWaypointsRequestT = Model::OptimizeWaypointsRequest>
  void OptimizeWaypointsAsync(const OptimizeWaypointsRequestT& request, const OptimizeWaypointsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GeoRoutesClient::OptimizeWaypoints, request, handler, context);
  }
 
  virtual Model::SnapToRoadsOutcome SnapToRoads(const Model::SnapToRoadsRequest& request) const;
 
  template <typename SnapToRoadsRequestT = Model::SnapToRoadsRequest>
  Model::SnapToRoadsOutcomeCallable SnapToRoadsCallable(const SnapToRoadsRequestT& request) const {
    return SubmitCallable(&GeoRoutesClient::SnapToRoads, request);
  }
 
  template <typename SnapToRoadsRequestT = Model::SnapToRoadsRequest>
  void SnapToRoadsAsync(const SnapToRoadsRequestT& request, const SnapToRoadsResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GeoRoutesClient::SnapToRoads, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<GeoRoutesEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<GeoRoutesClient>;
  void init(const GeoRoutesClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, GeoRoutesError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  GeoRoutesClientConfiguration m_clientConfiguration;
  std::shared_ptr<GeoRoutesEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace GeoRoutes
}  // namespace Aws