[core, node] Node bindings for setFilter

4 files changed, 56 insertions, 170 deletions

diff --git a/src/mbgl/style/conversion.cpp b/src/mbgl/style/conversion.cpp
new file mode 100644
index 0000000000..e863e285c4
--- /dev/null
+++ b/src/mbgl/style/conversion.cpp
@@ -0,0 +1,25 @@
+#include <mbgl/style/conversion.hpp>
+
+namespace mbgl {
+namespace style {
+namespace conversion {
+
+Result<Value> normalizeFilterValue(const std::string& key, const optional<Value>& value) {
+    if (!value) {
+        return Error { "filter expression value must be a boolean, number, or string" };
+    } else if (key != "$type") {
+        return *value;
+    } else if (*value == std::string("Point")) {
+        return Value(uint64_t(FeatureType::Point));
+    } else if (*value == std::string("LineString")) {
+        return Value(uint64_t(FeatureType::LineString));
+    } else if (*value == std::string("Polygon")) {
+        return Value(uint64_t(FeatureType::Polygon));
+    } else {
+        return Error { "value for $type filter must be Point, LineString, or Polygon" };
+    }
+}
+
+} // namespace conversion
+} // namespace style
+} // namespace mbgl
diff --git a/src/mbgl/style/parser.cpp b/src/mbgl/style/parser.cpp
index 34f01c14c1..eddda5d3f2 100644
--- a/src/mbgl/style/parser.cpp
+++ b/src/mbgl/style/parser.cpp
@@ -9,6 +9,8 @@
 #include <mbgl/style/layers/symbol_layer.hpp>
 #include <mbgl/style/layers/raster_layer.hpp>
 #include <mbgl/style/layers/background_layer.hpp>
+#include <mbgl/style/rapidjson_conversion.hpp>
+#include <mbgl/style/conversion.hpp>
 
 #include <mbgl/platform/log.hpp>
 
@@ -275,7 +277,12 @@ void Parser::parseLayer(const std::string& id, const JSValue& value, std::unique
         }
 
         if (value.HasMember("filter")) {
-            impl->filter = parseFilter(value["filter"]);
+            conversion::Result<Filter> filter = conversion::convertFilter(value["filter"]);
+            if (filter.is<Filter>()) {
+                impl->filter = filter.get<Filter>();
+            } else {
+                Log::Warning(Event::ParseStyle, filter.get<conversion::Error>().message);
+            }
         }
 
         if (value.HasMember("minzoom")) {
@@ -326,172 +333,6 @@ void Parser::parseVisibility(Layer& layer, const JSValue& value) {
     impl.visibility = *enumValue;
 }
 
-Value parseFeatureType(const Value& value) {
-    if (value == std::string("Point")) {
-        return Value(uint64_t(FeatureType::Point));
-    } else if (value == std::string("LineString")) {
-        return Value(uint64_t(FeatureType::LineString));
-    } else if (value == std::string("Polygon")) {
-        return Value(uint64_t(FeatureType::Polygon));
-    } else {
-        Log::Warning(Event::ParseStyle, "value for $type filter must be Point, LineString, or Polygon");
-        return Value(uint64_t(FeatureType::Unknown));
-    }
-}
-
-Value parseValue(const JSValue& value) {
-    switch (value.GetType()) {
-        case rapidjson::kNullType:
-        case rapidjson::kFalseType:
-            return false;
-
-        case rapidjson::kTrueType:
-            return true;
-
-        case rapidjson::kStringType:
-            return std::string { value.GetString(), value.GetStringLength() };
-
-        case rapidjson::kNumberType:
-            if (value.IsUint64()) return value.GetUint64();
-            if (value.IsInt64()) return value.GetInt64();
-            return value.GetDouble();
-
-        default:
-            return false;
-    }
-}
-
-template <class Expression>
-Filter parseUnaryFilter(const JSValue& value) {
-    Filter empty;
-
-    if (value.Size() < 2) {
-        Log::Warning(Event::ParseStyle, "filter expression must have 2 elements");
-        return empty;
-    }
-
-    if (!value[1u].IsString()) {
-        Log::Warning(Event::ParseStyle, "filter expression key must be a string");
-        return empty;
-    }
-
-    Expression expression;
-    expression.key = { value[1u].GetString(), value[1u].GetStringLength() };
-    return expression;
-}
-
-template <class Expression>
-Filter parseBinaryFilter(const JSValue& value) {
-    Filter empty;
-
-    if (value.Size() < 3) {
-        Log::Warning(Event::ParseStyle, "filter expression must have 3 elements");
-        return empty;
-    }
-
-    if (!value[1u].IsString()) {
-        Log::Warning(Event::ParseStyle, "filter expression key must be a string");
-        return empty;
-    }
-
-    Expression expression;
-    expression.key = { value[1u].GetString(), value[1u].GetStringLength() };
-    expression.value = parseValue(value[2u]);
-
-    if (expression.key == "$type") {
-        expression.value = parseFeatureType(expression.value);
-    }
-
-    return expression;
-}
-
-template <class Expression>
-Filter parseSetFilter(const JSValue& value) {
-    Filter empty;
-
-    if (value.Size() < 2) {
-        Log::Warning(Event::ParseStyle, "filter expression must at least 2 elements");
-        return empty;
-    }
-
-    if (!value[1u].IsString()) {
-        Log::Warning(Event::ParseStyle, "filter expression key must be a string");
-        return empty;
-    }
-
-    Expression expression;
-    expression.key = { value[1u].GetString(), value[1u].GetStringLength() };
-    for (rapidjson::SizeType i = 2; i < value.Size(); ++i) {
-        Value parsedValue = parseValue(value[i]);
-        if (expression.key == "$type") {
-            parsedValue = parseFeatureType(parsedValue);
-        }
-        expression.values.push_back(parsedValue);
-    }
-    return expression;
-}
-
-template <class Expression>
-Filter parseCompoundFilter(const JSValue& value) {
-    Expression expression;
-    for (rapidjson::SizeType i = 1; i < value.Size(); ++i) {
-        expression.filters.push_back(parseFilter(value[i]));
-    }
-    return expression;
-}
-
-Filter parseFilter(const JSValue& value) {
-    Filter empty;
-
-    if (!value.IsArray()) {
-        Log::Warning(Event::ParseStyle, "filter expression must be an array");
-        return empty;
-    }
-
-    if (value.Size() < 1) {
-        Log::Warning(Event::ParseStyle, "filter expression must have at least 1 element");
-        return empty;
-    }
-
-    if (!value[0u].IsString()) {
-        Log::Warning(Event::ParseStyle, "filter operator must be a string");
-        return empty;
-    }
-
-    std::string op = { value[0u].GetString(), value[0u].GetStringLength() };
-
-    if (op == "==") {
-        return parseBinaryFilter<EqualsFilter>(value);
-    } else if (op == "!=") {
-        return parseBinaryFilter<NotEqualsFilter>(value);
-    } else if (op == ">") {
-        return parseBinaryFilter<GreaterThanFilter>(value);
-    } else if (op == ">=") {
-        return parseBinaryFilter<GreaterThanEqualsFilter>(value);
-    } else if (op == "<") {
-        return parseBinaryFilter<LessThanFilter>(value);
-    } else if (op == "<=") {
-        return parseBinaryFilter<LessThanEqualsFilter>(value);
-    } else if (op == "in") {
-        return parseSetFilter<InFilter>(value);
-    } else if (op == "!in") {
-        return parseSetFilter<NotInFilter>(value);
-    } else if (op == "all") {
-        return parseCompoundFilter<AllFilter>(value);
-    } else if (op == "any") {
-        return parseCompoundFilter<AnyFilter>(value);
-    } else if (op == "none") {
-        return parseCompoundFilter<NoneFilter>(value);
-    } else if (op == "has") {
-        return parseUnaryFilter<HasFilter>(value);
-    } else if (op == "!has") {
-       return parseUnaryFilter<NotHasFilter>(value);
-    } else {
-        Log::Warning(Event::ParseStyle, "filter operator must be one of \"==\", \"!=\", \">\", \">=\", \"<\", \"<=\", \"in\", \"!in\", \"all\", \"any\", \"none\", \"has\", or \"!has\"");
-        return empty;
-    }
-}
-
 std::vector<FontStack> Parser::fontStacks() const {
     std::set<FontStack> result;
 
diff --git a/src/mbgl/style/parser.hpp b/src/mbgl/style/parser.hpp
index 6dac6dedcd..30da0dd2b0 100644
--- a/src/mbgl/style/parser.hpp
+++ b/src/mbgl/style/parser.hpp
@@ -2,7 +2,6 @@
 
 #include <mbgl/style/layer.hpp>
 #include <mbgl/style/source.hpp>
-#include <mbgl/style/filter.hpp>
 
 #include <mbgl/util/rapidjson.hpp>
 #include <mbgl/util/font_stack.hpp>
@@ -16,8 +15,6 @@
 namespace mbgl {
 namespace style {
 
-Filter parseFilter(const JSValue&);
-
 class Parser {
 public:
     ~Parser();
diff --git a/src/mbgl/style/rapidjson_conversion.hpp b/src/mbgl/style/rapidjson_conversion.hpp
index 93577ac8b2..1d9f88efa3 100644
--- a/src/mbgl/style/rapidjson_conversion.hpp
+++ b/src/mbgl/style/rapidjson_conversion.hpp
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <mbgl/util/rapidjson.hpp>
+#include <mbgl/util/feature.hpp>
 
 namespace mbgl {
 namespace style {
@@ -50,6 +51,28 @@ inline optional<std::string> toString(const JSValue& value) {
     return {{ value.GetString(), value.GetStringLength() }};
 }
 
+inline optional<Value> toValue(const JSValue& value) {
+    switch (value.GetType()) {
+        case rapidjson::kNullType:
+        case rapidjson::kFalseType:
+            return { false };
+
+        case rapidjson::kTrueType:
+            return { true };
+
+        case rapidjson::kStringType:
+            return { std::string { value.GetString(), value.GetStringLength() } };
+
+        case rapidjson::kNumberType:
+            if (value.IsUint64()) return { value.GetUint64() };
+            if (value.IsInt64()) return { value.GetInt64() };
+            return { value.GetDouble() };
+
+        default:
+            return {};
+    }
+}
+
 } // namespace conversion
 } // namespace style
 } // namespace mbgl