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

package/platform/android/MapboxGLAndroidSDK/src/cpp/style/layers/layer.cpp.ejs

@@ -1,139 +0,0 @@
-<%
-  const type = locals.type;
-  const properties = locals.properties;
--%>
-// This file is generated. Edit scripts/generate-style-code.js, then run `make style-code`.
-
-#include "<%- type.replace('-', '_') %>_layer.hpp"
-
-#include <string>
-
-#include "../conversion/property_value.hpp"
-#include "../conversion/transition_options.hpp"
-
-#include <mbgl/style/layer_impl.hpp>
-
-namespace mbgl {
-namespace android {
-
-    inline mbgl::style::<%- camelize(type) %>Layer& to<%- camelize(type) %>Layer(mbgl::style::Layer& layer) {
-        return static_cast<mbgl::style::<%- camelize(type) %>Layer&>(layer);
-    }
-
-<% if (type === 'background' || type === 'location-indicator') { -%>
-    /**
-     * Creates an owning peer object (for layers not attached to the map) from the JVM side
-     */
-    <%- camelize(type) %>Layer::<%- camelize(type) %>Layer(jni::JNIEnv& env, jni::String& layerId)
-        : Layer(std::make_unique<mbgl::style::<%- camelize(type) %>Layer>(jni::Make<std::string>(env, layerId))) {
-<% } else { -%>
-    /**
-     * Creates an owning peer object (for layers not attached to the map) from the JVM side
-     */
-    <%- camelize(type) %>Layer::<%- camelize(type) %>Layer(jni::JNIEnv& env, jni::String& layerId, jni::String& sourceId)
-        : Layer(std::make_unique<mbgl::style::<%- camelize(type) %>Layer>(jni::Make<std::string>(env, layerId), jni::Make<std::string>(env, sourceId))) {
-<% } -%>
-    }
-
-    /**
-     * Creates a non-owning peer object (for layers currently attached to the map)
-     */
-    <%- camelize(type) %>Layer::<%- camelize(type) %>Layer(mbgl::style::<%- camelize(type) %>Layer& coreLayer)
-        : Layer(coreLayer) {
-    }
-
-    /**
-     * Creates an owning peer object (for layers not attached to the map)
-     */
-    <%- camelize(type) %>Layer::<%- camelize(type) %>Layer(std::unique_ptr<mbgl::style::<%- camelize(type) %>Layer> coreLayer)
-        : Layer(std::move(coreLayer)) {
-    }
-
-    <%- camelize(type) %>Layer::~<%- camelize(type) %>Layer() = default;
-
-    // Property getters
-
-<% for (const property of properties) { -%>
-<% if (property.name != 'heatmap-color') { -%>
-    jni::Local<jni::Object<>> <%- camelize(type) %>Layer::get<%- camelize(property.name) %>(jni::JNIEnv& env) {
-        using namespace mbgl::android::conversion;
-        return std::move(*convert<jni::Local<jni::Object<>>>(env, to<%- camelize(type) %>Layer(layer).get<%- camelize(property.name) %>()));
-    }
-
-<% } else { -%>
-    jni::Local<jni::Object<>> HeatmapLayer::getHeatmapColor(jni::JNIEnv& env) {
-        using namespace mbgl::android::conversion;
-        auto propertyValue =  to<%- camelize(type) %>Layer(layer).getHeatmapColor();
-        if (propertyValue.isUndefined()) {
-            propertyValue =  to<%- camelize(type) %>Layer(layer).getDefaultHeatmapColor();
-        }
-        return std::move(*convert<jni::Local<jni::Object<>>>(env, propertyValue));
-    }
-
-<% } -%>
-<% if (property.transition) { -%>
-    jni::Local<jni::Object<TransitionOptions>> <%- camelize(type) %>Layer::get<%- camelize(property.name) %>Transition(jni::JNIEnv& env) {
-        using namespace mbgl::android::conversion;
-        mbgl::style::TransitionOptions options = to<%- camelize(type) %>Layer(layer).get<%- camelize(property.name) %>Transition();
-        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
-    }
-
-    void <%- camelize(type) %>Layer::set<%- camelize(property.name) %>Transition(jni::JNIEnv&, jlong duration, jlong delay) {
-        mbgl::style::TransitionOptions options;
-        options.duration.emplace(mbgl::Milliseconds(duration));
-        options.delay.emplace(mbgl::Milliseconds(delay));
-        to<%- camelize(type) %>Layer(layer).set<%- camelize(property.name) %>Transition(options);
-    }
-
-<% } -%>
-<% } -%>
-
-    // <%- camelize(type) %>JavaLayerPeerFactory
-
-    <%- camelize(type) %>JavaLayerPeerFactory::~<%- camelize(type) %>JavaLayerPeerFactory() = default;
-
-    namespace {
-        jni::Local<jni::Object<Layer>> createJavaPeer(jni::JNIEnv& env, Layer* layer) {
-            static auto& javaClass = jni::Class<<%- camelize(type) %>Layer>::Singleton(env);
-            static auto constructor = javaClass.GetConstructor<jni::jlong>(env);
-            return javaClass.New(env, constructor, reinterpret_cast<jni::jlong>(layer));
-        }
-    }  // namespace
-
-    jni::Local<jni::Object<Layer>> <%- camelize(type) %>JavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env, mbgl::style::Layer& layer) {
-        assert(layer.baseImpl->getTypeInfo() == getTypeInfo());
-        return createJavaPeer(env, new <%- camelize(type) %>Layer(to<%- camelize(type) %>Layer(layer)));
-    }
-
-    jni::Local<jni::Object<Layer>> <%- camelize(type) %>JavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env, std::unique_ptr<mbgl::style::Layer> layer) {
-        assert(layer->baseImpl->getTypeInfo() == getTypeInfo());
-        return createJavaPeer(env, new <%- camelize(type) %>Layer(std::unique_ptr<mbgl::style::<%- camelize(type) %>Layer>(static_cast<mbgl::style::<%- camelize(type) %>Layer*>(layer.release()))));
-    }
-
-    void <%- camelize(type) %>JavaLayerPeerFactory::registerNative(jni::JNIEnv& env) {
-        // Lookup the class
-        static auto& javaClass = jni::Class<<%- camelize(type) %>Layer>::Singleton(env);
-
-        #define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
-
-        // Register the peer
-        jni::RegisterNativePeer<<%- camelize(type) %>Layer>(
-            env,
-            javaClass,
-            "nativePtr",
-<% if (type === 'background' || type === 'location-indicator') { -%>
-            jni::MakePeer<<%- camelize(type) %>Layer, jni::String&>,
-<% } else { -%>
-            jni::MakePeer<<%- camelize(type) %>Layer, jni::String&, jni::String&>,
-<% } -%>
-            "initialize",
-            "finalize",<% for(var i = 0; i < properties.length; i++) {%>
-<% if (properties[i].transition) { -%>
-            METHOD(&<%- camelize(type) %>Layer::get<%- camelize(properties[i].name) %>Transition, "nativeGet<%- camelize(properties[i].name) %>Transition"),
-            METHOD(&<%- camelize(type) %>Layer::set<%- camelize(properties[i].name) %>Transition, "nativeSet<%- camelize(properties[i].name) %>Transition"),
-<% } -%>
-            METHOD(&<%- camelize(type) %>Layer::get<%- camelize(properties[i].name) %>, "nativeGet<%- camelize(properties[i].name) %>")<% if(i != (properties.length -1)) {-%>,<% } -%><% } -%>);
-    }
-
-} // namespace android
-} // namespace mbgl

package/platform/android/MapboxGLAndroidSDK/src/cpp/style/layers/layer.hpp

@@ -1,117 +0,0 @@
-#pragma once
-
-#include <mbgl/layermanager/layer_factory.hpp>
-#include <mbgl/style/layer.hpp>
-#include <mbgl/style/style.hpp>
-#include "../../gson/json_array.hpp"
-#include "../../gson/json_element.hpp"
-#include "../value.hpp"
-
-#include <jni/jni.hpp>
-
-namespace mbgl {
-
-namespace android {
-
-class Layer {
-public:
-
-    static constexpr auto Name() { return "com/mapbox/mapboxsdk/style/layers/Layer"; };
-
-    static void registerNative(jni::JNIEnv&);
-
-    virtual ~Layer();
-
-    /**
-     * Set core layer (ie return ownership after remove)
-     */
-    void setLayer(std::unique_ptr<mbgl::style::Layer>);
-
-    void addToStyle(mbgl::style::Style&, mbgl::optional<std::string>);
-
-    // Release the owned view and return it
-    std::unique_ptr<mbgl::style::Layer> releaseCoreLayer();
-
-    jni::Local<jni::String> getId(jni::JNIEnv&);
-
-    jni::Local<jni::String> getSourceId(jni::JNIEnv&);
-
-    style::Layer& get();
-
-    void setProperty(jni::JNIEnv&, const jni::String&, const jni::Object<>& value);
-
-    // Zoom
-
-    jni::jfloat getMinZoom(jni::JNIEnv&);
-
-    jni::jfloat getMaxZoom(jni::JNIEnv&);
-
-    void setMinZoom(jni::JNIEnv&, jni::jfloat zoom);
-
-    void setMaxZoom(jni::JNIEnv&, jni::jfloat zoom);
-
-    /* common properties, but not shared by all */
-
-    void setFilter(jni::JNIEnv&, const jni::Array<jni::Object<>>&);
-
-    jni::Local<jni::Object<gson::JsonElement>> getFilter(jni::JNIEnv&);
-
-    void setSourceLayer(jni::JNIEnv&, const jni::String&);
-
-    jni::Local<jni::String> getSourceLayer(jni::JNIEnv&);
-
-    // Property getters
-
-    jni::Local<jni::Object<jni::ObjectTag>> getVisibility(jni::JNIEnv&);
-
-protected:
-    /*
-     * Called when a non-owning peer object is created on the c++ side
-     */
-    Layer(mbgl::style::Layer&);
-
-    /*
-     * Called when a owning peer object is created on the c++ side
-     */
-    Layer(std::unique_ptr<mbgl::style::Layer>);
-
-    // Owned layer is set when creating a new layer, before adding it to the map
-    std::unique_ptr<mbgl::style::Layer> ownedLayer;
-
-    // Raw reference to the layer
-    mbgl::style::Layer& layer;
-};
-
-/**
- * @brief A factory class for a layer Java peer objects of a certain type.
- */
-class JavaLayerPeerFactory {
-public:
-    virtual ~JavaLayerPeerFactory() = default;
-    /**
-     * @brief Create a non-owning peer.
-     */
-    virtual jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv&, mbgl::style::Layer&) = 0;
-
-    /**
-     * @brief Create an owning peer.
-     */
-    virtual jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv& env,
-                                                               std::unique_ptr<mbgl::style::Layer>) = 0;
-
-    /**
-     * @brief Register peer methods.
-     */
-    virtual void registerNative(jni::JNIEnv&) = 0;
-
-    /**
-     * @brief Get the corresponding layer factory.
-     * 
-     * @return style::LayerFactory* must not be \c nullptr.
-     */
-    virtual LayerFactory* getLayerFactory() = 0;
-};
-
-
-} // namespace android
-} // namespace mbgl

package/platform/android/MapboxGLAndroidSDK/src/cpp/style/layers/layer.hpp.ejs

@@ -1,66 +0,0 @@
-<%
-  const type = locals.type;
-  const properties = locals.properties;
--%>
-// This file is generated. Edit scripts/generate-style-code.js, then run `make style-code`.
-
-#pragma once
-
-#include "layer.hpp"
-#include "../transition_options.hpp"
-#include <mbgl/layermanager/<%- type.replace('-', '_') %>_layer_factory.hpp>
-#include <mbgl/style/layers/<%- type.replace('-', '_') %>_layer.hpp>
-#include <jni/jni.hpp>
-
-namespace mbgl {
-namespace android {
-
-class <%- camelize(type) %>Layer : public Layer {
-public:
-    using SuperTag = Layer;
-<% if (type === 'location-indicator') { -%>
-    static constexpr auto Name() { return "com/mapbox/mapboxsdk/location/<%- camelize(type) %>Layer"; };
-<% } else { -%>
-    static constexpr auto Name() { return "com/mapbox/mapboxsdk/style/layers/<%- camelize(type) %>Layer"; };
-<% } -%>
-
-<% if (type === 'background' || type === 'location-indicator') { -%>
-    <%- camelize(type) %>Layer(jni::JNIEnv&, jni::String&);
-<% } else { -%>
-    <%- camelize(type) %>Layer(jni::JNIEnv&, jni::String&, jni::String&);
-<% } -%>
-
-    <%- camelize(type) %>Layer(mbgl::style::<%- camelize(type) %>Layer&);
-
-    <%- camelize(type) %>Layer(std::unique_ptr<mbgl::style::<%- camelize(type) %>Layer>);
-
-    ~<%- camelize(type) %>Layer();
-
-    // Properties
-<% for (const property of properties) { -%>
-
-    jni::Local<jni::Object<jni::ObjectTag>> get<%- camelize(property.name) %>(jni::JNIEnv&);
-<% if (property.transition) { -%>
-    void set<%- camelize(property.name) %>Transition(jni::JNIEnv&, jlong duration, jlong delay);
-    jni::Local<jni::Object<TransitionOptions>> get<%- camelize(property.name) %>Transition(jni::JNIEnv&);
-<% } -%>
-<% } -%>
-
-}; // class <%- camelize(type) %>Layer
-
-class <%- camelize(type) %>JavaLayerPeerFactory final : public JavaLayerPeerFactory,  public mbgl::<%- camelize(type) %>LayerFactory {
-public:
-    ~<%- camelize(type) %>JavaLayerPeerFactory() override;
-
-    // JavaLayerPeerFactory overrides.
-    jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv&, mbgl::style::Layer&) final;
-    jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv& env, std::unique_ptr<mbgl::style::Layer>) final;
-
-    void registerNative(jni::JNIEnv&) final;
-
-    LayerFactory* getLayerFactory() final { return this; }
-
-};  // class <%- camelize(type) %>JavaLayerPeerFactory
-
-} // namespace android
-} // namespace mbgl

package/platform/android/MapboxGLAndroidSDK/src/cpp/style/layers/layer_manager.cpp

@@ -1,177 +0,0 @@
-#include "layer_manager.hpp"
-
-#include <mbgl/style/layer_impl.hpp>
-
-#include <mbgl/style/conversion/constant.hpp>
-#include <mbgl/style/conversion/filter.hpp>
-#include <mbgl/style/conversion_impl.hpp>
-
-#include "background_layer.hpp"
-#include "circle_layer.hpp"
-#include "custom_layer.hpp"
-#include "fill_extrusion_layer.hpp"
-#include "fill_layer.hpp"
-#include "heatmap_layer.hpp"
-#include "hillshade_layer.hpp"
-#include "line_layer.hpp"
-#include "raster_layer.hpp"
-#include "symbol_layer.hpp"
-#include "fill_extrusion_layer.hpp"
-#include "location_indicator_layer.hpp"
-
-namespace mbgl {
-
-namespace android {
-
-LayerManagerAndroid::LayerManagerAndroid() {
-#if defined(MBGL_LAYER_FILL_DISABLE_RUNTIME)
-    addLayerTypeCoreOnly(std::make_unique<FillLayerFactory>());
-#elif !defined(MBGL_LAYER_FILL_DISABLE_ALL)
-    addLayerType(std::make_unique<FillJavaLayerPeerFactory>());
-#endif
-#if defined(MBGL_LAYER_LINE_DISABLE_RUNTIME)
-    addLayerTypeCoreOnly(std::make_unique<LineLayerFactory>());
-#elif !defined(MBGL_LAYER_LINE_DISABLE_ALL)
-    addLayerType(std::make_unique<LineJavaLayerPeerFactory>());
-#endif
-#if defined(MBGL_LAYER_CIRCLE_DISABLE_RUNTIME)
-    addLayerTypeCoreOnly(std::make_unique<CircleLayerFactory>());
-#elif !defined(MBGL_LAYER_CIRCLE_DISABLE_ALL)
-    addLayerType(std::make_unique<CircleJavaLayerPeerFactory>());
-#endif
-#if defined(MBGL_LAYER_SYMBOL_DISABLE_RUNTIME)
-    addLayerTypeCoreOnly(std::make_unique<SymbolLayerFactory>());
-#elif !defined(MBGL_LAYER_SYMBOL_DISABLE_ALL)
-    addLayerType(std::make_unique<SymbolJavaLayerPeerFactory>());
-#endif
-#if defined(MBGL_LAYER_RASTER_DISABLE_RUNTIME)
-    addLayerTypeCoreOnly(std::make_unique<RasterLayerFactory>());
-#elif !defined(MBGL_LAYER_RASTER_DISABLE_ALL)
-    addLayerType(std::make_unique<RasterJavaLayerPeerFactory>());
-#endif
-#if defined(MBGL_LAYER_BACKGROUND_DISABLE_RUNTIME)
-    addLayerTypeCoreOnly(std::make_unique<BackgroundLayerFactory>());
-#elif !defined(MBGL_LAYER_BACKGROUND_DISABLE_ALL)
-    addLayerType(std::make_unique<BackgroundJavaLayerPeerFactory>());
-#endif
-#if defined(MBGL_LAYER_HILLSHADE_DISABLE_RUNTIME)
-    addLayerTypeCoreOnly(std::make_unique<HillshadeLayerFactory>());
-#elif !defined(MBGL_LAYER_HILLSHADE_DISABLE_ALL)
-    addLayerType(std::make_unique<HillshadeJavaLayerPeerFactory>());
-#endif
-#if defined(MBGL_LAYER_FILL_EXTRUSION_DISABLE_RUNTIME)
-    addLayerTypeCoreOnly(std::make_unique<FillExtrusionLayerFactory>());
-#elif !defined(MBGL_LAYER_FILL_EXTRUSION_DISABLE_ALL)
-    addLayerType(std::make_unique<FillExtrusionJavaLayerPeerFactory>());
-#endif
-#if defined(MBGL_LAYER_HEATMAP_DISABLE_RUNTIME)
-    addLayerTypeCoreOnly(std::make_unique<HeatmapLayerFactory>());
-#elif !defined(MBGL_LAYER_HEATMAP_DISABLE_ALL)
-    addLayerType(std::make_unique<HeatmapJavaLayerPeerFactory>());
-#endif
-#if defined(MBGL_LAYER_CUSTOM_DISABLE_RUNTIME)
-    addLayerTypeCoreOnly(std::make_unique<CustomLayerFactory>());
-#elif !defined(MBGL_LAYER_CUSTOM_DISABLE_ALL)
-    addLayerType(std::make_unique<CustomJavaLayerPeerFactory>());
-#endif
-#if !defined(MBGL_LAYER_LOCATION_INDICATOR_DISABLE_ALL)
-    addLayerType(std::make_unique<LocationIndicatorJavaLayerPeerFactory>());
-#endif
-}
-
-LayerManagerAndroid::~LayerManagerAndroid() = default;
-
-jni::Local<jni::Object<Layer>> LayerManagerAndroid::createJavaLayerPeer(jni::JNIEnv& env, mbgl::style::Layer& layer) {
-    if (JavaLayerPeerFactory* factory = getPeerFactory(layer.getTypeInfo())) {
-        return factory->createJavaLayerPeer(env, layer);
-    }
-    return jni::Local<jni::Object<Layer>>();
-}
-
-jni::Local<jni::Object<Layer>> LayerManagerAndroid::createJavaLayerPeer(jni::JNIEnv& env,
-                                                                        std::unique_ptr<mbgl::style::Layer> layer) {
-    if (JavaLayerPeerFactory* factory = getPeerFactory(layer->getTypeInfo())) {
-        return factory->createJavaLayerPeer(env, std::move(layer));
-    }
-    return jni::Local<jni::Object<Layer>>();
-}
-
-void LayerManagerAndroid::registerNative(jni::JNIEnv& env) {
-    if (peerFactories.empty()) {
-        return;
-    }
-
-    Layer::registerNative(env);
-    for (const auto& factory: peerFactories) {
-        factory->registerNative(env);
-    }
-}
-
-void LayerManagerAndroid::addLayerType(std::unique_ptr<JavaLayerPeerFactory> factory) {
-    assert(getFactory(factory->getLayerFactory()->getTypeInfo()) == nullptr);
-    registerCoreFactory(factory->getLayerFactory());
-    peerFactories.emplace_back(std::move(factory));
-}
-
-void LayerManagerAndroid::addLayerTypeCoreOnly(std::unique_ptr<LayerFactory> factory) {
-    assert(getFactory(factory->getTypeInfo()) == nullptr);
-    registerCoreFactory(factory.get());
-    coreFactories.emplace_back(std::move(factory));
-}
-
-void LayerManagerAndroid::registerCoreFactory(mbgl::LayerFactory* factory) {
-    std::string type{factory->getTypeInfo()->type};
-    if (!type.empty()) {
-        assert(typeToFactory.find(type) == typeToFactory.end());
-        typeToFactory.emplace(std::make_pair(std::move(type), factory));
-    }
-}
-
-JavaLayerPeerFactory* LayerManagerAndroid::getPeerFactory(const mbgl::style::LayerTypeInfo* typeInfo) {
-    assert(typeInfo);
-    for (const auto& factory: peerFactories) {
-        if (factory->getLayerFactory()->getTypeInfo() == typeInfo) {
-            return factory.get();
-        }
-    }
-    return nullptr;
-}
-
-LayerFactory* LayerManagerAndroid::getFactory(const std::string& type) noexcept {
-    auto search = typeToFactory.find(type);
-    return (search != typeToFactory.end()) ? search->second : nullptr;
-}
-
-LayerFactory* LayerManagerAndroid::getFactory(const mbgl::style::LayerTypeInfo* info) noexcept {
-    if (JavaLayerPeerFactory* peerFactory = getPeerFactory(info)) {
-        return peerFactory->getLayerFactory();
-    }
-
-    for (const auto& factory: coreFactories) {
-        if (factory->getTypeInfo() == info) {
-            return factory.get();
-        }
-    }
-
-    return nullptr;
-}
-
-// static
-LayerManagerAndroid* LayerManagerAndroid::get() noexcept {
-    static LayerManagerAndroid impl;
-    return &impl;
-}
-
-} // namespace android
-
-LayerManager* LayerManager::get() noexcept {
-    return android::LayerManagerAndroid::get();
-}
-
-#if defined(MBGL_LAYER_LINE_DISABLE_ALL) || defined(MBGL_LAYER_SYMBOL_DISABLE_ALL) || defined(MBGL_LAYER_FILL_DISABLE_ALL)
-const bool LayerManager::annotationsEnabled = false;
-#else
-const bool LayerManager::annotationsEnabled = true;
-#endif
-
-} // namespace mbgl

package/platform/android/MapboxGLAndroidSDK/src/cpp/style/layers/layer_manager.hpp

@@ -1,57 +0,0 @@
-#pragma once
-
-#include <mbgl/layermanager/layer_manager.hpp>
-#include <mbgl/map/map.hpp>
-#include <mbgl/style/layer.hpp>
-
-#include "layer.hpp"
-
-#include <jni/jni.hpp>
-
-#include <memory>
-#include <vector>
-
-namespace mbgl {
-namespace android {
-
-/**
- * @brief A singleton class forwarding calls to the corresponding  \c JavaLayerPeerFactory instance.
- */
-class LayerManagerAndroid final : public mbgl::LayerManager {
-public:
-    ~LayerManagerAndroid() final;
-    static LayerManagerAndroid* get() noexcept;
-
-    jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv&, mbgl::style::Layer&);
-    jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv& env, std::unique_ptr<mbgl::style::Layer>);
-
-    void registerNative(jni::JNIEnv&);
-
-private:
-    LayerManagerAndroid();
-    /**
-     * @brief Enables a layer type for both JSON style and runtime API.
-     */
-    void addLayerType(std::unique_ptr<JavaLayerPeerFactory>); 
-    /**
-     * @brief Enables a layer type for JSON style only.
-     *
-     * We might not want to expose runtime API for some layer types
-     * in order to save binary size - JNI glue code for these layer types
-     * won't be added to the binary. 
-     */
-    void addLayerTypeCoreOnly(std::unique_ptr<mbgl::LayerFactory>);
-
-    void registerCoreFactory(mbgl::LayerFactory*);
-    JavaLayerPeerFactory* getPeerFactory(const mbgl::style::LayerTypeInfo*);
-    // mbgl::LayerManager overrides.
-    LayerFactory* getFactory(const std::string& type) noexcept final;
-    LayerFactory* getFactory(const mbgl::style::LayerTypeInfo* info) noexcept final;
-
-    std::vector<std::unique_ptr<JavaLayerPeerFactory>> peerFactories;
-    std::vector<std::unique_ptr<mbgl::LayerFactory>> coreFactories;
-    std::map<std::string, mbgl::LayerFactory*> typeToFactory;
-};
-
-}  // namespace android
-}  // namespace mbgl