GeoPlacesClient.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-places/GeoPlacesPaginationBase.h>
#include <aws/geo-places/GeoPlacesServiceClientModel.h>
#include <aws/geo-places/GeoPlaces_EXPORTS.h>
 
namespace Aws {
namespace GeoPlaces {
class AWS_GEOPLACES_API GeoPlacesClient : public Aws::Client::AWSJsonClient,
                                          public Aws::Client::ClientWithAsyncTemplateMethods<GeoPlacesClient>,
                                          public GeoPlacesPaginationBase<GeoPlacesClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef GeoPlacesClientConfiguration ClientConfigurationType;
  typedef GeoPlacesEndpointProvider EndpointProviderType;
 
  GeoPlacesClient(const Aws::GeoPlaces::GeoPlacesClientConfiguration& clientConfiguration = Aws::GeoPlaces::GeoPlacesClientConfiguration(),
                  std::shared_ptr<GeoPlacesEndpointProviderBase> endpointProvider = nullptr);
 
  GeoPlacesClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<GeoPlacesEndpointProviderBase> endpointProvider = nullptr,
                  const Aws::GeoPlaces::GeoPlacesClientConfiguration& clientConfiguration = Aws::GeoPlaces::GeoPlacesClientConfiguration());
 
  GeoPlacesClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                  std::shared_ptr<GeoPlacesEndpointProviderBase> endpointProvider = nullptr,
                  const Aws::GeoPlaces::GeoPlacesClientConfiguration& clientConfiguration = Aws::GeoPlaces::GeoPlacesClientConfiguration());
 
  /* Legacy constructors due deprecation */
  GeoPlacesClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  GeoPlacesClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  GeoPlacesClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                  const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~GeoPlacesClient();
 
  virtual Model::AutocompleteOutcome Autocomplete(const Model::AutocompleteRequest& request) const;
 
  template <typename AutocompleteRequestT = Model::AutocompleteRequest>
  Model::AutocompleteOutcomeCallable AutocompleteCallable(const AutocompleteRequestT& request) const {
    return SubmitCallable(&GeoPlacesClient::Autocomplete, request);
  }
 
  template <typename AutocompleteRequestT = Model::AutocompleteRequest>
  void AutocompleteAsync(const AutocompleteRequestT& request, const AutocompleteResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GeoPlacesClient::Autocomplete, request, handler, context);
  }
 
  virtual Model::GeocodeOutcome Geocode(const Model::GeocodeRequest& request = {}) const;
 
  template <typename GeocodeRequestT = Model::GeocodeRequest>
  Model::GeocodeOutcomeCallable GeocodeCallable(const GeocodeRequestT& request = {}) const {
    return SubmitCallable(&GeoPlacesClient::Geocode, request);
  }
 
  template <typename GeocodeRequestT = Model::GeocodeRequest>
  void GeocodeAsync(const GeocodeResponseReceivedHandler& handler,
                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                    const GeocodeRequestT& request = {}) const {
    return SubmitAsync(&GeoPlacesClient::Geocode, request, handler, context);
  }
 
  virtual Model::GetPlaceOutcome GetPlace(const Model::GetPlaceRequest& request) const;
 
  template <typename GetPlaceRequestT = Model::GetPlaceRequest>
  Model::GetPlaceOutcomeCallable GetPlaceCallable(const GetPlaceRequestT& request) const {
    return SubmitCallable(&GeoPlacesClient::GetPlace, request);
  }
 
  template <typename GetPlaceRequestT = Model::GetPlaceRequest>
  void GetPlaceAsync(const GetPlaceRequestT& request, const GetPlaceResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GeoPlacesClient::GetPlace, request, handler, context);
  }
 
  virtual Model::ReverseGeocodeOutcome ReverseGeocode(const Model::ReverseGeocodeRequest& request) const;
 
  template <typename ReverseGeocodeRequestT = Model::ReverseGeocodeRequest>
  Model::ReverseGeocodeOutcomeCallable ReverseGeocodeCallable(const ReverseGeocodeRequestT& request) const {
    return SubmitCallable(&GeoPlacesClient::ReverseGeocode, request);
  }
 
  template <typename ReverseGeocodeRequestT = Model::ReverseGeocodeRequest>
  void ReverseGeocodeAsync(const ReverseGeocodeRequestT& request, const ReverseGeocodeResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GeoPlacesClient::ReverseGeocode, request, handler, context);
  }
 
  virtual Model::SearchNearbyOutcome SearchNearby(const Model::SearchNearbyRequest& request) const;
 
  template <typename SearchNearbyRequestT = Model::SearchNearbyRequest>
  Model::SearchNearbyOutcomeCallable SearchNearbyCallable(const SearchNearbyRequestT& request) const {
    return SubmitCallable(&GeoPlacesClient::SearchNearby, request);
  }
 
  template <typename SearchNearbyRequestT = Model::SearchNearbyRequest>
  void SearchNearbyAsync(const SearchNearbyRequestT& request, const SearchNearbyResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GeoPlacesClient::SearchNearby, request, handler, context);
  }
 
  virtual Model::SearchTextOutcome SearchText(const Model::SearchTextRequest& request = {}) const;
 
  template <typename SearchTextRequestT = Model::SearchTextRequest>
  Model::SearchTextOutcomeCallable SearchTextCallable(const SearchTextRequestT& request = {}) const {
    return SubmitCallable(&GeoPlacesClient::SearchText, request);
  }
 
  template <typename SearchTextRequestT = Model::SearchTextRequest>
  void SearchTextAsync(const SearchTextResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                       const SearchTextRequestT& request = {}) const {
    return SubmitAsync(&GeoPlacesClient::SearchText, request, handler, context);
  }
 
  virtual Model::SuggestOutcome Suggest(const Model::SuggestRequest& request) const;
 
  template <typename SuggestRequestT = Model::SuggestRequest>
  Model::SuggestOutcomeCallable SuggestCallable(const SuggestRequestT& request) const {
    return SubmitCallable(&GeoPlacesClient::Suggest, request);
  }
 
  template <typename SuggestRequestT = Model::SuggestRequest>
  void SuggestAsync(const SuggestRequestT& request, const SuggestResponseReceivedHandler& handler,
                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GeoPlacesClient::Suggest, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<GeoPlacesEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<GeoPlacesClient>;
  void init(const GeoPlacesClientConfiguration& clientConfiguration);
 
  GeoPlacesClientConfiguration m_clientConfiguration;
  std::shared_ptr<GeoPlacesEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace GeoPlaces
}  // namespace Aws