[core] Implement Expression::serialize()

Issue #10714 - Each expression stores its operator as a string, and default serialization is [operator, serialize(child1), ...] - Custom implementations of `serialize` for Expression types that don't follow the pattern - expression::Value -> mbgl::Value converter - node_expression bindings to expose `serialize`
mapbox · Feb 16, 2018 · 9830c62 · 9830c62
1 parent 341eb76
commit 9830c62
Show file tree

Hide file tree

Showing 30 changed files with 262 additions and 40 deletions.
diff --git a/include/mbgl/style/expression/array_assertion.hpp b/include/mbgl/style/expression/array_assertion.hpp
@@ -33,6 +33,9 @@ class ArrayAssertion : public Expression  {
     std::vector<optional<Value>> possibleOutputs() const override {
         return input->possibleOutputs();
     }
+
+    mbgl::Value serialize() const override;
+    std::string getOperator() const override { return "array"; }
 
 private:
     std::unique_ptr<Expression> input;

diff --git a/include/mbgl/style/expression/assertion.hpp b/include/mbgl/style/expression/assertion.hpp
@@ -26,6 +26,8 @@ class Assertion : public Expression  {
     bool operator==(const Expression& e) const override;
 
     std::vector<optional<Value>> possibleOutputs() const override;
+
+    std::string getOperator() const override;
 
 private:
     std::vector<std::unique_ptr<Expression>> inputs;

diff --git a/include/mbgl/style/expression/at.hpp b/include/mbgl/style/expression/at.hpp
@@ -31,6 +31,8 @@ class At : public Expression {
     std::vector<optional<Value>> possibleOutputs() const override {
         return { nullopt };
     }
+
+    std::string getOperator() const override { return "at"; }
 
 private:
     std::unique_ptr<Expression> index;

diff --git a/include/mbgl/style/expression/boolean_operator.hpp b/include/mbgl/style/expression/boolean_operator.hpp
@@ -23,6 +23,7 @@ class Any : public Expression  {
     bool operator==(const Expression& e) const override;
     std::vector<optional<Value>> possibleOutputs() const override;
 
+    std::string getOperator() const override { return "any"; }
 private:
     std::vector<std::unique_ptr<Expression>> inputs;
 };
@@ -41,6 +42,7 @@ class All : public Expression  {
     bool operator==(const Expression& e) const override;
     std::vector<optional<Value>> possibleOutputs() const override;
 
+    std::string getOperator() const override { return "all"; }
 private:
     std::vector<std::unique_ptr<Expression>> inputs;
 };

diff --git a/include/mbgl/style/expression/case.hpp b/include/mbgl/style/expression/case.hpp
@@ -28,6 +28,7 @@ class Case : public Expression {
 
     std::vector<optional<Value>> possibleOutputs() const override;
 
+    std::string getOperator() const override { return "case"; }
 private:
     std::vector<Branch> branches;
     std::unique_ptr<Expression> otherwise;

diff --git a/include/mbgl/style/expression/coalesce.hpp b/include/mbgl/style/expression/coalesce.hpp
@@ -38,6 +38,7 @@ class Coalesce : public Expression {
         return args.at(i).get();
     }
 
+    std::string getOperator() const override { return "coalesce"; }
 private:
     Args args;
 };

diff --git a/include/mbgl/style/expression/coercion.hpp b/include/mbgl/style/expression/coercion.hpp
@@ -28,6 +28,7 @@ class Coercion : public Expression  {
 
     std::vector<optional<Value>> possibleOutputs() const override;
 
+    std::string getOperator() const override;
 private:
     EvaluationResult (*coerceSingleValue) (const Value& v);
     std::vector<std::unique_ptr<Expression>> inputs;

diff --git a/include/mbgl/style/expression/compound_expression.hpp b/include/mbgl/style/expression/compound_expression.hpp
@@ -40,14 +40,16 @@ namespace detail {
 // each CompoundExpression definition's type::Type data from the type of its
 // "evaluate" function.
 struct SignatureBase {
-    SignatureBase(type::Type result_, variant<std::vector<type::Type>, VarargsType> params_) :
+    SignatureBase(type::Type result_, variant<std::vector<type::Type>, VarargsType> params_, std::string name_) :
         result(std::move(result_)),
-        params(std::move(params_))
+        params(std::move(params_)),
+        name(std::move(name_))
     {}
     virtual ~SignatureBase() = default;
-    virtual std::unique_ptr<Expression> makeExpression(const std::string& name, std::vector<std::unique_ptr<Expression>>) const = 0;
+    virtual std::unique_ptr<Expression> makeExpression(std::vector<std::unique_ptr<Expression>>) const = 0;
     type::Type result;
     variant<std::vector<type::Type>, VarargsType> params;
+    std::string name;
 };
 } // namespace detail
 
@@ -111,6 +113,10 @@ class CompoundExpression : public CompoundExpressionBase {
         }
         return false;
     }
+
+    std::string getOperator() const override {
+        return signature.name;
+    }
 
 private:
     Signature signature;
@@ -128,8 +134,7 @@ struct CompoundExpressionRegistry {
 
 ParseResult parseCompoundExpression(const std::string name, const mbgl::style::conversion::Convertible& value, ParsingContext& ctx);
 
-ParseResult createCompoundExpression(const std::string& name,
-                                     const CompoundExpressionRegistry::Definition& definition,
+ParseResult createCompoundExpression(const CompoundExpressionRegistry::Definition& definition,
                                      std::vector<std::unique_ptr<Expression>> args,
                                      ParsingContext& ctx);
 

diff --git a/include/mbgl/style/expression/equals.hpp b/include/mbgl/style/expression/equals.hpp
@@ -21,6 +21,7 @@ class Equals : public Expression {
     EvaluationResult evaluate(const EvaluationContext&) const override;
     std::vector<optional<Value>> possibleOutputs() const override;
 
+    std::string getOperator() const override { return negate ? "!=" : "=="; }
 private:
     std::unique_ptr<Expression> lhs;
     std::unique_ptr<Expression> rhs;

diff --git a/include/mbgl/style/expression/expression.hpp b/include/mbgl/style/expression/expression.hpp
@@ -135,6 +135,17 @@ class Expression {
      * complete set of outputs is statically undecidable.
      */
     virtual std::vector<optional<Value>> possibleOutputs() const = 0;
+
+    virtual mbgl::Value serialize() const {
+        std::vector<mbgl::Value> serialized;
+        serialized.emplace_back(getOperator());
+        eachChild([&](const Expression &child) {
+            serialized.emplace_back(child.serialize());
+        });
+        return serialized;
+    };
+
+    virtual std::string getOperator() const = 0;
 
 protected:
     template <typename T>

diff --git a/include/mbgl/style/expression/interpolate.hpp b/include/mbgl/style/expression/interpolate.hpp
@@ -185,6 +185,9 @@ class Interpolate : public InterpolateBase {
         }
         return false;
     }
+
+    mbgl::Value serialize() const override;
+    std::string getOperator() const override { return "interpolate"; }
 };
 
 } // namespace expression

diff --git a/include/mbgl/style/expression/let.hpp b/include/mbgl/style/expression/let.hpp
@@ -39,6 +39,8 @@ class Let : public Expression {
         return result.get();
     }
 
+    mbgl::Value serialize() const override;
+    std::string getOperator() const override { return "let"; }
 private:
     Bindings bindings;
     std::unique_ptr<Expression> result;
@@ -66,6 +68,8 @@ class Var : public Expression {
 
     std::vector<optional<Value>> possibleOutputs() const override;
 
+    mbgl::Value serialize() const override;
+    std::string getOperator() const override { return "var"; }
 private:
     std::string name;
     std::shared_ptr<Expression> value;

diff --git a/include/mbgl/style/expression/literal.hpp b/include/mbgl/style/expression/literal.hpp
@@ -12,8 +12,16 @@ namespace expression {
 
 class Literal : public Expression {
 public:
-    Literal(Value value_) : Expression(typeOf(value_)), value(value_) {}
-    Literal(type::Array type_, std::vector<Value> value_) : Expression(type_), value(value_) {}
+    Literal(Value value_)
+        : Expression(typeOf(value_))
+        , value(value_)
+    {}
+
+    Literal(type::Array type_, std::vector<Value> value_)
+        : Expression(type_)
+        , value(value_)
+    {}
+
     EvaluationResult evaluate(const EvaluationContext&) const override {
         return value;
     }
@@ -33,6 +41,8 @@ class Literal : public Expression {
         return {{ value }};
     }
 
+    mbgl::Value serialize() const override;
+    std::string getOperator() const override { return "literal"; }
 private:
     Value value;
 };

diff --git a/include/mbgl/style/expression/match.hpp b/include/mbgl/style/expression/match.hpp
@@ -32,7 +32,9 @@ class Match : public Expression {
     bool operator==(const Expression& e) const override;
 
     std::vector<optional<Value>> possibleOutputs() const override;
-
+
+    mbgl::Value serialize() const override;
+    std::string getOperator() const override { return "match"; }
 private:
     std::unique_ptr<Expression> input;
     Branches branches;

diff --git a/include/mbgl/style/expression/step.hpp b/include/mbgl/style/expression/step.hpp
@@ -38,6 +38,8 @@ class Step : public Expression {
 
     static ParseResult parse(const mbgl::style::conversion::Convertible& value, ParsingContext& ctx);
 
+    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;

diff --git a/include/mbgl/style/expression/value.hpp b/include/mbgl/style/expression/value.hpp
@@ -110,6 +110,7 @@ struct ValueConverter<float> {
 template<>
 struct ValueConverter<mbgl::Value> {
     static Value toExpressionValue(const mbgl::Value& value);
+    static mbgl::Value fromExpressionValue(const Value& value);
 };
 
 template <typename T, std::size_t N>

diff --git a/include/mbgl/style/function/convert.hpp b/include/mbgl/style/function/convert.hpp
@@ -49,6 +49,7 @@ class ErrorExpression : public Expression {
         return {};
     }
 
+    std::string getOperator() const override { return "error"; }
 private:
     std::string message;
 };

diff --git a/platform/node/src/node_expression.cpp b/platform/node/src/node_expression.cpp
@@ -1,5 +1,6 @@
 #include "node_conversion.hpp"
 #include "node_expression.hpp"
+#include "node_feature.hpp"
 
 #include <mbgl/style/expression/parsing_context.hpp>
 #include <mbgl/style/expression/is_constant.hpp>
@@ -24,6 +25,8 @@ void NodeExpression::Init(v8::Local<v8::Object> target) {
     Nan::SetPrototypeMethod(tpl, "isFeatureConstant", IsFeatureConstant);
     Nan::SetPrototypeMethod(tpl, "isZoomConstant", IsZoomConstant);
 
+    Nan::SetPrototypeMethod(tpl, "serialize", Serialize);
+
     Nan::SetMethod(tpl, "parse", Parse);
 
     constructor.Reset(tpl->GetFunction()); // what is this doing?
@@ -39,31 +42,31 @@ type::Type parseType(v8::Local<v8::Object> type) {
         {"color", type::Color},
         {"value", type::Value}
     };
-    
+
     v8::Local<v8::Value> v8kind = Nan::Get(type, Nan::New("kind").ToLocalChecked()).ToLocalChecked();
     std::string kind(*v8::String::Utf8Value(v8kind));
-    
+
     if (kind == "array") {
         type::Type itemType = parseType(Nan::Get(type, Nan::New("itemType").ToLocalChecked()).ToLocalChecked()->ToObject());
         mbgl::optional<std::size_t> N;
-        
+
         v8::Local<v8::String> Nkey = Nan::New("N").ToLocalChecked();
         if (Nan::Has(type, Nkey).FromMaybe(false)) {
             N = Nan::Get(type, Nkey).ToLocalChecked()->ToInt32()->Value();
         }
         return type::Array(itemType, N);
     }
-    
+
     return types[kind];
 }
 
 void NodeExpression::Parse(const Nan::FunctionCallbackInfo<v8::Value>& info) {
     v8::Local<v8::Function> cons = Nan::New(constructor);
-    
+
     if (info.Length() < 1 || info[0]->IsUndefined()) {
         return Nan::ThrowTypeError("Requires a JSON style expression argument.");
     }
-    
+
     mbgl::optional<type::Type> expected;
     if (info.Length() > 1 && info[1]->IsObject()) {
         expected = parseType(info[1]->ToObject());
@@ -84,7 +87,7 @@ void NodeExpression::Parse(const Nan::FunctionCallbackInfo<v8::Value>& info) {
             info.GetReturnValue().Set(wrapped);
             return;
         }
-        
+
         v8::Local<v8::Array> result = Nan::New<v8::Array>();
         for (std::size_t i = 0; i < ctx.getErrors().size(); i++) {
             const auto& error = ctx.getErrors()[i];
@@ -140,7 +143,7 @@ struct ToValue {
         }
         return scope.Escape(result);
     }
-    
+
     v8::Local<v8::Value> operator()(const mbgl::Color& color) {
         return operator()(std::vector<Value> {
             static_cast<double>(color.r),
@@ -227,4 +230,12 @@ void NodeExpression::IsZoomConstant(const Nan::FunctionCallbackInfo<v8::Value>&
     info.GetReturnValue().Set(Nan::New(isZoomConstant(*expression)));
 }
 
+void NodeExpression::Serialize(const Nan::FunctionCallbackInfo<v8::Value>& info) {
+    NodeExpression* nodeExpr = ObjectWrap::Unwrap<NodeExpression>(info.Holder());
+    const std::unique_ptr<Expression>& expression = nodeExpr->expression;
+
+    const mbgl::Value serialized = expression->serialize();
+    info.GetReturnValue().Set(toJS(serialized));
+}
+
 } // namespace node_mbgl
diff --git a/platform/node/src/node_expression.hpp b/platform/node/src/node_expression.hpp
@@ -32,6 +32,9 @@ class NodeExpression : public Nan::ObjectWrap {
     static void GetType(const Nan::FunctionCallbackInfo<v8::Value>&);
     static void IsFeatureConstant(const Nan::FunctionCallbackInfo<v8::Value>&);
     static void IsZoomConstant(const Nan::FunctionCallbackInfo<v8::Value>&);
+
+    static void Serialize(const Nan::FunctionCallbackInfo<v8::Value>&);
+
     static Nan::Persistent<v8::Function> constructor;
 
     std::unique_ptr<Expression> expression;

diff --git a/platform/node/test/expression.test.js b/platform/node/test/expression.test.js
@@ -45,6 +45,9 @@ suite.run('native', {ignores: ignores, tests: tests}, (fixture) => {
         compiled.isZoomConstant = expression.isZoomConstant();
         compiled.type = expression.getType();
 
+        console.log("input: " + JSON.stringify(fixture.expression));
+        console.log("output: " + JSON.stringify(expression.serialize()));
+
         const evaluate = fixture.inputs || [];
         const evaluateResults = [];
         for (const input of evaluate) {
@@ -68,4 +71,3 @@ suite.run('native', {ignores: ignores, tests: tests}, (fixture) => {
 
     return result;
 });
-
diff --git a/src/mbgl/style/expression/array_assertion.cpp b/src/mbgl/style/expression/array_assertion.cpp
@@ -81,6 +81,25 @@ ParseResult ArrayAssertion::parse(const Convertible& value, ParsingContext& ctx)
     ));
 }
 
+mbgl::Value ArrayAssertion::serialize() const {
+    std::vector<mbgl::Value> serialized;
+    serialized.emplace_back(getOperator());
+
+
+    const auto array = getType().get<type::Array>();
+    if (array.itemType.is<type::StringType>()
+     || array.itemType.is<type::NumberType>()
+     || array.itemType.is<type::BooleanType>()) {
+        serialized.emplace_back(type::toString(array.itemType));
+        if (array.N) {
+            serialized.emplace_back(uint64_t(*array.N));
+        }
+    }
+
+    serialized.emplace_back(input->serialize());
+    return serialized;
+}
+
 } // namespace expression
 } // namespace style
 } // namespace mbgl
diff --git a/src/mbgl/style/expression/assertion.cpp b/src/mbgl/style/expression/assertion.cpp
@@ -35,6 +35,10 @@ ParseResult Assertion::parse(const Convertible& value, ParsingContext& ctx) {
     return ParseResult(std::make_unique<Assertion>(it->second, std::move(parsed)));
 }
 
+std::string Assertion::getOperator() const {
+    return type::toString(getType());
+}
+
 EvaluationResult Assertion::evaluate(const EvaluationContext& params) const {
     for (std::size_t i = 0; i < inputs.size(); i++) {
         EvaluationResult value = inputs[i]->evaluate(params);

diff --git a/src/mbgl/style/expression/coercion.cpp b/src/mbgl/style/expression/coercion.cpp
@@ -81,6 +81,13 @@ Coercion::Coercion(type::Type type_, std::vector<std::unique_ptr<Expression>> in
     }
 }
 
+std::string Coercion::getOperator() const {
+    return getType().match(
+      [](const type::NumberType&) { return "to-number"; },
+      [](const type::ColorType&) { return "to-color"; },
+      [](const auto&) { assert(false); return ""; });
+}
+
 using namespace mbgl::style::conversion;
 ParseResult Coercion::parse(const Convertible& value, ParsingContext& ctx) {
     static std::unordered_map<std::string, type::Type> types {