diff options
| -rw-r--r-- | cmake/core-files.cmake | 4 | ||||
| -rw-r--r-- | include/mbgl/style/expression/comparison.hpp | 68 | ||||
| -rw-r--r-- | include/mbgl/style/expression/dsl.hpp | 1 | ||||
| -rw-r--r-- | include/mbgl/style/expression/equals.hpp | 35 | ||||
| -rw-r--r-- | include/mbgl/style/expression/expression.hpp | 2 | ||||
| m--------- | mapbox-gl-js | 0 | ||||
| -rw-r--r-- | src/mbgl/style/expression/comparison.cpp | 275 | ||||
| -rw-r--r-- | src/mbgl/style/expression/compound_expression.cpp | 13 | ||||
| -rw-r--r-- | src/mbgl/style/expression/dsl.cpp | 20 | ||||
| -rw-r--r-- | src/mbgl/style/expression/equals.cpp | 113 | ||||
| -rw-r--r-- | src/mbgl/style/expression/parsing_context.cpp | 10 |
11 files changed, 366 insertions, 175 deletions
diff --git a/cmake/core-files.cmake b/cmake/core-files.cmake index 44aff682fc..addacc174d 100644 --- a/cmake/core-files.cmake +++ b/cmake/core-files.cmake @@ -455,9 +455,9 @@ set(MBGL_CORE_FILES include/mbgl/style/expression/coercion.hpp include/mbgl/style/expression/collator.hpp include/mbgl/style/expression/collator_expression.hpp + include/mbgl/style/expression/comparison.hpp include/mbgl/style/expression/compound_expression.hpp include/mbgl/style/expression/dsl.hpp - include/mbgl/style/expression/equals.hpp include/mbgl/style/expression/error.hpp include/mbgl/style/expression/expression.hpp include/mbgl/style/expression/find_zoom_curve.hpp @@ -483,9 +483,9 @@ set(MBGL_CORE_FILES src/mbgl/style/expression/coalesce.cpp src/mbgl/style/expression/coercion.cpp src/mbgl/style/expression/collator_expression.cpp + src/mbgl/style/expression/comparison.cpp src/mbgl/style/expression/compound_expression.cpp src/mbgl/style/expression/dsl.cpp - src/mbgl/style/expression/equals.cpp src/mbgl/style/expression/expression.cpp src/mbgl/style/expression/find_zoom_curve.cpp src/mbgl/style/expression/get_covering_stops.cpp diff --git a/include/mbgl/style/expression/comparison.hpp b/include/mbgl/style/expression/comparison.hpp new file mode 100644 index 0000000000..cf64f5cd34 --- /dev/null +++ b/include/mbgl/style/expression/comparison.hpp @@ -0,0 +1,68 @@ +#pragma once + +#include <mbgl/style/expression/collator_expression.hpp> +#include <mbgl/style/expression/expression.hpp> +#include <mbgl/style/expression/parsing_context.hpp> +#include <mbgl/style/conversion.hpp> + +#include <memory> + +namespace mbgl { +namespace style { +namespace expression { + +ParseResult parseComparison(const mbgl::style::conversion::Convertible&, ParsingContext&); + +class BasicComparison : public Expression { +public: + using CompareFunctionType = bool (*) (Value, Value); + + BasicComparison( + std::string op, + std::unique_ptr<Expression> lhs, + std::unique_ptr<Expression> rhs); + + 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; + std::string getOperator() const override; + +private: + std::string op; + CompareFunctionType compare; + std::unique_ptr<Expression> lhs; + std::unique_ptr<Expression> rhs; + bool needsRuntimeTypeCheck; +}; + +class CollatorComparison : public Expression { +public: + using CompareFunctionType = bool (*) (std::string, std::string, Collator); + + CollatorComparison( + std::string op, + std::unique_ptr<Expression> lhs, + std::unique_ptr<Expression> rhs, + std::unique_ptr<Expression> collator); + + 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; + std::string getOperator() const override; + +private: + std::string op; + CompareFunctionType compare; + std::unique_ptr<Expression> lhs; + std::unique_ptr<Expression> rhs; + std::unique_ptr<Expression> collator; + bool needsRuntimeTypeCheck; +}; + + + +} // namespace expression +} // namespace style +} // namespace mbgl diff --git a/include/mbgl/style/expression/dsl.hpp b/include/mbgl/style/expression/dsl.hpp index e9de20de18..a4483a6fe6 100644 --- a/include/mbgl/style/expression/dsl.hpp +++ b/include/mbgl/style/expression/dsl.hpp @@ -31,6 +31,7 @@ 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> assertion(type::Type, std::unique_ptr<Expression>); std::unique_ptr<Expression> number(std::unique_ptr<Expression>); std::unique_ptr<Expression> string(std::unique_ptr<Expression>); std::unique_ptr<Expression> boolean(std::unique_ptr<Expression>); diff --git a/include/mbgl/style/expression/equals.hpp b/include/mbgl/style/expression/equals.hpp deleted file mode 100644 index 1e8bf7acef..0000000000 --- a/include/mbgl/style/expression/equals.hpp +++ /dev/null @@ -1,35 +0,0 @@ -#pragma once - -#include <mbgl/style/expression/collator_expression.hpp> -#include <mbgl/style/expression/expression.hpp> -#include <mbgl/style/expression/parsing_context.hpp> -#include <mbgl/style/conversion.hpp> - -#include <memory> - -namespace mbgl { -namespace style { -namespace expression { - -class Equals : public Expression { -public: - Equals(std::unique_ptr<Expression> lhs, std::unique_ptr<Expression> rhs, optional<std::unique_ptr<Expression>> collator, bool negate); - - static ParseResult parse(const mbgl::style::conversion::Convertible&, ParsingContext&); - - 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; - - std::string getOperator() const override { return negate ? "!=" : "=="; } -private: - std::unique_ptr<Expression> lhs; - std::unique_ptr<Expression> rhs; - optional<std::unique_ptr<Expression>> collator; - bool negate; -}; - -} // namespace expression -} // namespace style -} // namespace mbgl diff --git a/include/mbgl/style/expression/expression.hpp b/include/mbgl/style/expression/expression.hpp index 8301f1572c..26124f6463 100644 --- a/include/mbgl/style/expression/expression.hpp +++ b/include/mbgl/style/expression/expression.hpp @@ -133,7 +133,7 @@ enum class Kind : int32_t { Case, Any, All, - Equals, + Comparison, }; class Expression { diff --git a/mapbox-gl-js b/mapbox-gl-js -Subproject dc43a09a6e84d7d97af33455594adf7f25dc961 +Subproject 47e637c3984a5121589bd17b51c6605f223aaea diff --git a/src/mbgl/style/expression/comparison.cpp b/src/mbgl/style/expression/comparison.cpp new file mode 100644 index 0000000000..6179c3ce88 --- /dev/null +++ b/src/mbgl/style/expression/comparison.cpp @@ -0,0 +1,275 @@ +#include <mbgl/style/expression/collator.hpp> +#include <mbgl/style/expression/comparison.hpp> +#include <mbgl/style/expression/dsl.hpp> + +namespace mbgl { +namespace style { +namespace expression { + +static bool isComparableType(const std::string& op, const type::Type& type) { + if (op == "==" || op == "!=") { + return type == type::String || + type == type::Number || + type == type::Boolean || + type == type::Null || + type == type::Value; + } else { + return type == type::String || + type == type::Number || + type == type::Value; + } +} + +bool eq(Value a, Value b) { return a == b; } +bool neq(Value a, Value b) { return a != b; } +bool lt(Value lhs, Value rhs) { + return lhs.match( + [&](const std::string& a) { return a < rhs.get<std::string>(); }, + [&](double a) { return a < rhs.get<double>(); }, + [&](const auto&) { assert(false); return false; } + ); +} +bool gt(Value lhs, Value rhs) { + return lhs.match( + [&](const std::string& a) { return a > rhs.get<std::string>(); }, + [&](double a) { return a > rhs.get<double>(); }, + [&](const auto&) { assert(false); return false; } + ); +} +bool lteq(Value lhs, Value rhs) { + return lhs.match( + [&](const std::string& a) { return a <= rhs.get<std::string>(); }, + [&](double a) { return a <= rhs.get<double>(); }, + [&](const auto&) { assert(false); return false; } + ); +} +bool gteq(Value lhs, Value rhs) { + return lhs.match( + [&](const std::string& a) { return a >= rhs.get<std::string>(); }, + [&](double a) { return a >= rhs.get<double>(); }, + [&](const auto&) { assert(false); return false; } + ); +} + +bool eqCollate(std::string a, std::string b, Collator c) { return c.compare(a, b) == 0; } +bool neqCollate(std::string a, std::string b, Collator c) { return !eqCollate(a, b, c); } +bool ltCollate(std::string a, std::string b, Collator c) { return c.compare(a, b) < 0; } +bool gtCollate(std::string a, std::string b, Collator c) { return c.compare(a, b) > 0; } +bool lteqCollate(std::string a, std::string b, Collator c) { return c.compare(a, b) <= 0; } +bool gteqCollate(std::string a, std::string b, Collator c) { return c.compare(a, b) >= 0; } + +static BasicComparison::CompareFunctionType getBasicCompareFunction(const std::string& op) { + if (op == "==") return eq; + else if (op == "!=") return neq; + else if (op == ">") return gt; + else if (op == "<") return lt; + else if (op == ">=") return gteq; + else if (op == "<=") return lteq; + assert(false); + return nullptr; +} + +static CollatorComparison::CompareFunctionType getCollatorComparisonFunction(const std::string& op) { + if (op == "==") return eqCollate; + else if (op == "!=") return neqCollate; + else if (op == ">") return gtCollate; + else if (op == "<") return ltCollate; + else if (op == ">=") return gteqCollate; + else if (op == "<=") return lteqCollate; + assert(false); + return nullptr; + +} + + +BasicComparison::BasicComparison( + std::string op_, + std::unique_ptr<Expression> lhs_, + std::unique_ptr<Expression> rhs_) + : Expression(Kind::Comparison, type::Boolean), + op(std::move(op_)), + compare(getBasicCompareFunction(op)), + lhs(std::move(lhs_)), + rhs(std::move(rhs_)) { + assert(isComparableType(op, lhs->getType()) && isComparableType(op, rhs->getType())); + assert(lhs->getType() == rhs->getType() || lhs->getType() == type::Value || rhs->getType() == type::Value); + + needsRuntimeTypeCheck = (op != "==" && op != "!=") && + (lhs->getType() == type::Value || rhs->getType() == type::Value); +} + +EvaluationResult BasicComparison::evaluate(const EvaluationContext& params) const { + EvaluationResult lhsResult = lhs->evaluate(params); + if (!lhsResult) return lhsResult; + + EvaluationResult rhsResult = rhs->evaluate(params); + if (!rhsResult) return rhsResult; + + if (needsRuntimeTypeCheck) { + type::Type lhsType = typeOf(*lhsResult); + type::Type rhsType = typeOf(*rhsResult); + // check that type is string or number, and equal + if (lhsType != rhsType || !(lhsType == type::String || lhsType == type::Number)) { + return EvaluationError { + R"(Expected arguments for ")" + op + R"(")" + + " to be (string, string) or (number, number), but found (" + toString(lhsType) + ", " + + toString(rhsType) + ") instead." + }; + } + } + + return compare(*lhsResult, *rhsResult); +} + +void BasicComparison::eachChild(const std::function<void(const Expression&)>& visit) const { + visit(*lhs); + visit(*rhs); +} + +std::string BasicComparison::getOperator() const { return op; } + +bool BasicComparison::operator==(const Expression& e) const { + if (e.getKind() == Kind::Comparison) { + auto comp = static_cast<const BasicComparison*>(&e); + return comp->op == op && + *comp->lhs == *lhs && + *comp->rhs == *rhs; + } + return false; +} + +std::vector<optional<Value>> BasicComparison::possibleOutputs() const { + return {{ true }, { false }}; +} + +CollatorComparison::CollatorComparison( + std::string op_, + std::unique_ptr<Expression> lhs_, + std::unique_ptr<Expression> rhs_, + std::unique_ptr<Expression> collator_) + : Expression(Kind::Comparison, type::Boolean), + op(op_), + compare(getCollatorComparisonFunction(op)), + lhs(std::move(lhs_)), + rhs(std::move(rhs_)), + collator(std::move(collator_)) { + assert(isComparableType(op, lhs->getType()) && isComparableType(op, rhs->getType())); + assert(lhs->getType() == rhs->getType() || lhs->getType() == type::Value || rhs->getType() == type::Value); + + needsRuntimeTypeCheck = (op == "==" || op == "!=") && + (lhs->getType() == type::Value || rhs->getType() == type::Value); +} + +EvaluationResult CollatorComparison::evaluate(const EvaluationContext& params) const { + EvaluationResult lhsResult = lhs->evaluate(params); + if (!lhsResult) return lhsResult; + + EvaluationResult rhsResult = rhs->evaluate(params); + if (!rhsResult) return lhsResult; + + if (needsRuntimeTypeCheck) { + if (typeOf(*lhsResult) != type::String || typeOf(*rhsResult) != type::String) { + return getBasicCompareFunction(op)(*lhsResult, *rhsResult); + } + } + + auto collatorResult = collator->evaluate(params); + if (!collatorResult) return collatorResult; + + const Collator& c = collatorResult->get<Collator>(); + return compare(lhsResult->get<std::string>(), rhsResult->get<std::string>(), c); +} + +void CollatorComparison::eachChild(const std::function<void(const Expression&)>& visit) const { + visit(*lhs); + visit(*rhs); + visit(*collator); +} + +std::string CollatorComparison::getOperator() const { return op; } + +bool CollatorComparison::operator==(const Expression& e) const { + if (e.getKind() == Kind::Comparison) { + auto comp = static_cast<const CollatorComparison*>(&e); + return comp->op == op && + *comp->collator == *collator && + *comp->lhs == *lhs && + *comp->rhs == *rhs; + } + return false; +} + +std::vector<optional<Value>> CollatorComparison::possibleOutputs() const { + return {{ true }, { false }}; +} + +using namespace mbgl::style::conversion; +ParseResult parseComparison(const Convertible& value, ParsingContext& ctx) { + std::size_t length = arrayLength(value); + + if (length != 3 && length != 4) { + ctx.error("Expected two or three arguments."); + return ParseResult(); + } + + std::string op = *toString(arrayMember(value, 0)); + + assert(getBasicCompareFunction(op)); + + ParseResult lhs = ctx.parse(arrayMember(value, 1), 1, {type::Value}); + if (!lhs) return ParseResult(); + type::Type lhsType = (*lhs)->getType(); + if (!isComparableType(op, lhsType)) { + ctx.error(R"(")" + op + R"(" comparisons are not supported for type ')" + toString(lhsType) + "'.", 1); + return ParseResult(); + } + + ParseResult rhs = ctx.parse(arrayMember(value, 2), 2, {type::Value}); + if (!rhs) return ParseResult(); + type::Type rhsType = (*rhs)->getType(); + if (!isComparableType(op, rhsType)) { + ctx.error(R"(")" + op + R"(" comparisons are not supported for type ')" + toString(rhsType) + "'.", 2); + return ParseResult(); + } + + if ( + lhsType != rhsType && + lhsType != type::Value && + rhsType != type::Value + ) { + ctx.error("Cannot compare types '" + toString(lhsType) + "' and '" + toString(rhsType) + "'."); + return ParseResult(); + } + + if (op != "==" && op != "!=") { + // typing rules specific to less/greater than operators + if (lhsType == type::Value && rhsType != type::Value) { + // (value, T) + lhs = dsl::assertion(rhsType, std::move(*lhs)); + } else if (lhsType != type::Value && rhsType == type::Value) { + // (T, value) + rhs = dsl::assertion(lhsType, std::move(*rhs)); + } + } + + if (length == 4) { + if ( + lhsType != type::String && + rhsType != type::String && + lhsType != type::Value && + rhsType != type::Value + ) { + ctx.error("Cannot use collator to compare non-string types."); + return ParseResult(); + } + ParseResult collatorParseResult = ctx.parse(arrayMember(value, 3), 3, {type::Collator}); + if (!collatorParseResult) return ParseResult(); + return ParseResult(std::make_unique<CollatorComparison>(op, std::move(*lhs), std::move(*rhs), std::move(*collatorParseResult))); + } + + return ParseResult(std::make_unique<BasicComparison>(op, std::move(*lhs), std::move(*rhs))); +} + +} // namespace expression +} // namespace style +} // namespace mbgl diff --git a/src/mbgl/style/expression/compound_expression.cpp b/src/mbgl/style/expression/compound_expression.cpp index bbb57e19ab..53ce91f0b7 100644 --- a/src/mbgl/style/expression/compound_expression.cpp +++ b/src/mbgl/style/expression/compound_expression.cpp @@ -485,19 +485,6 @@ std::unordered_map<std::string, CompoundExpressionRegistry::Definition> initiali define("ceil", [](double x) -> Result<double> { return std::ceil(x); }); define("abs", [](double x) -> Result<double> { return std::abs(x); }); - define(">", [](double lhs, double rhs) -> Result<bool> { return lhs > rhs; }); - define(">", [](const std::string& lhs, const std::string& rhs) -> Result<bool> { return lhs > rhs; }); - define(">", [](const std::string& lhs, const std::string& rhs, const Collator& c) -> Result<bool> { return c.compare(lhs, rhs) > 0; }); - define(">=", [](double lhs, double rhs) -> Result<bool> { return lhs >= rhs; }); - define(">=",[](const std::string& lhs, const std::string& rhs) -> Result<bool> { return lhs >= rhs; }); - define(">=", [](const std::string& lhs, const std::string& rhs, const Collator& c) -> Result<bool> { return c.compare(lhs, rhs) >= 0; }); - define("<", [](double lhs, double rhs) -> Result<bool> { return lhs < rhs; }); - define("<", [](const std::string& lhs, const std::string& rhs) -> Result<bool> { return lhs < rhs; }); - define("<", [](const std::string& lhs, const std::string& rhs, const Collator& c) -> Result<bool> { return c.compare(lhs, rhs) < 0; }); - define("<=", [](double lhs, double rhs) -> Result<bool> { return lhs <= rhs; }); - define("<=", [](const std::string& lhs, const std::string& rhs) -> Result<bool> { return lhs <= rhs; }); - define("<=", [](const std::string& lhs, const std::string& rhs, const Collator& c) -> Result<bool> { return c.compare(lhs, rhs) <= 0; }); - define("!", [](bool e) -> Result<bool> { return !e; }); define("is-supported-script", [](const std::string& x) -> Result<bool> { diff --git a/src/mbgl/style/expression/dsl.cpp b/src/mbgl/style/expression/dsl.cpp index a851d82e16..cdada583a2 100644 --- a/src/mbgl/style/expression/dsl.cpp +++ b/src/mbgl/style/expression/dsl.cpp @@ -3,7 +3,7 @@ #include <mbgl/style/expression/literal.hpp> #include <mbgl/style/expression/assertion.hpp> #include <mbgl/style/expression/coercion.hpp> -#include <mbgl/style/expression/equals.hpp> +#include <mbgl/style/expression/comparison.hpp> #include <mbgl/style/expression/step.hpp> #include <mbgl/style/expression/interpolate.hpp> #include <mbgl/style/expression/compound_expression.hpp> @@ -53,16 +53,20 @@ std::unique_ptr<Expression> literal(std::initializer_list<const char *> value) { return literal(values); } +std::unique_ptr<Expression> assertion(type::Type type, std::unique_ptr<Expression> value) { + return std::make_unique<Assertion>(type, vec(std::move(value))); +} + std::unique_ptr<Expression> number(std::unique_ptr<Expression> value) { - return std::make_unique<Assertion>(type::Number, vec(std::move(value))); + return assertion(type::Number, std::move(value)); } std::unique_ptr<Expression> string(std::unique_ptr<Expression> value) { - return std::make_unique<Assertion>(type::String, vec(std::move(value))); + return assertion(type::String, std::move(value)); } std::unique_ptr<Expression> boolean(std::unique_ptr<Expression> value) { - return std::make_unique<Assertion>(type::Boolean, vec(std::move(value))); + return assertion(type::Boolean, std::move(value)); } std::unique_ptr<Expression> toColor(std::unique_ptr<Expression> value) { @@ -91,22 +95,22 @@ std::unique_ptr<Expression> zoom() { std::unique_ptr<Expression> eq(std::unique_ptr<Expression> lhs, std::unique_ptr<Expression> rhs) { - return std::make_unique<Equals>(std::move(lhs), std::move(rhs), nullopt, false); + return std::make_unique<BasicComparison>("==", std::move(lhs), std::move(rhs)); } std::unique_ptr<Expression> ne(std::unique_ptr<Expression> lhs, std::unique_ptr<Expression> rhs) { - return std::make_unique<Equals>(std::move(lhs), std::move(rhs), nullopt, true); + return std::make_unique<BasicComparison>("!=", std::move(lhs), std::move(rhs)); } std::unique_ptr<Expression> gt(std::unique_ptr<Expression> lhs, std::unique_ptr<Expression> rhs) { - return compound(">", std::move(lhs), std::move(rhs)); + return std::make_unique<BasicComparison>(">", std::move(lhs), std::move(rhs)); } std::unique_ptr<Expression> lt(std::unique_ptr<Expression> lhs, std::unique_ptr<Expression> rhs) { - return compound("<", std::move(lhs), std::move(rhs)); + return std::make_unique<BasicComparison>("<", std::move(lhs), std::move(rhs)); } std::unique_ptr<Expression> step(std::unique_ptr<Expression> input, diff --git a/src/mbgl/style/expression/equals.cpp b/src/mbgl/style/expression/equals.cpp deleted file mode 100644 index 73e2baf71b..0000000000 --- a/src/mbgl/style/expression/equals.cpp +++ /dev/null @@ -1,113 +0,0 @@ -#include <mbgl/style/expression/collator.hpp> -#include <mbgl/style/expression/equals.hpp> - -namespace mbgl { -namespace style { -namespace expression { - -static bool isComparableType(const type::Type& type) { - return type == type::String || - type == type::Number || - type == type::Boolean || - type == type::Null; -} - -Equals::Equals(std::unique_ptr<Expression> lhs_, std::unique_ptr<Expression> rhs_, optional<std::unique_ptr<Expression>> collator_, bool negate_) - : Expression(Kind::Equals, type::Boolean), - lhs(std::move(lhs_)), - rhs(std::move(rhs_)), - collator(std::move(collator_)), - negate(negate_) { - assert(isComparableType(lhs->getType()) || isComparableType(rhs->getType())); - assert(lhs->getType() == rhs->getType() || lhs->getType() == type::Value || rhs->getType() == type::Value); -} - -EvaluationResult Equals::evaluate(const EvaluationContext& params) const { - EvaluationResult lhsResult = lhs->evaluate(params); - if (!lhsResult) return lhsResult; - - EvaluationResult rhsResult = rhs->evaluate(params); - if (!rhsResult) return lhsResult; - - bool result; - - if (collator) { - auto collatorResult = (*collator)->evaluate(params); - const Collator& c = collatorResult->get<Collator>(); - result = c.compare(lhsResult->get<std::string>(), rhsResult->get<std::string>()) == 0; - } else { - result = *lhsResult == *rhsResult; - } - if (negate) { - result = !result; - } - return result; -} - -void Equals::eachChild(const std::function<void(const Expression&)>& visit) const { - visit(*lhs); - visit(*rhs); - if (collator) { - visit(**collator); - } -} - -bool Equals::operator==(const Expression& e) const { - if (e.getKind() == Kind::Equals) { - auto eq = static_cast<const Equals*>(&e); - return eq->negate == negate && *eq->lhs == *lhs && *eq->rhs == *rhs; - } - return false; -} - -std::vector<optional<Value>> Equals::possibleOutputs() const { - return {{ true }, { false }}; -} - -using namespace mbgl::style::conversion; -ParseResult Equals::parse(const Convertible& value, ParsingContext& ctx) { - std::size_t length = arrayLength(value); - - if (length != 3 && length != 4) { - ctx.error("Expected two or three arguments."); - return ParseResult(); - } - - bool negate = toString(arrayMember(value, 0)) == std::string("!="); - - ParseResult lhs = ctx.parse(arrayMember(value, 1), 1, {type::Value}); - if (!lhs) return ParseResult(); - - ParseResult rhs = ctx.parse(arrayMember(value, 2), 2, {type::Value}); - if (!rhs) return ParseResult(); - - type::Type lhsType = (*lhs)->getType(); - type::Type rhsType = (*rhs)->getType(); - - if (!isComparableType(lhsType) && !isComparableType(rhsType)) { - ctx.error("Expected at least one argument to be a string, number, boolean, or null, but found (" + - toString(lhsType) + ", " + toString(rhsType) + ") instead."); - return ParseResult(); - } - - if (lhsType != rhsType && lhsType != type::Value && rhsType != type::Value) { - ctx.error("Cannot compare " + toString(lhsType) + " and " + toString(rhsType) + "."); - return ParseResult(); - } - - ParseResult collatorParseResult; - if (length == 4) { - if (lhsType != type::String && rhsType != type::String) { - ctx.error("Cannot use collator to compare non-string types."); - return ParseResult(); - } - collatorParseResult = ctx.parse(arrayMember(value, 3), 3, {type::Collator}); - if (!collatorParseResult) return ParseResult(); - } - - return ParseResult(std::make_unique<Equals>(std::move(*lhs), std::move(*rhs), std::move(collatorParseResult), negate)); -} - -} // namespace expression -} // namespace style -} // namespace mbgl diff --git a/src/mbgl/style/expression/parsing_context.cpp b/src/mbgl/style/expression/parsing_context.cpp index 979eb58236..b3f6b1acee 100644 --- a/src/mbgl/style/expression/parsing_context.cpp +++ b/src/mbgl/style/expression/parsing_context.cpp @@ -13,7 +13,7 @@ #include <mbgl/style/expression/coalesce.hpp> #include <mbgl/style/expression/coercion.hpp> #include <mbgl/style/expression/compound_expression.hpp> -#include <mbgl/style/expression/equals.hpp> +#include <mbgl/style/expression/comparison.hpp> #include <mbgl/style/expression/interpolate.hpp> #include <mbgl/style/expression/length.hpp> #include <mbgl/style/expression/let.hpp> @@ -95,8 +95,12 @@ ParseResult ParsingContext::parse(const Convertible& value, std::size_t index_, const ExpressionRegistry& getExpressionRegistry() { static ExpressionRegistry registry {{ - {"==", Equals::parse}, - {"!=", Equals::parse}, + {"==", parseComparison}, + {"!=", parseComparison}, + {">", parseComparison}, + {"<", parseComparison}, + {">=", parseComparison}, + {"<=", parseComparison}, {"all", All::parse}, {"any", Any::parse}, {"array", ArrayAssertion::parse}, |