Remove stops-based *Function constructors

cmake/core-files.cmake

@@ -448,6 +448,7 @@ set(MBGL_CORE_FILES
     include/mbgl/style/expression/coalesce.hpp
     include/mbgl/style/expression/coercion.hpp
     include/mbgl/style/expression/compound_expression.hpp
+    include/mbgl/style/expression/dsl.hpp
     include/mbgl/style/expression/equals.hpp
     include/mbgl/style/expression/expression.hpp
     include/mbgl/style/expression/find_zoom_curve.hpp
@@ -473,6 +474,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/dsl.cpp
     src/mbgl/style/expression/equals.cpp
     src/mbgl/style/expression/find_zoom_curve.cpp
     src/mbgl/style/expression/get_covering_stops.cpp
@@ -502,6 +504,7 @@ set(MBGL_CORE_FILES
     include/mbgl/style/function/interval_stops.hpp
     include/mbgl/style/function/source_function.hpp
     src/mbgl/style/function/categorical_stops.cpp
+    src/mbgl/style/function/convert.cpp
     src/mbgl/style/function/expression.cpp
     src/mbgl/style/function/identity_stops.cpp
 

include/mbgl/style/conversion/function.hpp

@@ -3,9 +3,18 @@
 #include <mbgl/style/function/camera_function.hpp>
 #include <mbgl/style/function/source_function.hpp>
 #include <mbgl/style/function/composite_function.hpp>
+#include <mbgl/style/function/convert.hpp>
+#include <mbgl/style/function/categorical_stops.hpp>
+#include <mbgl/style/function/exponential_stops.hpp>
+#include <mbgl/style/function/interval_stops.hpp>
+#include <mbgl/style/function/identity_stops.hpp>
+#include <mbgl/style/function/composite_exponential_stops.hpp>
+#include <mbgl/style/function/composite_interval_stops.hpp>
+#include <mbgl/style/function/composite_categorical_stops.hpp>
 #include <mbgl/style/conversion.hpp>
 #include <mbgl/style/conversion/constant.hpp>
 #include <mbgl/util/ignore.hpp>
+#include <mbgl/util/variant.hpp>
 
 namespace mbgl {
 namespace style {
@@ -193,12 +202,22 @@ struct Converter<CameraFunction<T>> {
             return {};
         }
 
-        auto stops = StopsConverter<T, typename CameraFunction<T>::Stops>()(value, error);
+        using Stops = std::conditional_t<
+            util::Interpolatable<T>::value,
+            variant<
+                ExponentialStops<T>,
+                IntervalStops<T>>,
+            variant<
+                IntervalStops<T>>>;
+
+        auto stops = StopsConverter<T, Stops>()(value, error);
         if (!stops) {
             return {};
         }
 
-        return CameraFunction<T>(*stops);
+        return CameraFunction<T>((*stops).match([&] (const auto& s) {
+            return expression::Convert::toExpression(s);
+        }), false);
     }
 };
 
@@ -238,7 +257,19 @@ struct Converter<SourceFunction<T>> {
             return {};
         }
 
-        auto stops = StopsConverter<T, typename SourceFunction<T>::Stops>()(value, error);
+        using Stops = std::conditional_t<
+            util::Interpolatable<T>::value,
+            variant<
+                ExponentialStops<T>,
+                IntervalStops<T>,
+                CategoricalStops<T>,
+                IdentityStops<T>>,
+            variant<
+                IntervalStops<T>,
+                CategoricalStops<T>,
+                IdentityStops<T>>>;
+
+        auto stops = StopsConverter<T, Stops>()(value, error);
         if (!stops) {
             return {};
         }
@@ -248,7 +279,9 @@ struct Converter<SourceFunction<T>> {
             return {};
         }
 
-        return SourceFunction<T>(*propertyString, *stops, *defaultValue);
+        return SourceFunction<T>((*stops).match([&] (const auto& s) {
+            return expression::Convert::toExpression(*propertyString, s);
+        }), *defaultValue);
     }
 };
 
@@ -374,7 +407,17 @@ struct Converter<CompositeFunction<T>> {
             return {};
         }
 
-        auto stops = StopsConverter<T, typename CompositeFunction<T>::Stops>()(value, error);
+        using Stops = std::conditional_t<
+            util::Interpolatable<T>::value,
+            variant<
+                CompositeExponentialStops<T>,
+                CompositeIntervalStops<T>,
+                CompositeCategoricalStops<T>>,
+            variant<
+                CompositeIntervalStops<T>,
+                CompositeCategoricalStops<T>>>;
+
+        auto stops = StopsConverter<T, Stops>()(value, error);
         if (!stops) {
             return {};
         }
@@ -384,7 +427,9 @@ struct Converter<CompositeFunction<T>> {
             return {};
         }
 
-        return CompositeFunction<T>(*propertyString, *stops, *defaultValue);
+        return CompositeFunction<T>((*stops).match([&] (const auto& s) {
+            return expression::Convert::toExpression(*propertyString, s);
+        }), *defaultValue);
     }
 };
 

include/mbgl/style/expression/assertion.hpp

@@ -13,10 +13,7 @@ namespace expression {
 
 class Assertion : public Expression  {
 public:
-    Assertion(type::Type type_, std::vector<std::unique_ptr<Expression>> inputs_) :
-        Expression(type_),
-        inputs(std::move(inputs_))
-    {}
+    Assertion(type::Type type_, std::vector<std::unique_ptr<Expression>> inputs_);
 
     static ParseResult parse(const mbgl::style::conversion::Convertible& value, ParsingContext& ctx);
 

include/mbgl/style/expression/compound_expression.hpp

@@ -134,24 +134,9 @@ struct CompoundExpressionRegistry {
 
 ParseResult parseCompoundExpression(const std::string name, const mbgl::style::conversion::Convertible& value, ParsingContext& ctx);
 
-ParseResult createCompoundExpression(const CompoundExpressionRegistry::Definition& definition,
-                                     std::vector<std::unique_ptr<Expression>> args,
-                                     ParsingContext& ctx);
-
 ParseResult createCompoundExpression(const std::string& name,
                                      std::vector<std::unique_ptr<Expression>> args,
                                      ParsingContext& ctx);
-// Convenience method for use expressions that have 0, 1, or 2 args.
-ParseResult createCompoundExpression(const std::string& name, ParsingContext& ctx);
-
-ParseResult createCompoundExpression(const std::string& name,
-                                     std::unique_ptr<Expression> arg1,
-                                     ParsingContext& ctx);
-
-ParseResult createCompoundExpression(const std::string& name,
-                                     std::unique_ptr<Expression> arg1,
-                                     std::unique_ptr<Expression> arg2,
-                                     ParsingContext& ctx);
 
 } // namespace expression
 } // namespace style

include/mbgl/style/expression/dsl.hpp

@@ -0,0 +1,70 @@
+#pragma once
+
+#include <mbgl/style/expression/value.hpp>
+#include <mbgl/style/expression/expression.hpp>
+#include <mbgl/style/expression/interpolator.hpp>
+
+#include <memory>
+#include <initializer_list>
+
+namespace mbgl {
+namespace style {
+namespace expression {
+namespace dsl {
+
+// This convenience API does little to no expression validation or type-checking, and is intended for
+// use only by test and other non-production code.
+
+std::unique_ptr<Expression> literal(const char* value);
+std::unique_ptr<Expression> literal(Value value);
+std::unique_ptr<Expression> literal(std::initializer_list<double> value);
+std::unique_ptr<Expression> literal(std::initializer_list<const char *> value);
+
+std::unique_ptr<Expression> number(std::unique_ptr<Expression>);
+std::unique_ptr<Expression> string(std::unique_ptr<Expression>);
+
+std::unique_ptr<Expression> toColor(const char* value);
+std::unique_ptr<Expression> toColor(std::unique_ptr<Expression>);
+
+std::unique_ptr<Expression> get(const char* value);
+std::unique_ptr<Expression> get(std::unique_ptr<Expression>);
+
+std::unique_ptr<Expression> id();
+std::unique_ptr<Expression> zoom();
+
+std::unique_ptr<Expression> eq(std::unique_ptr<Expression>,
+                               std::unique_ptr<Expression>);
+std::unique_ptr<Expression> ne(std::unique_ptr<Expression>,
+                               std::unique_ptr<Expression>);
+std::unique_ptr<Expression> gt(std::unique_ptr<Expression>,
+                               std::unique_ptr<Expression>);
+std::unique_ptr<Expression> lt(std::unique_ptr<Expression>,
+                               std::unique_ptr<Expression>);
+
+std::unique_ptr<Expression> step(std::unique_ptr<Expression> input,
+                                 std::unique_ptr<Expression> output0,
+                                 double input1, std::unique_ptr<Expression> output1);
+
+Interpolator linear();
+Interpolator exponential(double base);
+Interpolator cubicBezier(double x1, double y1, double x2, double y2);
+
+std::unique_ptr<Expression> interpolate(Interpolator interpolator,
+                                        std::unique_ptr<Expression> input,
+                                        double input1, std::unique_ptr<Expression> output1);
+
+std::unique_ptr<Expression> interpolate(Interpolator interpolator,
+                                        std::unique_ptr<Expression> input,
+                                        double input1, std::unique_ptr<Expression> output1,
+                                        double input2, std::unique_ptr<Expression> output2);
+
+std::unique_ptr<Expression> interpolate(Interpolator interpolator,
+                                        std::unique_ptr<Expression> input,
+                                        double input1, std::unique_ptr<Expression> output1,
+                                        double input2, std::unique_ptr<Expression> output2,
+                                        double input3, std::unique_ptr<Expression> output3);
+
+} // namespace dsl
+} // namespace expression
+} // namespace style
+} // namespace mbgl

include/mbgl/style/expression/interpolate.hpp

@@ -19,14 +19,9 @@ ParseResult parseInterpolate(const mbgl::style::conversion::Convertible& value,
 class Interpolate : public Expression {
 public:
     Interpolate(const type::Type& type_,
-          Interpolator interpolator_,
-          std::unique_ptr<Expression> input_,
-          std::map<double, std::unique_ptr<Expression>> stops_
-    ) : Expression(type_),
-        interpolator(std::move(interpolator_)),
-        input(std::move(input_)),
-        stops(std::move(stops_))
-    {}
+                Interpolator interpolator_,
+                std::unique_ptr<Expression> input_,
+                std::map<double, std::unique_ptr<Expression>> stops_);
 
     const std::unique_ptr<Expression>& getInput() const { return input; }
     const Interpolator& getInterpolator() const { return interpolator; }

include/mbgl/style/expression/literal.hpp

@@ -47,13 +47,11 @@ class Literal : public Expression {
 
     mbgl::Value serialize() const override;
     std::string getOperator() const override { return "literal"; }
+
 private:
     Value value;
 };
 
-std::unique_ptr<Literal> createLiteral(const char* value);
-std::unique_ptr<Literal> createLiteral(Value value);
-
 } // namespace expression
 } // namespace style
 } // namespace mbgl

include/mbgl/style/expression/step.hpp

@@ -1,4 +1,3 @@
-
 #pragma once
 
 #include <mbgl/style/expression/expression.hpp>
@@ -10,20 +9,15 @@
 #include <memory>
 #include <map>
 
-
 namespace mbgl {
 namespace style {
 namespace expression {
 
 class Step : public Expression {
 public:
     Step(const type::Type& type_,
-          std::unique_ptr<Expression> input_,
-          std::map<double, std::unique_ptr<Expression>> stops_
-    ) : Expression(type_),
-        input(std::move(input_)),
-        stops(std::move(stops_))
-    {}
+         std::unique_ptr<Expression> input_,
+         std::map<double, std::unique_ptr<Expression>> stops_);
 
     EvaluationResult evaluate(const EvaluationContext& params) const override;
     void eachChild(const std::function<void(const Expression&)>& visit) const override;
@@ -40,6 +34,7 @@ class Step : public Expression {
 
     mbgl::Value serialize() const override;
     std::string getOperator() const override { return "step"; }
+
 private:
     const std::unique_ptr<Expression> input;
     const std::map<double, std::unique_ptr<Expression>> stops;

include/mbgl/style/function/camera_function.hpp

@@ -1,48 +1,28 @@
 #pragma once
 
 #include <mbgl/style/expression/expression.hpp>
+#include <mbgl/style/expression/value.hpp>
+#include <mbgl/style/expression/is_constant.hpp>
 #include <mbgl/style/expression/interpolate.hpp>
 #include <mbgl/style/expression/step.hpp>
 #include <mbgl/style/expression/find_zoom_curve.hpp>
-#include <mbgl/style/expression/value.hpp>
-#include <mbgl/style/expression/is_constant.hpp>
-#include <mbgl/style/function/convert.hpp>
-#include <mbgl/style/function/exponential_stops.hpp>
-#include <mbgl/style/function/interval_stops.hpp>
-#include <mbgl/util/interpolate.hpp>
-#include <mbgl/util/variant.hpp>
+#include <mbgl/util/range.hpp>
 
 namespace mbgl {
 namespace style {
 
 template <class T>
 class CameraFunction {
 public:
-    using Stops = std::conditional_t<
-        util::Interpolatable<T>::value,
-        variant<
-            ExponentialStops<T>,
-            IntervalStops<T>>,
-        variant<
-            IntervalStops<T>>>;
-
-    CameraFunction(std::unique_ptr<expression::Expression> expression_)
-         : isExpression(true),
+    // The second parameter should be used only for conversions from legacy functions.
+    CameraFunction(std::unique_ptr<expression::Expression> expression_, bool isExpression_ = true)
+         : isExpression(isExpression_),
            expression(std::move(expression_)),
-           zoomCurve(expression::findZoomCurveChecked(expression.get()))
-    {
+           zoomCurve(expression::findZoomCurveChecked(expression.get())) {
         assert(!expression::isZoomConstant(*expression));
         assert(expression::isFeatureConstant(*expression));
     }
 
-    CameraFunction(const Stops& stops)
-        : isExpression(false),
-          expression(stops.match([&] (const auto& s) {
-            return expression::Convert::toExpression(s);
-          })),
-          zoomCurve(expression::findZoomCurveChecked(expression.get()))
-    {}
-
     T evaluate(float zoom) const {
         const expression::EvaluationResult result = expression->evaluate(expression::EvaluationContext(zoom, nullptr));
         if (result) {
@@ -82,7 +62,7 @@ class CameraFunction {
     const expression::Expression& getExpression() const { return *expression; }
 
 private:
-    std::shared_ptr<expression::Expression> expression;
+    std::shared_ptr<const expression::Expression> expression;
     const variant<const expression::Interpolate*, const expression::Step*> zoomCurve;
 };