GeoPlacesClient.h

 
#pragma once
#include <aws/geo-places/GeoPlaces_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/geo-places/GeoPlacesServiceClientModel.h>
 
namespace Aws
{
namespace GeoPlaces
{
  class AWS_GEOPLACES_API GeoPlacesClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      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