From bf7785618ac5f3bbcba068e61ef6359d70aff92b Mon Sep 17 00:00:00 2001 From: John Firebaugh Date: Wed, 25 Jul 2018 18:15:24 -0700 Subject: [core] Simplify CompoundExpression implementation --- .../mbgl/style/expression/compound_expression.hpp | 119 ++++----------------- include/mbgl/style/expression/is_constant.hpp | 4 +- 2 files changed, 21 insertions(+), 102 deletions(-) (limited to 'include/mbgl') diff --git a/include/mbgl/style/expression/compound_expression.hpp b/include/mbgl/style/expression/compound_expression.hpp index c618f2f206..ef10dadb55 100644 --- a/include/mbgl/style/expression/compound_expression.hpp +++ b/include/mbgl/style/expression/compound_expression.hpp @@ -5,9 +5,7 @@ #include #include #include - #include -#include #include #include @@ -16,115 +14,34 @@ namespace mbgl { namespace style { namespace expression { +namespace detail { +struct SignatureBase; +} // namespace detail + /* CompoundExpression provides a mechanism for implementing an expression simply by providing a list of pure functions of the form (const T0& arg0, const T1& arg1, ...) -> Result where T0, T1, ..., U are member types of mbgl::style::expression::Value. - + The majority of expressions specified in the style-spec are implemented in this fashion (see compound_expression.cpp). */ - - -/* - Represents the parameter list for an expression that takes an arbitrary - number of arguments (of a specific type). -*/ -struct VarargsType { type::Type type; }; -template -struct Varargs : std::vector { - template - Varargs(Args&&... args) : std::vector(std::forward(args)...) {} -}; - -namespace detail { -// Base class for the Signature structs that are used to determine -// each CompoundExpression definition's type::Type data from the type of its -// "evaluate" function. -struct SignatureBase { - SignatureBase(type::Type result_, variant, VarargsType> params_, std::string name_) : - result(std::move(result_)), - params(std::move(params_)), - name(std::move(name_)) - {} - virtual ~SignatureBase() = default; - virtual std::unique_ptr makeExpression(std::vector>) const = 0; - type::Type result; - variant, VarargsType> params; - std::string name; -}; -} // namespace detail - - -/* - Common base class for CompoundExpression instances. Used to - allow downcasting (and access to things like name & parameter list) during - an Expression tree traversal. -*/ -class CompoundExpressionBase : public Expression { +class CompoundExpression : public Expression { public: - CompoundExpressionBase(std::string name_, const detail::SignatureBase& signature) : - Expression(Kind::CompoundExpression, signature.result), - name(std::move(name_)), - params(signature.params) - {} + CompoundExpression(const detail::SignatureBase&, std::vector>); - std::string getName() const { return name; } - optional getParameterCount() const { - return params.match( - [&](const VarargsType&) { return optional(); }, - [&](const std::vector& p) -> optional { return p.size(); } - ); - } - - std::vector> possibleOutputs() const override { - return { nullopt }; - } - -private: - std::string name; - variant, VarargsType> params; -}; - -template -class CompoundExpression : public CompoundExpressionBase { -public: - using Args = typename Signature::Args; - - CompoundExpression(const std::string& name_, - Signature signature_, - typename Signature::Args args_) : - CompoundExpressionBase(name_, signature_), - signature(signature_), - args(std::move(args_)) - {} - - EvaluationResult evaluate(const EvaluationContext& evaluationParams) const override { - return signature.apply(evaluationParams, args); - } - - void eachChild(const std::function& visit) const override { - for (const std::unique_ptr& e : args) { - visit(*e); - } - } + std::string getOperator() const override; + EvaluationResult evaluate(const EvaluationContext& evaluationParams) const override; + std::vector> possibleOutputs() const override; + void eachChild(const std::function& visit) const override; + bool operator==(const Expression& e) const override; - bool operator==(const Expression& e) const override { - if (e.getKind() == Kind::CompoundExpression) { - auto rhs = static_cast(&e); - return getName() == rhs->getName() && Expression::childrenEqual(args, rhs->args); - } - return false; - } - - std::string getOperator() const override { - return signature.name; - } + optional getParameterCount() const; -private: - Signature signature; - typename Signature::Args args; +protected: + const detail::SignatureBase& signature; + std::vector> args; }; /* @@ -136,7 +53,9 @@ struct CompoundExpressionRegistry { static std::unordered_map definitions; }; -ParseResult parseCompoundExpression(const std::string name, const mbgl::style::conversion::Convertible& value, ParsingContext& ctx); +ParseResult parseCompoundExpression(const std::string name, + const mbgl::style::conversion::Convertible& value, + ParsingContext& ctx); ParseResult createCompoundExpression(const std::string& name, std::vector> args, diff --git a/include/mbgl/style/expression/is_constant.hpp b/include/mbgl/style/expression/is_constant.hpp index 065fa30db1..bd758977d8 100644 --- a/include/mbgl/style/expression/is_constant.hpp +++ b/include/mbgl/style/expression/is_constant.hpp @@ -10,9 +10,9 @@ namespace expression { template bool isGlobalPropertyConstant(const Expression& expression, const T& properties) { if (expression.getKind() == Kind::CompoundExpression) { - auto e = static_cast(&expression); + auto e = static_cast(&expression); for (const std::string& property : properties) { - if (e->getName() == property) { + if (e->getOperator() == property) { return false; } } -- cgit v1.2.1