Add data-driven-styling support for text-font

include/mbgl/style/expression/array_assertion.hpp

@@ -30,6 +30,10 @@ class ArrayAssertion : public Expression  {
         return false;
     }
 
+    std::vector<optional<Value>> possibleOutputs() const override {
+        return input->possibleOutputs();
+    }
+
 private:
     std::unique_ptr<Expression> input;
 };

include/mbgl/style/expression/assertion.hpp

@@ -1,7 +1,9 @@
 #pragma once
+
 #include <mbgl/style/expression/expression.hpp>
 #include <mbgl/style/conversion.hpp>
 #include <mbgl/style/expression/parsing_context.hpp>
+
 #include <memory>
 #include <vector>
 
@@ -23,11 +25,12 @@ class Assertion : public Expression  {
 
     bool operator==(const Expression& e) const override;
 
+    std::vector<optional<Value>> possibleOutputs() const override;
+
 private:
     std::vector<std::unique_ptr<Expression>> inputs;
 };
 
 } // namespace expression
 } // namespace style
 } // namespace mbgl
-

include/mbgl/style/expression/at.hpp

@@ -28,6 +28,10 @@ class At : public Expression {
         return false;
     }
 
+    std::vector<optional<Value>> possibleOutputs() const override {
+        return { nullopt };
+    }
+
 private:
     std::unique_ptr<Expression> index;
     std::unique_ptr<Expression> input;

include/mbgl/style/expression/boolean_operator.hpp

@@ -2,6 +2,7 @@
 
 #include <mbgl/style/expression/expression.hpp>
 #include <mbgl/style/conversion.hpp>
+
 #include <memory>
 
 namespace mbgl {
@@ -20,6 +21,7 @@ class Any : public Expression  {
     EvaluationResult evaluate(const EvaluationContext& params) const override;
     void eachChild(const std::function<void(const Expression&)>& visit) const override;
     bool operator==(const Expression& e) const override;
+    std::vector<optional<Value>> possibleOutputs() const override;
 
 private:
     std::vector<std::unique_ptr<Expression>> inputs;
@@ -36,8 +38,8 @@ class All : public Expression  {
 
     EvaluationResult evaluate(const EvaluationContext& params) const override;
     void eachChild(const std::function<void(const Expression&)>& visit) const override;
-
     bool operator==(const Expression& e) const override;
+    std::vector<optional<Value>> possibleOutputs() const override;
 
 private:
     std::vector<std::unique_ptr<Expression>> inputs;
@@ -46,4 +48,3 @@ class All : public Expression  {
 } // namespace expression
 } // namespace style
 } // namespace mbgl
-

include/mbgl/style/expression/case.hpp

@@ -26,6 +26,8 @@ class Case : public Expression {
 
     bool operator==(const Expression& e) const override;
 
+    std::vector<optional<Value>> possibleOutputs() const override;
+
 private:
     std::vector<Branch> branches;
     std::unique_ptr<Expression> otherwise;

include/mbgl/style/expression/coalesce.hpp

@@ -27,7 +27,9 @@ class Coalesce : public Expression {
     void eachChild(const std::function<void(const Expression&)>& visit) const override;
 
     bool operator==(const Expression& e) const override;
-
+
+    std::vector<optional<Value>> possibleOutputs() const override;
+
     std::size_t getLength() const {
         return args.size();
     }

include/mbgl/style/expression/coercion.hpp

@@ -1,6 +1,8 @@
 #pragma once
+
 #include <mbgl/style/expression/expression.hpp>
 #include <mbgl/style/conversion.hpp>
+
 #include <memory>
 #include <vector>
 
@@ -23,6 +25,9 @@ class Coercion : public Expression  {
     void eachChild(const std::function<void(const Expression&)>& visit) const override;
 
     bool operator==(const Expression& e) const override;
+
+    std::vector<optional<Value>> possibleOutputs() const override;
+
 private:
     EvaluationResult (*coerceSingleValue) (const Value& v);
     std::vector<std::unique_ptr<Expression>> inputs;

include/mbgl/style/expression/compound_expression.hpp

@@ -72,7 +72,11 @@ class CompoundExpressionBase : public Expression {
             [&](const std::vector<type::Type>& p) -> optional<std::size_t> { return p.size(); }
         );
     }
-
+
+    std::vector<optional<Value>> possibleOutputs() const override {
+        return { nullopt };
+    }
+
 private:
     std::string name;
     variant<std::vector<type::Type>, VarargsType> params;
@@ -107,7 +111,7 @@ class CompoundExpression : public CompoundExpressionBase {
         }
         return false;
     }
-    
+
 private:
     Signature signature;
     typename Signature::Args args;

include/mbgl/style/expression/equals.hpp

@@ -19,6 +19,7 @@ class Equals : public Expression {
     void eachChild(const std::function<void(const Expression&)>& visit) const override;
     bool operator==(const Expression&) const override;
     EvaluationResult evaluate(const EvaluationContext&) const override;
+    std::vector<optional<Value>> possibleOutputs() const override;
 
 private:
     std::unique_ptr<Expression> lhs;

include/mbgl/style/expression/expression.hpp

@@ -1,15 +1,16 @@
 #pragma once
 
-#include <array>
-#include <vector>
-#include <memory>
 #include <mbgl/util/optional.hpp>
 #include <mbgl/util/variant.hpp>
 #include <mbgl/util/color.hpp>
 #include <mbgl/style/expression/type.hpp>
 #include <mbgl/style/expression/value.hpp>
 #include <mbgl/style/expression/parsing_context.hpp>
 
+#include <array>
+#include <vector>
+#include <memory>
+
 namespace mbgl {
 
 class GeometryTileFeature;
@@ -38,7 +39,7 @@ class EvaluationContext {
     optional<double> heatmapDensity;
 };
 
-template<typename T>
+template <typename T>
 class Result : private variant<EvaluationError, T> {
 public:
     using variant<EvaluationError, T>::variant;
@@ -128,6 +129,13 @@ class Expression {
 
     EvaluationResult evaluate(optional<float> zoom, const Feature& feature, optional<double> heatmapDensity) const;
 
+    /**
+     * Statically analyze the expression, attempting to enumerate possible outputs. Returns
+     * an array of values plus the sentinel null optional value, used to indicate that the
+     * complete set of outputs is statically undecidable.
+     */
+    virtual std::vector<optional<Value>> possibleOutputs() const = 0;
+
 protected:
     template <typename T>
     static bool childrenEqual(const T& lhs, const T& rhs) {
@@ -161,8 +169,6 @@ class Expression {
                            const std::pair<std::unique_ptr<Expression>, std::unique_ptr<Expression>>& rhs) {
         return *(lhs.first) == *(rhs.first) && *(lhs.second) == *(rhs.second);
     }
-
-
 
 private:
     type::Type type;

include/mbgl/style/expression/interpolate.hpp

@@ -89,6 +89,8 @@ class InterpolateBase : public Expression {
         );
     }
 
+    std::vector<optional<Value>> possibleOutputs() const override;
+
 protected:
     const Interpolator interpolator;
     const std::unique_ptr<Expression> input;

include/mbgl/style/expression/let.hpp

@@ -33,6 +33,8 @@ class Let : public Expression {
         return false;
     }
 
+    std::vector<optional<Value>> possibleOutputs() const override;
+
     Expression* getResult() const {
         return result.get();
     }
@@ -61,7 +63,9 @@ class Var : public Expression {
         }
         return false;
     }
-
+
+    std::vector<optional<Value>> possibleOutputs() const override;
+
 private:
     std::string name;
     std::shared_ptr<Expression> value;

include/mbgl/style/expression/literal.hpp

@@ -28,7 +28,11 @@ class Literal : public Expression {
         }
         return false;
     }
-
+
+    std::vector<optional<Value>> possibleOutputs() const override {
+        return {{ value }};
+    }
+
 private:
     Value value;
 };

include/mbgl/style/expression/match.hpp

@@ -25,14 +25,15 @@ class Match : public Expression {
         otherwise(std::move(otherwise_))
     {}
 
+    EvaluationResult evaluate(const EvaluationContext& params) const override;
+
     void eachChild(const std::function<void(const Expression&)>& visit) const override;
 
     bool operator==(const Expression& e) const override;
 
-    EvaluationResult evaluate(const EvaluationContext& params) const override;
-    
+    std::vector<optional<Value>> possibleOutputs() const override;
+
 private:
-
     std::unique_ptr<Expression> input;
     Branches branches;
     std::unique_ptr<Expression> otherwise;

include/mbgl/style/expression/step.hpp

@@ -33,6 +33,8 @@ class Step : public Expression {
 
     bool operator==(const Expression& e) const override;
 
+    std::vector<optional<Value>> possibleOutputs() const override;
+
     static ParseResult parse(const mbgl::style::conversion::Convertible& value, ParsingContext& ctx);
 
 private:

include/mbgl/style/expression/value.hpp

@@ -148,6 +148,15 @@ struct ValueConverter<T, std::enable_if_t< std::is_enum<T>::value >> {
     static optional<T> fromExpressionValue(const Value& value);
 };
 
+template <typename T>
+std::vector<optional<T>> fromExpressionValues(const std::vector<optional<Value>>& values) {
+    std::vector<optional<T>> result;
+    for (const auto& value : values) {
+        result.push_back(value ? fromExpressionValue<T>(*value) : nullopt);
+    }
+    return result;
+}
+
 } // namespace expression
 } // namespace style
 } // namespace mbgl

include/mbgl/style/function/camera_function.hpp

@@ -12,7 +12,6 @@
 #include <mbgl/util/interpolate.hpp>
 #include <mbgl/util/variant.hpp>
 
-
 namespace mbgl {
 namespace style {
 
@@ -66,7 +65,11 @@ class CameraFunction {
             [&](auto z) { return z->getCoveringStops(lower, upper); }
         );
     }
-
+
+    std::vector<optional<T>> possibleOutputs() const {
+        return expression::fromExpressionValues<T>(expression->possibleOutputs());
+    }
+
     friend bool operator==(const CameraFunction& lhs,
                            const CameraFunction& rhs) {
         return *lhs.expression == *rhs.expression;

include/mbgl/style/function/composite_function.hpp

@@ -102,6 +102,10 @@ class CompositeFunction {
         );
     }
 
+    std::vector<optional<T>> possibleOutputs() const {
+        return expression::fromExpressionValues<T>(expression->possibleOutputs());
+    }
+
     friend bool operator==(const CompositeFunction& lhs,
                            const CompositeFunction& rhs) {
         return *lhs.expression == *rhs.expression;

include/mbgl/style/function/convert.hpp

@@ -45,6 +45,10 @@ class ErrorExpression : public Expression {
         return EvaluationError{message};
     }
 
+    std::vector<optional<Value>> possibleOutputs() const override {
+        return {};
+    }
+
 private:
     std::string message;
 };

include/mbgl/style/function/source_function.hpp

@@ -57,6 +57,10 @@ class SourceFunction {
         return defaultValue ? *defaultValue : finalDefaultValue;
     }
 
+    std::vector<optional<T>> possibleOutputs() const {
+        return expression::fromExpressionValues<T>(expression->possibleOutputs());
+    }
+
     friend bool operator==(const SourceFunction& lhs,
                            const SourceFunction& rhs) {
         return *lhs.expression == *rhs.expression;

include/mbgl/style/layers/symbol_layer.hpp

@@ -118,9 +118,9 @@ class SymbolLayer : public Layer {
     DataDrivenPropertyValue<std::string> getTextField() const;
     void setTextField(DataDrivenPropertyValue<std::string>);
 
-    static PropertyValue<std::vector<std::string>> getDefaultTextFont();
-    PropertyValue<std::vector<std::string>> getTextFont() const;
-    void setTextFont(PropertyValue<std::vector<std::string>>);
+    static DataDrivenPropertyValue<std::vector<std::string>> getDefaultTextFont();
+    DataDrivenPropertyValue<std::vector<std::string>> getTextFont() const;
+    void setTextFont(DataDrivenPropertyValue<std::vector<std::string>>);
 
     static DataDrivenPropertyValue<float> getDefaultTextSize();
     DataDrivenPropertyValue<float> getTextSize() const;

include/mbgl/util/optional.hpp

@@ -7,4 +7,7 @@ namespace mbgl {
 template <typename T>
 using optional = std::experimental::optional<T>;
 
+using nullopt_t = std::experimental::nullopt_t;
+constexpr nullopt_t nullopt = std::experimental::nullopt;
+
 } // namespace mbgl

platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/PropertyFactory.java

@@ -2888,11 +2888,11 @@ public static PropertyValue<Expression> textFont(Expression value) {
   /**
    * Font stack to use for displaying text.
    *
-   * @param <Z> the zoom parameter type
-   * @param function a wrapper {@link CameraFunction} for String[]
+   * @param <T> the function input type
+   * @param function a wrapper function for String[]
    * @return property wrapper around a String[] function
    */
-  public static <Z extends Number> PropertyValue<CameraFunction<Z, String[]>> textFont(CameraFunction<Z, String[]> function) {
+  public static <T> PropertyValue<Function<T, String[]>> textFont(Function<T, String[]> function) {
     return new LayoutPropertyValue<>("text-font", function);
   }