@acalcutt/maplibre-gl-native-test 5.0.1-pre.16 → 5.0.2-pre.1

package/platform/android/MapboxGLAndroidSDK/src/cpp/android_renderer_frontend.hpp

@@ -1,68 +0,0 @@
-#pragma once
-
-#include <mbgl/actor/actor.hpp>
-#include <mbgl/annotation/annotation.hpp>
-#include <mbgl/renderer/renderer_frontend.hpp>
-#include <mbgl/util/geo.hpp>
-#include <mbgl/util/run_loop.hpp>
-
-#include <functional>
-#include <memory>
-#include <vector>
-#include <string>
-#include <mbgl/util/geojson.hpp>
-
-#include "map_renderer.hpp"
-
-namespace mbgl {
-
-class RenderedQueryOptions;
-class SourceQueryOptions;
-
-namespace util {
-
-class AsyncTask;
-
-} // namespace util
-
-namespace android {
-
-class AndroidRendererFrontend : public RendererFrontend {
-public:
-
-    AndroidRendererFrontend(MapRenderer&);
-    ~AndroidRendererFrontend() override;
-
-    void reset() override;
-    void setObserver(RendererObserver&) override;
-
-    void update(std::shared_ptr<UpdateParameters>) override;
-
-    // Feature querying
-    std::vector<Feature> queryRenderedFeatures(const ScreenCoordinate&, const RenderedQueryOptions&) const;
-    std::vector<Feature> queryRenderedFeatures(const ScreenBox&, const RenderedQueryOptions&) const;
-    std::vector<Feature> querySourceFeatures(const std::string& sourceID, const SourceQueryOptions&) const;
-    AnnotationIDs queryPointAnnotations(const ScreenBox& box) const;
-    AnnotationIDs queryShapeAnnotations(const ScreenBox& box) const;
-
-
-    // Feature extension query
-    FeatureExtensionValue
-    queryFeatureExtensions(const std::string& sourceID,
-                           const Feature& feature,
-                           const std::string& extension,
-                           const std::string& extensionField,
-                           const optional<std::map<std::string, mbgl::Value>>& args) const;
-
-    // Memory
-    void reduceMemoryUse();
-
-private:
-    MapRenderer& mapRenderer;
-    util::RunLoop* mapRunLoop;
-    std::unique_ptr<util::AsyncTask> updateAsyncTask;
-    std::shared_ptr<UpdateParameters> updateParams;
-};
-
-} // namespace android
-} // namespace mbgl

package/platform/android/MapboxGLAndroidSDK/src/cpp/annotation/marker.cpp

@@ -1,23 +0,0 @@
-#include "marker.hpp"
-
-namespace mbgl {
-namespace android {
-
-mbgl::Point<double> Marker::getPosition(jni::JNIEnv& env, const jni::Object<Marker>& marker) {
-    static auto& javaClass = jni::Class<Marker>::Singleton(env);
-    static auto positionField = javaClass.GetField<jni::Object<LatLng>>(env, "position");
-    return LatLng::getGeometry(env, marker.Get(env, positionField));
-}
-
-std::string Marker::getIconId(jni::JNIEnv& env, const jni::Object<Marker>& marker) {
-    static auto& javaClass = jni::Class<Marker>::Singleton(env);
-    static auto iconIdField = javaClass.GetField<jni::String>(env, "iconId");
-    return jni::Make<std::string>(env, marker.Get(env, iconIdField));
-}
-
-void Marker::registerNative(jni::JNIEnv& env) {
-    jni::Class<Marker>::Singleton(env);
-}
-
-} // namespace android
-} // namespace mbgl

package/platform/android/MapboxGLAndroidSDK/src/cpp/annotation/marker.hpp

@@ -1,28 +0,0 @@
-#pragma once
-
-#include <mbgl/util/noncopyable.hpp>
-#include <jni/jni.hpp>
-
-#include <string>
-
-#include "../geometry/lat_lng.hpp"
-
-namespace mbgl {
-namespace android {
-
-class Marker : private mbgl::util::noncopyable {
-public:
-
-    static constexpr auto Name() { return "com/mapbox/mapboxsdk/annotations/Marker"; };
-
-    static mbgl::Point<double> getPosition(jni::JNIEnv&, const jni::Object<Marker>&);
-
-    static std::string getIconId(jni::JNIEnv&, const jni::Object<Marker>&);
-
-    static void registerNative(jni::JNIEnv&);
-
-};
-
-
-} // namespace android
-} // namespace mbgl

package/platform/android/MapboxGLAndroidSDK/src/cpp/annotation/multi_point.hpp

@@ -1,34 +0,0 @@
-#pragma once
-
-#include <mbgl/util/noncopyable.hpp>
-#include <jni/jni.hpp>
-
-#include "../geometry/lat_lng.hpp"
-#include "../java/util.hpp"
-
-namespace mbgl {
-namespace android {
-
-class MultiPoint : protected mbgl::util::noncopyable {
-
-protected:
-
-  template <class Geometry>
-  static Geometry toGeometry(JNIEnv& env, const jni::Object<java::util::List>& pointsList) {
-      auto jarray = java::util::List::toArray<LatLng>(env, pointsList);
-
-      std::size_t size = jarray.Length(env);
-
-      Geometry geometry;
-      geometry.reserve(size);
-
-      for (std::size_t i = 0; i < size; i++) {
-          geometry.push_back(LatLng::getGeometry(env, jarray.Get(env, i)));
-      }
-
-      return geometry;
-  }
-};
-
-} // namespace android
-} // namespace mbgl

package/platform/android/MapboxGLAndroidSDK/src/cpp/annotation/polygon.cpp

@@ -1,40 +0,0 @@
-#include "polygon.hpp"
-
-#include "../conversion/color.hpp"
-
-namespace mbgl {
-namespace android {
-
-mbgl::FillAnnotation Polygon::toAnnotation(jni::JNIEnv& env, const jni::Object<Polygon>& polygon) {
-    static auto& javaClass = jni::Class<Polygon>::Singleton(env);
-    static auto points = javaClass.GetField<jni::Object<java::util::List>>(env, "points");
-    static auto holes = javaClass.GetField<jni::Object<java::util::List>>(env, "holes");
-    static auto alpha = javaClass.GetField<float>(env, "alpha");
-    static auto fillColor = javaClass.GetField<int>(env, "fillColor");
-    static auto strokeColor = javaClass.GetField<int>(env, "strokeColor");
-
-    mbgl::Polygon<double> geometry {
-        MultiPoint::toGeometry<mbgl::LinearRing<double>>(env, polygon.Get(env, points))
-    };
-
-    auto jHoleListsArray = java::util::List::toArray<java::util::List>(env, polygon.Get(env, holes));
-
-    std::size_t jHoleListsSize = jHoleListsArray.Length(env);
-    for (std::size_t i = 0; i < jHoleListsSize; i++) {
-        geometry.push_back(MultiPoint::toGeometry<mbgl::LinearRing<double>>(env, jHoleListsArray.Get(env, i)));
-    }
-
-    mbgl::FillAnnotation annotation { geometry };
-    annotation.opacity = polygon.Get(env, alpha);
-    annotation.color = *conversion::convert<mbgl::Color>(env, polygon.Get(env, fillColor));
-    annotation.outlineColor = *conversion::convert<mbgl::Color>(env, polygon.Get(env, strokeColor));
-
-    return annotation;
-}
-
-void Polygon::registerNative(jni::JNIEnv& env) {
-    jni::Class<Polygon>::Singleton(env);
-}
-
-} // namespace android
-} // namespace mbgl

package/platform/android/MapboxGLAndroidSDK/src/cpp/annotation/polygon.hpp

@@ -1,21 +0,0 @@
-#pragma once
-
-#include <mbgl/annotation/annotation.hpp>
-
-#include "multi_point.hpp"
-
-namespace mbgl {
-namespace android {
-
-class Polygon : private MultiPoint {
-public:
-    static constexpr auto Name() { return "com/mapbox/mapboxsdk/annotations/Polygon"; };
-
-    static mbgl::FillAnnotation toAnnotation(jni::JNIEnv&, const jni::Object<Polygon>&);
-
-    static void registerNative(jni::JNIEnv&);
-};
-
-
-} // namespace android
-} // namespace mbgl

package/platform/android/MapboxGLAndroidSDK/src/cpp/annotation/polyline.cpp

@@ -1,31 +0,0 @@
-#include "polyline.hpp"
-
-#include "../conversion/color.hpp"
-
-namespace mbgl {
-namespace android {
-
-mbgl::LineAnnotation Polyline::toAnnotation(jni::JNIEnv& env, const jni::Object<Polyline>& polyline) {
-    static auto& javaClass = jni::Class<Polyline>::Singleton(env);
-    static auto points = javaClass.GetField<jni::Object<java::util::List>>(env, "points");
-    static auto alpha = javaClass.GetField<float>(env, "alpha");
-    static auto color = javaClass.GetField<int>(env, "color");
-    static auto width = javaClass.GetField<float>(env, "width");
-
-    mbgl::LineAnnotation annotation {
-        MultiPoint::toGeometry<mbgl::LineString<double>>(env, polyline.Get(env, points))
-    };
-
-    annotation.opacity = polyline.Get(env, alpha);
-    annotation.color = *conversion::convert<mbgl::Color>(env, polyline.Get(env, color));
-    annotation.width = polyline.Get(env, width);
-
-    return annotation;
-}
-
-void Polyline::registerNative(jni::JNIEnv& env) {
-    jni::Class<Polyline>::Singleton(env);
-}
-
-} // namespace android
-} // namespace mbgl

package/platform/android/MapboxGLAndroidSDK/src/cpp/annotation/polyline.hpp

@@ -1,21 +0,0 @@
-#pragma once
-
-#include <mbgl/annotation/annotation.hpp>
-
-#include "multi_point.hpp"
-
-namespace mbgl {
-namespace android {
-
-class Polyline : private MultiPoint {
-public:
-    static constexpr auto Name() { return "com/mapbox/mapboxsdk/annotations/Polyline"; };
-
-    static mbgl::LineAnnotation toAnnotation(jni::JNIEnv&, const jni::Object<Polyline>&);
-
-    static void registerNative(jni::JNIEnv&);
-};
-
-
-} // namespace android
-} // namespace mbgl

package/platform/android/MapboxGLAndroidSDK/src/cpp/asset_manager.hpp

@@ -1,14 +0,0 @@
-#pragma once
-
-namespace mbgl {
-namespace android {
-
-class AssetManager {
-public:
-    static constexpr auto Name() {
-        return "android/content/res/AssetManager";
-    };
-};
-
-} // namespace android
-} // namespace mbgl

package/platform/android/MapboxGLAndroidSDK/src/cpp/asset_manager_file_source.cpp

@@ -1,106 +0,0 @@
-#include "asset_manager_file_source.hpp"
-
-#include <mbgl/platform/settings.hpp>
-#include <mbgl/storage/file_source_request.hpp>
-#include <mbgl/storage/resource.hpp>
-#include <mbgl/storage/resource_options.hpp>
-#include <mbgl/storage/response.hpp>
-#include <mbgl/util/thread.hpp>
-#include <mbgl/util/url.hpp>
-#include <mbgl/util/util.hpp>
-
-#include <android/asset_manager.h>
-#include <android/asset_manager_jni.h>
-
-namespace mbgl {
-
-class AssetManagerFileSource::Impl {
-public:
-    Impl(ActorRef<Impl>, AAssetManager* assetManager_, const ResourceOptions resourceOptions_, const ClientOptions clientOptions_) :
-        resourceOptions(resourceOptions_.clone()),
-        clientOptions(clientOptions_.clone()),
-        assetManager(assetManager_) {}
-
-    void request(const std::string& url, ActorRef<FileSourceRequest> req) {
-        // Note: AssetManager already prepends "assets" to the filename.
-        const std::string path = mbgl::util::percentDecode(url.substr(8));
-
-        Response response;
-
-        if (AAsset* asset = AAssetManager_open(assetManager, path.c_str(), AASSET_MODE_BUFFER)) {
-            response.data = std::make_shared<std::string>(
-                reinterpret_cast<const char*>(AAsset_getBuffer(asset)), AAsset_getLength64(asset));
-            AAsset_close(asset);
-        } else {
-            response.error = std::make_unique<Response::Error>(Response::Error::Reason::NotFound,
-                                                               "Could not read asset");
-        }
-
-        req.invoke(&FileSourceRequest::setResponse, response);
-    }
-
-    void setResourceOptions(ResourceOptions options) {
-        resourceOptions = options;
-    }
-
-    ResourceOptions getResourceOptions() {
-        return resourceOptions.clone();
-    }
-
-    void setClientOptions(ClientOptions options) {
-        clientOptions = options;
-    }
-
-    ClientOptions getClientOptions() {
-        return clientOptions.clone();
-    }
-
-private:
-    AAssetManager* assetManager;
-    ResourceOptions resourceOptions;
-    ClientOptions clientOptions;
-};
-
-AssetManagerFileSource::AssetManagerFileSource(jni::JNIEnv& env,
-                                               const jni::Object<android::AssetManager>& assetManager_,
-                                               const ResourceOptions resourceOptions,
-                                               const ClientOptions clientOptions)
-    : assetManager(jni::NewGlobal(env, assetManager_)),
-      impl(std::make_unique<util::Thread<Impl>>(
-          util::makeThreadPrioritySetter(platform::EXPERIMENTAL_THREAD_PRIORITY_FILE),
-          "AssetManagerFileSource",
-          AAssetManager_fromJava(&env, jni::Unwrap(assetManager.get())),
-          resourceOptions.clone(),
-          clientOptions.clone())) {}
-
-AssetManagerFileSource::~AssetManagerFileSource() = default;
-
-std::unique_ptr<AsyncRequest> AssetManagerFileSource::request(const Resource& resource, Callback callback) {
-    auto req = std::make_unique<FileSourceRequest>(std::move(callback));
-
-    impl->actor().invoke(&Impl::request, resource.url, req->actor());
-
-    return std::move(req);
-}
-
-bool AssetManagerFileSource::canRequest(const Resource& resource) const {
-    return 0 == resource.url.rfind(mbgl::util::ASSET_PROTOCOL, 0);
-}
-
-void AssetManagerFileSource::setResourceOptions(ResourceOptions options) {
-    impl->actor().invoke(&Impl::setResourceOptions, options.clone());
-}
-
-ResourceOptions AssetManagerFileSource::getResourceOptions() {
-    return impl->actor().ask(&Impl::getResourceOptions).get();
-}
-
-void AssetManagerFileSource::setClientOptions(ClientOptions options) {
-    impl->actor().invoke(&Impl::setClientOptions, options.clone());
-}
-
-ClientOptions AssetManagerFileSource::getClientOptions() {
-    return impl->actor().ask(&Impl::getClientOptions).get();
-}
-
-} // namespace mbgl

package/platform/android/MapboxGLAndroidSDK/src/cpp/asset_manager_file_source.hpp

@@ -1,38 +0,0 @@
-#pragma once
-
-#include <mbgl/storage/file_source.hpp>
-#include <mbgl/storage/resource_options.hpp>
-#include <mbgl/util/client_options.hpp>
-
-#include "asset_manager.hpp"
-
-#include <jni/jni.hpp>
-
-namespace mbgl {
-
-namespace util {
-template <typename T> class Thread;
-} // namespace util
-
-class AssetManagerFileSource : public FileSource {
-public:
-    AssetManagerFileSource(jni::JNIEnv&, const jni::Object<android::AssetManager>&, const ResourceOptions, const ClientOptions);
-    ~AssetManagerFileSource() override;
-
-    std::unique_ptr<AsyncRequest> request(const Resource&, Callback) override;
-    bool canRequest(const Resource&) const override;
-
-    void setResourceOptions(ResourceOptions options) override;
-    ResourceOptions getResourceOptions() override;
-
-    void setClientOptions(ClientOptions options) override;
-    ClientOptions getClientOptions() override;
-
-private:
-    class Impl;
-
-    jni::Global<jni::Object<android::AssetManager>> assetManager;
-    std::unique_ptr<util::Thread<Impl>> impl;
-};
-
-} // namespace mbgl

package/platform/android/MapboxGLAndroidSDK/src/cpp/connectivity_listener.cpp

@@ -1,41 +0,0 @@
-#include "connectivity_listener.hpp"
-
-#include <mbgl/storage/network_status.hpp>
-#include <mbgl/util/logging.hpp>
-
-#include <jni/jni.hpp>
-
-namespace mbgl {
-namespace android {
-
-    /**
-     * Invoked when the construction is initiated from the jvm
-     */
-    ConnectivityListener::ConnectivityListener(jni::JNIEnv&) {}
-
-    ConnectivityListener::~ConnectivityListener() {}
-
-    void ConnectivityListener::onConnectivityStateChanged(jni::JNIEnv&, jni::jboolean connected) {
-        NetworkStatus::Set(connected ? NetworkStatus::Status::Online : NetworkStatus::Status::Offline);
-    }
-
-    void ConnectivityListener::registerNative(jni::JNIEnv& env) {
-        // Lookup the class
-        static auto& javaClass = jni::Class<ConnectivityListener>::Singleton(env);
-
-        #define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
-
-        // Register the peer
-        jni::RegisterNativePeer<ConnectivityListener>(
-            env,
-            javaClass,
-            "nativePtr",
-            std::make_unique<ConnectivityListener, JNIEnv&>,
-            "initialize",
-            "finalize",
-            METHOD(&ConnectivityListener::onConnectivityStateChanged, "nativeOnConnectivityStateChanged")
-        );
-    }
-
-} // namespace android
-} // namespace mbgl

package/platform/android/MapboxGLAndroidSDK/src/cpp/connectivity_listener.hpp

@@ -1,29 +0,0 @@
-#pragma once
-
-#include <mbgl/util/noncopyable.hpp>
-
-#include <jni/jni.hpp>
-
-namespace mbgl {
-namespace android {
-
-class ConnectivityListener : private mbgl::util::noncopyable {
-public:
-
-    static constexpr auto Name() { return "com/mapbox/mapboxsdk/net/NativeConnectivityListener"; };
-
-    static void registerNative(jni::JNIEnv&);
-
-    /*
-     * Called when a Java object was created from the jvm side
-     */
-    ConnectivityListener(jni::JNIEnv&);
-
-    ~ConnectivityListener();
-
-    void onConnectivityStateChanged(jni::JNIEnv&, jni::jboolean);
-
-};
-
-} // namespace android
-} // namespace mbgl

package/platform/android/MapboxGLAndroidSDK/src/cpp/conversion/collection.cpp

@@ -1,32 +0,0 @@
-#include "collection.hpp"
-#include "constant.hpp"
-
-namespace mbgl {
-namespace android {
-namespace conversion {
-
-std::vector<std::string> toVector(JNIEnv& env, const jni::Array<jni::String>& array) {
-    std::size_t len = array.Length(env);
-    std::vector<std::string> vector;
-    vector.reserve(len);
-
-    for (std::size_t i = 0; i < len; i++) {
-        vector.push_back(jni::Make<std::string>(env, array.Get(env, i)));
-    }
-
-    return vector;
-}
-
-jni::Local<jni::Array<jni::String>> toArray(JNIEnv& env, const std::vector<std::string>& vector) {
-    auto result = jni::Array<jni::String>::New(env, vector.size());
-
-    for (std::size_t i = 0; i < vector.size(); i++) {
-        result.Set(env, i, jni::Make<jni::String>(env, vector.at(i)));
-    }
-
-    return result;
-}
-
-}
-}
-}

package/platform/android/MapboxGLAndroidSDK/src/cpp/conversion/collection.hpp

@@ -1,18 +0,0 @@
-#pragma once
-
-#include "conversion.hpp"
-
-#include <jni/jni.hpp>
-
-#include <vector>
-
-namespace mbgl {
-namespace android {
-namespace conversion {
-
-std::vector<std::string> toVector(JNIEnv& env, const jni::Array<jni::String>& array);
-jni::Local<jni::Array<jni::String>> toArray(JNIEnv& env, const std::vector<std::string>&);
-
-}
-}
-}

package/platform/android/MapboxGLAndroidSDK/src/cpp/conversion/color.cpp

@@ -1,17 +0,0 @@
-#include "color.hpp"
-
-namespace mbgl {
-namespace android {
-namespace conversion {
-
-Result<mbgl::Color> Converter<mbgl::Color, int>::operator()(jni::JNIEnv&, const int& color) const {
-    float r = (color >> 16) & 0xFF;
-    float g = (color >> 8) & 0xFF;
-    float b = (color) & 0xFF;
-    float a = (color >> 24) & 0xFF;
-    return { mbgl::Color( r / 255.0f, g / 255.0f, b / 255.0f, a / 255.0f ) };
-}
-
-} // namespace conversion
-} // namespace style
-} // namespace mbgl

package/platform/android/MapboxGLAndroidSDK/src/cpp/conversion/color.hpp

@@ -1,18 +0,0 @@
-#pragma once
-
-#include "conversion.hpp"
-
-#include <mbgl/util/color.hpp>
-
-namespace mbgl {
-namespace android {
-namespace conversion {
-
-template <>
-struct Converter<mbgl::Color, int> {
-    Result<mbgl::Color> operator()(jni::JNIEnv&, const int& color) const;
-};
-
-} // namespace conversion
-} // namespace style
-} // namespace mbgl

package/platform/android/MapboxGLAndroidSDK/src/cpp/conversion/constant.cpp

@@ -1,76 +0,0 @@
-#include "constant.hpp"
-#include "collection.hpp"
-#include "../style/formatted.hpp"
-
-#include <mbgl/util/string.hpp>
-
-namespace mbgl {
-namespace android {
-namespace conversion {
-
-Result<jni::Local<jni::Object<>>> Converter<jni::Local<jni::Object<>>, bool>::operator()(jni::JNIEnv& env, const bool& value) const {
-    return jni::Box(env, value ? jni::jni_true : jni::jni_false);
-}
-
-Result<jni::Local<jni::Object<>>> Converter<jni::Local<jni::Object<>>, float>::operator()(jni::JNIEnv& env, const float& value) const {
-    return jni::Box(env, value);
-}
-
-Result<jni::Local<jni::Object<>>> Converter<jni::Local<jni::Object<>>, double>::operator()(jni::JNIEnv& env, const double& value) const {
-    return jni::Box(env, value);
-}
-
-Result<jni::Local<jni::Object<>>> Converter<jni::Local<jni::Object<>>, std::string>::operator()(jni::JNIEnv& env, const std::string& value) const {
-    return jni::Make<jni::String>(env, value);
-}
-
-Result<jni::Local<jni::Object<>>> Converter<jni::Local<jni::Object<>>, Color>::operator()(jni::JNIEnv& env, const Color& value) const {
-    return jni::Make<jni::String>(env, value.stringify());
-}
-
-Result<jni::Local<jni::Object<>>> Converter<jni::Local<jni::Object<>>, style::expression::Formatted>::operator()(jni::JNIEnv& env, const style::expression::Formatted& value) const {
-    return Formatted::New(env, value);
-}
-
-Result<jni::Local<jni::Object<>>> Converter<jni::Local<jni::Object<>>, std::vector<std::string>>::operator()(jni::JNIEnv& env, const std::vector<std::string>& value) const {
-    auto result = jni::Array<jni::String>::New(env, value.size());
-
-    for (std::size_t i = 0; i < value.size(); i++) {
-        result.Set(env, i, jni::Make<jni::String>(env, value.at(i)));
-    }
-
-    return result;
-}
-
-Result<jni::Local<jni::Object<>>> Converter<jni::Local<jni::Object<>>, std::vector<float>>::operator()(jni::JNIEnv& env, const std::vector<float>& value) const {
-    auto result = jni::Array<jni::Float>::New(env, value.size());
-
-    for (std::size_t i = 0; i < value.size(); i++) {
-        result.Set(env, i, jni::Box(env, value.at(i)));
-    }
-
-    return result;
-}
-
-Result<jni::Local<jni::Object<>>> Converter<jni::Local<jni::Object<>>, std::vector<double>>::operator()(jni::JNIEnv& env, const std::vector<double>& value) const {
-    auto result = jni::Array<jni::Double>::New(env, value.size());
-
-    for (std::size_t i = 0; i < value.size(); i++) {
-        result.Set(env, i, jni::Box(env, value.at(i)));
-    }
-
-    return result;
-}
-
-Result<jni::Local<jni::Object<>>> Converter<jni::Local<jni::Object<>>, style::expression::Image>::operator()(
-    jni::JNIEnv& env, const style::expression::Image& value) const {
-    return jni::Make<jni::String>(env, value.id());
-}
-
-Result<jni::Local<jni::Object<>>> Converter<jni::Local<jni::Object<>>, mbgl::style::Rotation>::operator()(jni::JNIEnv& env, const mbgl::style::Rotation& value) const {
-    return jni::Box(env, value.getAngle());
-}
-
-} // namespace conversion
-} // namespace style
-} // namespace mbgl