GeoMapsClient.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-maps/GeoMapsServiceClientModel.h>
#include <aws/geo-maps/GeoMaps_EXPORTS.h>
 
namespace Aws {
namespace GeoMaps {
class AWS_GEOMAPS_API GeoMapsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<GeoMapsClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef GeoMapsClientConfiguration ClientConfigurationType;
  typedef GeoMapsEndpointProvider EndpointProviderType;
 
  GeoMapsClient(const Aws::GeoMaps::GeoMapsClientConfiguration& clientConfiguration = Aws::GeoMaps::GeoMapsClientConfiguration(),
                std::shared_ptr<GeoMapsEndpointProviderBase> endpointProvider = nullptr);
 
  GeoMapsClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<GeoMapsEndpointProviderBase> endpointProvider = nullptr,
                const Aws::GeoMaps::GeoMapsClientConfiguration& clientConfiguration = Aws::GeoMaps::GeoMapsClientConfiguration());
 
  GeoMapsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                std::shared_ptr<GeoMapsEndpointProviderBase> endpointProvider = nullptr,
                const Aws::GeoMaps::GeoMapsClientConfiguration& clientConfiguration = Aws::GeoMaps::GeoMapsClientConfiguration());
 
  /* Legacy constructors due deprecation */
  GeoMapsClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  GeoMapsClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  GeoMapsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~GeoMapsClient();
 
  virtual Model::GetGlyphsOutcome GetGlyphs(const Model::GetGlyphsRequest& request) const;
 
  template <typename GetGlyphsRequestT = Model::GetGlyphsRequest>
  Model::GetGlyphsOutcomeCallable GetGlyphsCallable(const GetGlyphsRequestT& request) const {
    return SubmitCallable(&GeoMapsClient::GetGlyphs, request);
  }
 
  template <typename GetGlyphsRequestT = Model::GetGlyphsRequest>
  void GetGlyphsAsync(const GetGlyphsRequestT& request, const GetGlyphsResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GeoMapsClient::GetGlyphs, request, handler, context);
  }
 
  virtual Model::GetSpritesOutcome GetSprites(const Model::GetSpritesRequest& request) const;
 
  template <typename GetSpritesRequestT = Model::GetSpritesRequest>
  Model::GetSpritesOutcomeCallable GetSpritesCallable(const GetSpritesRequestT& request) const {
    return SubmitCallable(&GeoMapsClient::GetSprites, request);
  }
 
  template <typename GetSpritesRequestT = Model::GetSpritesRequest>
  void GetSpritesAsync(const GetSpritesRequestT& request, const GetSpritesResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GeoMapsClient::GetSprites, request, handler, context);
  }
 
  virtual Model::GetStaticMapOutcome GetStaticMap(const Model::GetStaticMapRequest& request) const;
 
  template <typename GetStaticMapRequestT = Model::GetStaticMapRequest>
  Model::GetStaticMapOutcomeCallable GetStaticMapCallable(const GetStaticMapRequestT& request) const {
    return SubmitCallable(&GeoMapsClient::GetStaticMap, request);
  }
 
  template <typename GetStaticMapRequestT = Model::GetStaticMapRequest>
  void GetStaticMapAsync(const GetStaticMapRequestT& request, const GetStaticMapResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GeoMapsClient::GetStaticMap, request, handler, context);
  }
 
  virtual Model::GetStyleDescriptorOutcome GetStyleDescriptor(const Model::GetStyleDescriptorRequest& request) const;
 
  template <typename GetStyleDescriptorRequestT = Model::GetStyleDescriptorRequest>
  Model::GetStyleDescriptorOutcomeCallable GetStyleDescriptorCallable(const GetStyleDescriptorRequestT& request) const {
    return SubmitCallable(&GeoMapsClient::GetStyleDescriptor, request);
  }
 
  template <typename GetStyleDescriptorRequestT = Model::GetStyleDescriptorRequest>
  void GetStyleDescriptorAsync(const GetStyleDescriptorRequestT& request, const GetStyleDescriptorResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GeoMapsClient::GetStyleDescriptor, request, handler, context);
  }
 
  virtual Model::GetTileOutcome GetTile(const Model::GetTileRequest& request) const;
 
  template <typename GetTileRequestT = Model::GetTileRequest>
  Model::GetTileOutcomeCallable GetTileCallable(const GetTileRequestT& request) const {
    return SubmitCallable(&GeoMapsClient::GetTile, request);
  }
 
  template <typename GetTileRequestT = Model::GetTileRequest>
  void GetTileAsync(const GetTileRequestT& request, const GetTileResponseReceivedHandler& handler,
                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GeoMapsClient::GetTile, request, handler, context);
  }
 
  void OverrideEndpoint(const Aws::String& endpoint);
  std::shared_ptr<GeoMapsEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<GeoMapsClient>;
  void init(const GeoMapsClientConfiguration& clientConfiguration);
 
  GeoMapsClientConfiguration m_clientConfiguration;
  std::shared_ptr<GeoMapsEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace GeoMaps
}  // namespace Aws