Consolidate `style::Layer` properties API

The `style::Layer` class now exposes all the properties contained at `style::LayerImpl`.
This allowed to drop `style::Layer::accept()` method usage, avoid the repeated generated code
and thus save some binary size.

This patch is a part of the layers modularization effort.

4 files changed, 45 insertions, 196 deletions

diff --git a/platform/android/src/style/layers/layer.cpp b/platform/android/src/style/layers/layer.cpp
index 5726873f40..bb543a7639 100644
--- a/platform/android/src/style/layers/layer.cpp
+++ b/platform/android/src/style/layers/layer.cpp
@@ -109,20 +109,6 @@ namespace android {
         }
     }
 
-    struct SetFilterEvaluator {
-        style::Filter filter;
-
-        void operator()(style::BackgroundLayer&) { Log::Warning(mbgl::Event::JNI, "BackgroundLayer doesn't support filters"); }
-        void operator()(style::CustomLayer&) { Log::Warning(mbgl::Event::JNI, "CustomLayer doesn't support filters"); }
-        void operator()(style::RasterLayer&) { Log::Warning(mbgl::Event::JNI, "RasterLayer doesn't support filters"); }
-        void operator()(style::HillshadeLayer&) { Log::Warning(mbgl::Event::JNI, "HillshadeLayer doesn't support filters"); }
-
-        template <class LayerType>
-        void operator()(LayerType& layer) {
-            layer.setFilter(filter);
-        }
-    };
-
     void Layer::setFilter(jni::JNIEnv& env, const jni::Array<jni::Object<>>& jfilter) {
         using namespace mbgl::style;
         using namespace mbgl::style::conversion;
@@ -134,31 +120,14 @@ namespace android {
             return;
         }
 
-        layer.accept(SetFilterEvaluator {std::move(*converted)});
+        layer.setFilter(std::move(*converted));
     }
 
-    struct GetFilterEvaluator {
-        mbgl::style::Filter noop(std::string layerType) {
-            Log::Warning(mbgl::Event::JNI, "%s doesn't support filter", layerType.c_str());
-            return {};
-        }
-
-        mbgl::style::Filter operator()(style::BackgroundLayer&) { return noop("BackgroundLayer"); }
-        mbgl::style::Filter operator()(style::CustomLayer&) { return noop("CustomLayer"); }
-        mbgl::style::Filter operator()(style::RasterLayer&) { return noop("RasterLayer"); }
-        mbgl::style::Filter operator()(style::HillshadeLayer&) { return noop("HillshadeLayer"); }
-
-        template <class LayerType>
-            mbgl::style::Filter operator()(LayerType& layer) {
-            return layer.getFilter();
-        }
-    };
-
     jni::Local<jni::Object<gson::JsonElement>> Layer::getFilter(jni::JNIEnv& env) {
         using namespace mbgl::style;
         using namespace mbgl::style::conversion;
 
-        Filter filter = layer.accept(GetFilterEvaluator());
+        Filter filter = layer.getFilter();
         if (filter.expression) {
             mbgl::Value expressionValue = (*filter.expression)->serialize();
             return gson::JsonElement::New(env, expressionValue);
@@ -167,62 +136,16 @@ namespace android {
         }
     }
 
-    struct SetSourceLayerEvaluator {
-        std::string sourceLayer;
-
-        void operator()(style::BackgroundLayer&) { Log::Warning(mbgl::Event::JNI, "BackgroundLayer doesn't support source layer"); }
-        void operator()(style::CustomLayer&) { Log::Warning(mbgl::Event::JNI, "CustomLayer doesn't support source layer"); }
-        void operator()(style::RasterLayer&) { Log::Warning(mbgl::Event::JNI, "RasterLayer doesn't support source layer"); }
-        void operator()(style::HillshadeLayer&) { Log::Warning(mbgl::Event::JNI, "HillshadeLayer doesn't support source layer"); }
-
-        template <class LayerType>
-        void operator()(LayerType& layer) {
-            layer.setSourceLayer(sourceLayer);
-        }
-    };
-
     void Layer::setSourceLayer(jni::JNIEnv& env, const jni::String& sourceLayer) {
-        layer.accept(SetSourceLayerEvaluator {jni::Make<std::string>(env, sourceLayer)});
+        layer.setSourceLayer(jni::Make<std::string>(env, sourceLayer));
     }
 
-    struct GetSourceLayerEvaluator {
-        std::string noop(std::string layerType) {
-            Log::Warning(mbgl::Event::JNI, "%s doesn't support source layer", layerType.c_str());
-            return {};
-        }
-
-        std::string operator()(style::BackgroundLayer&) { return noop("BackgroundLayer"); }
-        std::string operator()(style::CustomLayer&) { return noop("CustomLayer"); }
-        std::string operator()(style::RasterLayer&) { return noop("RasterLayer"); }
-        std::string operator()(style::HillshadeLayer&) { return noop("HillshadeLayer"); }
-
-        template <class LayerType>
-        std::string operator()(LayerType& layer) {
-            return layer.getSourceLayer();
-        }
-    };
-
     jni::Local<jni::String> Layer::getSourceLayer(jni::JNIEnv& env) {
-        return jni::Make<jni::String>(env, layer.accept(GetSourceLayerEvaluator()));
+        return jni::Make<jni::String>(env, layer.getSourceLayer());
     }
 
-    struct GetSourceIdEvaluator {
-        std::string noop(std::string layerType) {
-            Log::Warning(mbgl::Event::JNI, "%s doesn't support get source id", layerType.c_str());
-            return {};
-        }
-
-        std::string operator()(style::BackgroundLayer&) { return noop("BackgroundLayer"); }
-        std::string operator()(style::CustomLayer&) { return noop("CustomLayer"); }
-
-        template <class LayerType>
-        std::string operator()(LayerType& layer) {
-            return layer.getSourceID();
-        }
-    };
-
     jni::Local<jni::String> Layer::getSourceId(jni::JNIEnv& env) {
-        return jni::Make<jni::String>(env, layer.accept(GetSourceIdEvaluator()));
+        return jni::Make<jni::String>(env, layer.getSourceID());
     }
 
     jni::jfloat Layer::getMinZoom(jni::JNIEnv&){
diff --git a/platform/android/src/style/layers/layers.cpp b/platform/android/src/style/layers/layers.cpp
index 232e92a7c7..c0a3acdf42 100644
--- a/platform/android/src/style/layers/layers.cpp
+++ b/platform/android/src/style/layers/layers.cpp
@@ -26,66 +26,58 @@
 #include "fill_extrusion_layer.hpp"
 
 namespace mbgl {
-namespace android {
-
-// Mapping from style layers to peer classes
-template <class> struct PeerType {};
-template <> struct PeerType<style::BackgroundLayer> { using Type = android::BackgroundLayer; };
-template <> struct PeerType<style::CircleLayer> { using Type = android::CircleLayer; };
-template <> struct PeerType<style::FillExtrusionLayer> { using Type = android::FillExtrusionLayer; };
-template <> struct PeerType<style::FillLayer> { using Type = android::FillLayer; };
-template <> struct PeerType<style::HeatmapLayer> { using Type = android::HeatmapLayer; };
-template <> struct PeerType<style::HillshadeLayer> { using Type = android::HillshadeLayer; };
-template <> struct PeerType<style::LineLayer> { using Type = android::LineLayer; };
-template <> struct PeerType<style::RasterLayer> { using Type = android::RasterLayer; };
-template <> struct PeerType<style::SymbolLayer> { using Type = android::SymbolLayer; };
-template <> struct PeerType<style::CustomLayer> { using Type = android::CustomLayer; };
 
-// Inititalizes a non-owning peer
-struct LayerPeerIntitializer {
-    mbgl::Map& map;
-
-    template <class LayerType>
-    Layer* operator()(LayerType& layer) {
-        return new typename PeerType<LayerType>::Type(map, layer);
-    }
-};
+namespace android {
 
-static Layer* initializeLayerPeer(mbgl::Map& map, mbgl::style::Layer& coreLayer) {
-    Layer* layer = coreLayer.accept(LayerPeerIntitializer {map});
-    return layer ? layer : new UnknownLayer(map, coreLayer);
+template <typename T>
+inline std::unique_ptr<T> to(std::unique_ptr<style::Layer> layer) {
+    return std::unique_ptr<T>(layer.release()->as<T>());
 }
 
-// Initializes an owning peer
-// Only usable once since it needs to pass on ownership
-// of the given layer and thus enforced to be an rvalue
-struct UniqueLayerPeerIntitializer {
-    mbgl::Map& map;
-    std::unique_ptr<style::Layer> layer;
+template <typename T>
+inline T& to(style::Layer& layer) {
+    return *layer.as<T>();
+}
 
-    template <class LayerType>
-    Layer* operator()(LayerType&) && {
-        return new typename PeerType<LayerType>::Type(
-                map,
-                std::unique_ptr<LayerType>(layer.release()->as<LayerType>())
-        );
+template <typename T>
+std::unique_ptr<Layer> initializeLayerPeer(Map& map, style::LayerType type, T&& layer) {
+    switch (type) {
+    case style::LayerType::Fill:
+        return std::unique_ptr<Layer>(new FillLayer(map, to<style::FillLayer>(std::forward<T>(layer))));
+    case style::LayerType::Line:
+        return std::unique_ptr<Layer>(new LineLayer(map, to<style::LineLayer>(std::forward<T>(layer))));
+    case style::LayerType::Circle:
+        return std::unique_ptr<Layer>(new CircleLayer(map, to<style::CircleLayer>(std::forward<T>(layer))));
+    case style::LayerType::Symbol:
+        return std::unique_ptr<Layer>(new SymbolLayer(map, to<style::SymbolLayer>(std::forward<T>(layer))));
+    case style::LayerType::Raster:
+        return std::unique_ptr<Layer>(new RasterLayer(map, to<style::RasterLayer>(std::forward<T>(layer))));
+    case style::LayerType::Background:
+        return std::unique_ptr<Layer>(new BackgroundLayer(map, to<style::BackgroundLayer>(std::forward<T>(layer))));
+    case style::LayerType::Hillshade:
+        return std::unique_ptr<Layer>(new HillshadeLayer(map, to<style::HillshadeLayer>(std::forward<T>(layer))));
+    case style::LayerType::Custom:
+        return std::unique_ptr<Layer>(new CustomLayer(map, to<style::CustomLayer>(std::forward<T>(layer))));
+    case style::LayerType::FillExtrusion:
+        return std::unique_ptr<Layer>(new FillExtrusionLayer(map, to<style::FillExtrusionLayer>(std::forward<T>(layer))));
+    case style::LayerType::Heatmap:
+        return std::unique_ptr<Layer>(new HeatmapLayer(map, to<style::HeatmapLayer>(std::forward<T>(layer))));
     }
-};
-
-static Layer* initializeLayerPeer(Map& map, std::unique_ptr<mbgl::style::Layer> coreLayer) {
-    Layer* layer = coreLayer->accept(UniqueLayerPeerIntitializer {map, std::move(coreLayer)});
-    return layer ? layer : new UnknownLayer(map, std::move(coreLayer));
+    // Not reachable, but placate GCC.
+    assert(false);
+    return std::unique_ptr<Layer>(new UnknownLayer(map, std::forward<T>(layer)));
 }
 
 jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv& env, Map& map, style::Layer& coreLayer) {
-    std::unique_ptr<Layer> peerLayer = std::unique_ptr<Layer>(initializeLayerPeer(map, coreLayer));
+    std::unique_ptr<Layer> peerLayer = initializeLayerPeer(map, coreLayer.getType(), coreLayer);
     jni::Local<jni::Object<Layer>> result = peerLayer->createJavaPeer(env);
     peerLayer.release();
     return result;
 }
 
 jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv& env, mbgl::Map& map, std::unique_ptr<mbgl::style::Layer> coreLayer) {
-    std::unique_ptr<Layer> peerLayer = std::unique_ptr<Layer>(initializeLayerPeer(map, std::move(coreLayer)));
+    auto type = coreLayer->getType();
+    std::unique_ptr<Layer> peerLayer = initializeLayerPeer(map, type, std::move(coreLayer));
     jni::Local<jni::Object<Layer>> result = peerLayer->createJavaPeer(env);
     peerLayer.release();
     return result;
diff --git a/platform/node/src/node_map.cpp b/platform/node/src/node_map.cpp
index 5693edbd03..6dccdf5292 100644
--- a/platform/node/src/node_map.cpp
+++ b/platform/node/src/node_map.cpp
@@ -892,31 +892,6 @@ void NodeMap::SetPaintProperty(const Nan::FunctionCallbackInfo<v8::Value>& info)
     info.GetReturnValue().SetUndefined();
 }
 
-struct SetFilterVisitor {
-    mbgl::style::Filter& filter;
-
-    void operator()(mbgl::style::CustomLayer&) {
-        Nan::ThrowTypeError("layer doesn't support filters");
-    }
-
-    void operator()(mbgl::style::RasterLayer&) {
-        Nan::ThrowTypeError("layer doesn't support filters");
-    }
-
-    void operator()(mbgl::style::HillshadeLayer&) {
-        Nan::ThrowTypeError("layer doesn't support filters");
-    }
-
-    void operator()(mbgl::style::BackgroundLayer&) {
-        Nan::ThrowTypeError("layer doesn't support filters");
-    }
-
-    template <class VectorLayer>
-    void operator()(VectorLayer& layer) {
-        layer.setFilter(filter);
-    }
-};
-
 void NodeMap::SetFilter(const Nan::FunctionCallbackInfo<v8::Value>& info) {
     using namespace mbgl::style;
     using namespace mbgl::style::conversion;
@@ -949,7 +924,7 @@ void NodeMap::SetFilter(const Nan::FunctionCallbackInfo<v8::Value>& info) {
         filter = std::move(*converted);
     }
 
-    layer->accept(SetFilterVisitor { filter });
+    layer->setFilter(filter);
 }
 
 void NodeMap::SetCenter(const Nan::FunctionCallbackInfo<v8::Value>& info) {
diff --git a/platform/qt/src/qmapboxgl.cpp b/platform/qt/src/qmapboxgl.cpp
index ceed411ca3..d008ad86c9 100644
--- a/platform/qt/src/qmapboxgl.cpp
+++ b/platform/qt/src/qmapboxgl.cpp
@@ -1533,38 +1533,14 @@ void QMapboxGL::setFilter(const QString& layer, const QVariant& filter)
         return;
     }
 
-    Filter filter_;
-
     Error error;
     mbgl::optional<Filter> converted = convert<Filter>(filter, error);
     if (!converted) {
         qWarning() << "Error parsing filter:" << error.message.c_str();
         return;
     }
-    filter_ = std::move(*converted);
-
-    if (layer_->is<FillLayer>()) {
-        layer_->as<FillLayer>()->setFilter(filter_);
-        return;
-    }
-    if (layer_->is<LineLayer>()) {
-        layer_->as<LineLayer>()->setFilter(filter_);
-        return;
-    }
-    if (layer_->is<SymbolLayer>()) {
-        layer_->as<SymbolLayer>()->setFilter(filter_);
-        return;
-    }
-    if (layer_->is<CircleLayer>()) {
-        layer_->as<CircleLayer>()->setFilter(filter_);
-        return;
-    }
-    if (layer_->is<FillExtrusionLayer>()) {
-        layer_->as<FillExtrusionLayer>()->setFilter(filter_);
-        return;
-    }
 
-    qWarning() << "Layer doesn't support filters";
+    layer_->setFilter(std::move(*converted));
 }
 
 QVariant QVariantFromValue(const mbgl::Value &value) {
@@ -1617,24 +1593,7 @@ QVariant QMapboxGL::getFilter(const QString &layer)  const {
         return QVariant();
     }
 
-    Filter filter_;
-
-    if (layer_->is<FillLayer>()) {
-        filter_ = layer_->as<FillLayer>()->getFilter();
-    } else if (layer_->is<LineLayer>()) {
-        filter_ = layer_->as<LineLayer>()->getFilter();
-    } else if (layer_->is<SymbolLayer>()) {
-        filter_ = layer_->as<SymbolLayer>()->getFilter();
-    } else if (layer_->is<CircleLayer>()) {
-        filter_ = layer_->as<CircleLayer>()->getFilter();
-    } else if (layer_->is<FillExtrusionLayer>()) {
-        filter_ = layer_->as<FillExtrusionLayer>()->getFilter();
-    } else {
-        qWarning() << "Layer doesn't support filters";
-        return QVariant();
-    }
-
-    auto serialized = filter_.serialize();
+    auto serialized = layer_->getFilter().serialize();
     return QVariantFromValue(serialized);
 }