Extract InterpolateBase to de-templatize findZoomCurve

8 files changed, 99 insertions, 79 deletions

diff --git a/cmake/core-files.cmake b/cmake/core-files.cmake
index 9a9236d363..409c004762 100644
--- a/cmake/core-files.cmake
+++ b/cmake/core-files.cmake
@@ -426,6 +426,7 @@ set(MBGL_CORE_FILES
     src/mbgl/style/expression/coalesce.cpp
     src/mbgl/style/expression/coercion.cpp
     src/mbgl/style/expression/compound_expression.cpp
+    src/mbgl/style/expression/find_zoom_curve.cpp
     src/mbgl/style/expression/get_covering_stops.cpp
     src/mbgl/style/expression/interpolate.cpp
     src/mbgl/style/expression/is_constant.cpp
diff --git a/include/mbgl/style/conversion/data_driven_property_value.hpp b/include/mbgl/style/conversion/data_driven_property_value.hpp
index 37acb3f775..13e196a772 100644
--- a/include/mbgl/style/conversion/data_driven_property_value.hpp
+++ b/include/mbgl/style/conversion/data_driven_property_value.hpp
@@ -34,7 +34,7 @@ struct Converter<DataDrivenPropertyValue<T>> {
             
             bool zoomConstant = isZoomConstant(**expression);
             
-            if (!zoomConstant && !findZoomCurve<typename CameraFunction<T>::ExpressionType>(expression->get())) {
+            if (!zoomConstant && !findZoomCurve(expression->get())) {
                 error = { R"("zoom" expression may only be used as input to a top-level "step" or "interpolate" expression.)" };
                 return {};
             }
diff --git a/include/mbgl/style/conversion/property_value.hpp b/include/mbgl/style/conversion/property_value.hpp
index 50382b74d3..e65c110c71 100644
--- a/include/mbgl/style/conversion/property_value.hpp
+++ b/include/mbgl/style/conversion/property_value.hpp
@@ -25,7 +25,7 @@ struct Converter<PropertyValue<T>> {
                 return {};
             }
             if (isFeatureConstant(**expression)) {
-                if (!isZoomConstant(**expression) && !findZoomCurve<typename CameraFunction<T>::ExpressionType>(expression->get())) {
+                if (!isZoomConstant(**expression) && !findZoomCurve(expression->get())) {
                     error = { R"("zoom" expression may only be used as input to a top-level "step" or "interpolate" expression.)" };
                     return {};
                 }
diff --git a/include/mbgl/style/expression/find_zoom_curve.hpp b/include/mbgl/style/expression/find_zoom_curve.hpp
index 81a4951bf5..e7dbfa1040 100644
--- a/include/mbgl/style/expression/find_zoom_curve.hpp
+++ b/include/mbgl/style/expression/find_zoom_curve.hpp
@@ -1,9 +1,7 @@
 #pragma once
 
+#include <mbgl/style/expression/interpolate.hpp>
 #include <mbgl/style/expression/step.hpp>
-#include <mbgl/style/expression/compound_expression.hpp>
-#include <mbgl/style/expression/let.hpp>
-#include <mbgl/style/expression/coalesce.hpp>
 
 #include <mbgl/util/variant.hpp>
 #include <mbgl/util/optional.hpp>
@@ -12,38 +10,7 @@ namespace mbgl {
 namespace style {
 namespace expression {
 
-template <typename T>
-optional<variant<Interpolate<T>*, Step*>> findZoomCurve(expression::Expression* e) {
-    if (auto curve = dynamic_cast<Interpolate<T>*>(e)) {
-        auto z = dynamic_cast<CompoundExpressionBase*>(curve->getInput().get());
-        if (z && z->getName() == "zoom") {
-            return {curve};
-        } else {
-            return optional<variant<Interpolate<T>*, Step*>>();
-        }
-    } else if (auto step = dynamic_cast<Step*>(e)) {
-        auto z = dynamic_cast<CompoundExpressionBase*>(step->getInput().get());
-        if (z && z->getName() == "zoom") {
-            return {step};
-        } else {
-            return optional<variant<Interpolate<T>*, Step*>>();
-        }
-    } else if (auto let = dynamic_cast<Let*>(e)) {
-        return findZoomCurve<T>(let->getResult());
-    } else if (auto coalesce = dynamic_cast<Coalesce*>(e)) {
-        std::size_t length = coalesce->getLength();
-        for (std::size_t i = 0; i < length; i++) {
-            optional<variant<Interpolate<T>*, Step*>> childInterpolate = findZoomCurve<T>(coalesce->getChild(i));
-            if (!childInterpolate) {
-                continue;
-            } else {
-                return childInterpolate;
-            }
-        }
-    }
-
-    return optional<variant<Interpolate<T>*, Step*>>();
-}
+optional<variant<InterpolateBase*, Step*>> findZoomCurve(expression::Expression* e);
 
 } // namespace expression
 } // namespace style
diff --git a/include/mbgl/style/expression/interpolate.hpp b/include/mbgl/style/expression/interpolate.hpp
index b848265c1b..b000633f5d 100644
--- a/include/mbgl/style/expression/interpolate.hpp
+++ b/include/mbgl/style/expression/interpolate.hpp
@@ -17,7 +17,6 @@ namespace mbgl {
 namespace style {
 namespace expression {
 
-
 class ExponentialInterpolator {
 public:
     ExponentialInterpolator(double base_) : base(base_) {}
@@ -56,13 +55,11 @@ public:
 
 ParseResult parseInterpolate(const mbgl::style::conversion::Convertible& value, ParsingContext& ctx);
 
-
-template <typename T>
-class Interpolate : public Expression {
+class InterpolateBase : public Expression {
 public:
     using Interpolator = variant<ExponentialInterpolator, CubicBezierInterpolator>;
-    
-    Interpolate(const type::Type& type_,
+
+    InterpolateBase(const type::Type& type_,
           Interpolator interpolator_,
           std::unique_ptr<Expression> input_,
           std::map<double, std::unique_ptr<Expression>> stops_
@@ -70,6 +67,42 @@ public:
         interpolator(std::move(interpolator_)),
         input(std::move(input_)),
         stops(std::move(stops_))
+    {}
+
+    const std::unique_ptr<Expression>& getInput() const { return input; }
+
+    void eachChild(const std::function<void(const Expression&)>& visit) const override {
+        visit(*input);
+        for (auto it = stops.begin(); it != stops.end(); it++) {
+            visit(*(it->second));
+        }
+    }
+    
+    // Return the smallest range of stops that covers the interval [lower, upper]
+    Range<float> getCoveringStops(const double lower, const double upper) const {
+        return ::mbgl::style::expression::getCoveringStops(stops, lower, upper);
+    }
+    
+    double interpolationFactor(const Range<double>& inputLevels, const double inputValue) const {
+        return interpolator.match(
+            [&](const auto& interp) { return interp.interpolationFactor(inputLevels, inputValue); }
+        );
+    }
+
+protected:
+    const Interpolator interpolator;
+    const std::unique_ptr<Expression> input;
+    const std::map<double, std::unique_ptr<Expression>> stops;
+};
+
+template <typename T>
+class Interpolate : public InterpolateBase {
+public:
+    Interpolate(type::Type type_,
+          Interpolator interpolator_,
+          std::unique_ptr<Expression> input_,
+          std::map<double, std::unique_ptr<Expression>> stops_
+    ) : InterpolateBase(std::move(type_), std::move(interpolator_), std::move(input_), std::move(stops_))
     {
         static_assert(util::Interpolatable<T>::value, "Interpolate expression requires an interpolatable value type.");
     }
@@ -109,14 +142,6 @@ public:
 
             return interpolate({*lower, *upper}, t);
         }
-        
-    }
-    
-    void eachChild(const std::function<void(const Expression&)>& visit) const override {
-        visit(*input);
-        for (auto it = stops.begin(); it != stops.end(); it++) {
-            visit(*(it->second));
-        }
     }
     
     bool operator==(const Expression& e) const override {
@@ -132,19 +157,7 @@ public:
         }
         return false;
     }
-    
-    const std::unique_ptr<Expression>& getInput() const { return input; }
 
-    // Return the smallest range of stops that covers the interval [lower, upper]
-    Range<float> getCoveringStops(const double lower, const double upper) const {
-        return ::mbgl::style::expression::getCoveringStops(stops, lower, upper);
-    }
-    
-    double interpolationFactor(const Range<double>& inputLevels, const double inputValue) const {
-        return interpolator.match(
-            [&](const auto& interp) { return interp.interpolationFactor(inputLevels, inputValue); }
-        );
-    }
     
 private:
     static EvaluationResult interpolate(const Range<Value>& outputs, const double t) {
@@ -167,10 +180,6 @@ private:
         T result = util::interpolate(*lower, *upper, t);
         return toExpressionValue(result);
     }
-    
-    const Interpolator interpolator;
-    const std::unique_ptr<Expression> input;
-    const std::map<double, std::unique_ptr<Expression>> stops;
 };
 
 } // namespace expression
diff --git a/include/mbgl/style/function/camera_function.hpp b/include/mbgl/style/function/camera_function.hpp
index 3391ec1523..47b062558c 100644
--- a/include/mbgl/style/function/camera_function.hpp
+++ b/include/mbgl/style/function/camera_function.hpp
@@ -19,8 +19,6 @@ namespace style {
 template <class T>
 class CameraFunction {
 public:
-    using ExpressionType = typename expression::ValueConverter<T>::ExpressionType;
-    
     using Stops = std::conditional_t<
         util::Interpolatable<T>::value,
         variant<
@@ -31,7 +29,7 @@ public:
     
     CameraFunction(std::unique_ptr<expression::Expression> expression_)
         : expression(std::move(expression_)),
-          zoomCurve(*expression::findZoomCurve<ExpressionType>(expression.get()))
+          zoomCurve(*expression::findZoomCurve(expression.get()))
     {
         assert(!expression::isZoomConstant(*expression));
         assert(expression::isFeatureConstant(*expression));
@@ -42,7 +40,7 @@ public:
           expression(stops.match([&] (const auto& s) {
             return expression::Convert::toExpression(s);
           })),
-          zoomCurve(*expression::findZoomCurve<ExpressionType>(expression.get()))
+          zoomCurve(*expression::findZoomCurve(expression.get()))
     {}
 
     T evaluate(float zoom) const {
@@ -56,7 +54,7 @@ public:
     
     float interpolationFactor(const Range<float>& inputLevels, const float inputValue) const {
         return zoomCurve.match(
-            [&](expression::Interpolate<ExpressionType>* z) {
+            [&](expression::InterpolateBase* z) {
                 return z->interpolationFactor(Range<double> { inputLevels.min, inputLevels.max }, inputValue);
             },
             [&](expression::Step*) { return 0.0f; }
@@ -81,7 +79,7 @@ public:
 
 private:
     std::shared_ptr<expression::Expression> expression;
-    const variant<expression::Interpolate<ExpressionType>*, expression::Step*> zoomCurve;
+    const variant<expression::InterpolateBase*, expression::Step*> zoomCurve;
 };
 
 } // namespace style
diff --git a/include/mbgl/style/function/composite_function.hpp b/include/mbgl/style/function/composite_function.hpp
index 89b7a0a237..cde1598e7d 100644
--- a/include/mbgl/style/function/composite_function.hpp
+++ b/include/mbgl/style/function/composite_function.hpp
@@ -50,11 +50,9 @@ public:
             CompositeIntervalStops<T>,
             CompositeCategoricalStops<T>>>;
 
-    using ExpressionType = typename expression::ValueConverter<T>::ExpressionType;
-
     CompositeFunction(std::unique_ptr<expression::Expression> expression_)
     :   expression(std::move(expression_)),
-        zoomCurve(*expression::findZoomCurve<ExpressionType>(expression.get()))
+        zoomCurve(*expression::findZoomCurve(expression.get()))
     {
         assert(!expression::isZoomConstant(*expression));
         assert(!expression::isFeatureConstant(*expression));
@@ -67,7 +65,7 @@ public:
         expression(stops.match([&] (const auto& s) {
             return expression::Convert::toExpression(property, s);
         })),
-        zoomCurve(*expression::findZoomCurve<ExpressionType>(expression.get()))
+        zoomCurve(*expression::findZoomCurve(expression.get()))
     {}
 
     // Return the range obtained by evaluating the function at each of the zoom levels in zoomRange
@@ -91,7 +89,7 @@ public:
     
     float interpolationFactor(const Range<float>& inputLevels, const float inputValue) const {
         return zoomCurve.match(
-            [&](expression::Interpolate<ExpressionType>* z) {
+            [&](expression::InterpolateBase* z) {
                 return z->interpolationFactor(Range<double> { inputLevels.min, inputLevels.max }, inputValue);
             },
             [&](expression::Step*) { return 0.0f; }
@@ -116,7 +114,7 @@ public:
     
 private:
     std::shared_ptr<expression::Expression> expression;
-    const variant<expression::Interpolate<ExpressionType>*, expression::Step*> zoomCurve;
+    const variant<expression::InterpolateBase*, expression::Step*> zoomCurve;
 };
 
 } // namespace style
diff --git a/src/mbgl/style/expression/find_zoom_curve.cpp b/src/mbgl/style/expression/find_zoom_curve.cpp
new file mode 100644
index 0000000000..9ee8257777
--- /dev/null
+++ b/src/mbgl/style/expression/find_zoom_curve.cpp
@@ -0,0 +1,47 @@
+#include <mbgl/style/expression/find_zoom_curve.hpp>
+#include <mbgl/style/expression/compound_expression.hpp>
+#include <mbgl/style/expression/let.hpp>
+#include <mbgl/style/expression/coalesce.hpp>
+
+#include <mbgl/util/variant.hpp>
+#include <mbgl/util/optional.hpp>
+
+namespace mbgl {
+namespace style {
+namespace expression {
+
+optional<variant<InterpolateBase*, Step*>> findZoomCurve(expression::Expression* e) {
+    if (auto curve = dynamic_cast<InterpolateBase*>(e)) {
+        auto z = dynamic_cast<CompoundExpressionBase*>(curve->getInput().get());
+        if (z && z->getName() == "zoom") {
+            return {curve};
+        } else {
+            return optional<variant<InterpolateBase*, Step*>>();
+        }
+    } else if (auto step = dynamic_cast<Step*>(e)) {
+        auto z = dynamic_cast<CompoundExpressionBase*>(step->getInput().get());
+        if (z && z->getName() == "zoom") {
+            return {step};
+        } else {
+            return optional<variant<InterpolateBase*, Step*>>();
+        }
+    } else if (auto let = dynamic_cast<Let*>(e)) {
+        return findZoomCurve(let->getResult());
+    } else if (auto coalesce = dynamic_cast<Coalesce*>(e)) {
+        std::size_t length = coalesce->getLength();
+        for (std::size_t i = 0; i < length; i++) {
+            optional<variant<InterpolateBase*, Step*>> childInterpolate = findZoomCurve(coalesce->getChild(i));
+            if (!childInterpolate) {
+                continue;
+            } else {
+                return childInterpolate;
+            }
+        }
+    }
+
+    return optional<variant<InterpolateBase*, Step*>>();
+}
+
+} // namespace expression
+} // namespace style
+} // namespace mbgl