wip - add Expression::operator==()

19 files changed, 239 insertions, 5 deletions

diff --git a/include/mbgl/style/expression/array_assertion.hpp b/include/mbgl/style/expression/array_assertion.hpp
index d7b0f786cc..a86426737d 100644
--- a/include/mbgl/style/expression/array_assertion.hpp
+++ b/include/mbgl/style/expression/array_assertion.hpp
@@ -23,6 +23,13 @@ public:
     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 {
+        if (auto rhs = dynamic_cast<const ArrayAssertion*>(&e)) {
+            return getType() == rhs->getType() && *input == *(rhs->input);
+        }
+        return false;
+    }
+
 private:
     std::unique_ptr<Expression> input;
 };
diff --git a/include/mbgl/style/expression/assertion.hpp b/include/mbgl/style/expression/assertion.hpp
index e572f7a6f9..804f236a35 100644
--- a/include/mbgl/style/expression/assertion.hpp
+++ b/include/mbgl/style/expression/assertion.hpp
@@ -20,6 +20,20 @@ public:
 
     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 {
+        if (auto rhs = dynamic_cast<const Assertion*>(&e)) {
+            if (getType() != rhs->getType() || inputs.size() != rhs->inputs.size()) return false;
+            for (auto leftChild = inputs.begin(), rightChild = rhs->inputs.begin();
+                 leftChild != inputs.end();
+                 leftChild++, rightChild++)
+             {
+                 if (**leftChild != **rightChild) return false;
+             }
+             return true;
+        }
+        return false;
+    }
 
 private:
     std::vector<std::unique_ptr<Expression>> inputs;
diff --git a/include/mbgl/style/expression/at.hpp b/include/mbgl/style/expression/at.hpp
index 171c8ec9b1..a19b29d9af 100644
--- a/include/mbgl/style/expression/at.hpp
+++ b/include/mbgl/style/expression/at.hpp
@@ -21,6 +21,13 @@ public:
     EvaluationResult evaluate(const EvaluationContext& params) const override;
     void eachChild(const std::function<void(const Expression*)>&) const override;
 
+    bool operator==(const Expression& e) const override {
+        if (auto rhs = dynamic_cast<const At*>(&e)) {
+            return *index == *(rhs->index) && *input == *(rhs->input);
+        }
+        return false;
+    }
+
 private:
     std::unique_ptr<Expression> index;
     std::unique_ptr<Expression> input;
diff --git a/include/mbgl/style/expression/boolean_operator.hpp b/include/mbgl/style/expression/boolean_operator.hpp
index 4e025c5d2d..e95c8ba5db 100644
--- a/include/mbgl/style/expression/boolean_operator.hpp
+++ b/include/mbgl/style/expression/boolean_operator.hpp
@@ -20,6 +20,20 @@ public:
     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 {
+        if (auto rhs = dynamic_cast<const Any*>(&e)) {
+            if (inputs.size() != rhs->inputs.size()) return false;
+            for (auto leftChild = inputs.begin(), rightChild = rhs->inputs.begin();
+                 leftChild != inputs.end();
+                 leftChild++, rightChild++)
+             {
+                 if (**leftChild != **rightChild) return false;
+             }
+             return true;
+        }
+        return false;
+    }
+
 private:
     std::vector<std::unique_ptr<Expression>> inputs;
 };
@@ -36,6 +50,20 @@ public:
     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 {
+        if (auto rhs = dynamic_cast<const All*>(&e)) {
+            if (inputs.size() != rhs->inputs.size()) return false;
+            for (auto leftChild = inputs.begin(), rightChild = rhs->inputs.begin();
+                 leftChild != inputs.end();
+                 leftChild++, rightChild++)
+             {
+                 if (**leftChild != **rightChild) return false;
+             }
+             return true;
+        }
+        return false;
+    }
+
 private:
     std::vector<std::unique_ptr<Expression>> inputs;
 };
diff --git a/include/mbgl/style/expression/case.hpp b/include/mbgl/style/expression/case.hpp
index 26d030aed6..9641448c65 100644
--- a/include/mbgl/style/expression/case.hpp
+++ b/include/mbgl/style/expression/case.hpp
@@ -23,6 +23,24 @@ public:
 
     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 {
+        if (auto rhs = dynamic_cast<const Case*>(&e)) {
+            if (branches.size() != rhs->branches.size() || *otherwise != *(rhs->otherwise)) return false;
+            for (auto leftChild = branches.begin(), rightChild = rhs->branches.begin();
+                 leftChild != branches.end();
+                 leftChild++, rightChild++)
+             {
+                 if (*(leftChild->first) != *(rightChild->first) ||
+                     *(leftChild->second) != *(rightChild->second))
+                 {
+                     return false;
+                 }
+             }
+             return true;
+        }
+        return false;
+    }
 
 private:
     std::vector<Branch> branches;
diff --git a/include/mbgl/style/expression/coalesce.hpp b/include/mbgl/style/expression/coalesce.hpp
index f32949ea76..9768f66204 100644
--- a/include/mbgl/style/expression/coalesce.hpp
+++ b/include/mbgl/style/expression/coalesce.hpp
@@ -26,6 +26,20 @@ public:
     
     void eachChild(const std::function<void(const Expression*)>& visit) const override;
 
+    bool operator==(const Expression& e) const override {
+        if (auto rhs = dynamic_cast<const Coalesce*>(&e)) {
+            if (getType() != rhs->getType() || args.size() != rhs->args.size()) return false;
+            for (auto leftChild = args.begin(), rightChild = rhs->args.begin();
+                 leftChild != args.end();
+                 leftChild++, rightChild++)
+             {
+                 if (**leftChild != **rightChild) return false;
+             }
+             return true;
+        }
+        return false;
+    }
+    
     std::size_t getLength() const {
         return args.size();
     }
diff --git a/include/mbgl/style/expression/coercion.hpp b/include/mbgl/style/expression/coercion.hpp
index 65bd1aab58..a1800cb916 100644
--- a/include/mbgl/style/expression/coercion.hpp
+++ b/include/mbgl/style/expression/coercion.hpp
@@ -22,6 +22,19 @@ public:
     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 {
+        if (auto rhs = dynamic_cast<const Coercion*>(&e)) {
+            if (getType() != rhs->getType() || inputs.size() != rhs->inputs.size()) return false;
+            for (auto leftChild = inputs.begin(), rightChild = rhs->inputs.begin();
+                 leftChild != inputs.end();
+                 leftChild++, rightChild++)
+             {
+                 if (**leftChild != **rightChild) return false;
+             }
+             return true;
+        }
+        return false;
+    }
 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
index 909927e299..a34ea13cea 100644
--- a/include/mbgl/style/expression/compound_expression.hpp
+++ b/include/mbgl/style/expression/compound_expression.hpp
@@ -100,6 +100,25 @@ public:
             visit(e.get());
         }
     }
+
+    bool operator==(const Expression& e) const override {
+        if (auto rhs = dynamic_cast<const CompoundExpression*>(&e)) {
+            if (getName() != rhs->getName() ||
+                args.size() != rhs->args.size())
+            {
+                return false;
+            }
+            
+            for (auto leftChild = args.begin(), rightChild = rhs->args.begin();
+                 leftChild != args.end();
+                 leftChild++, rightChild++)
+             {
+                 if (**leftChild != **rightChild) return false;
+             }
+             return true;
+        }
+        return false;
+    }
     
 private:
     Signature signature;
diff --git a/include/mbgl/style/expression/expression.hpp b/include/mbgl/style/expression/expression.hpp
index 929134d473..9bee02a49c 100644
--- a/include/mbgl/style/expression/expression.hpp
+++ b/include/mbgl/style/expression/expression.hpp
@@ -115,6 +115,10 @@ public:
     
     virtual EvaluationResult evaluate(const EvaluationContext& params) const = 0;
     virtual void eachChild(const std::function<void(const Expression*)>&) const = 0;
+    virtual bool operator==(const Expression&) const = 0;
+    bool operator!=(const Expression& rhs) const {
+        return !operator==(rhs);
+    }
 
     type::Type getType() const { return type; };
     
diff --git a/include/mbgl/style/expression/interpolate.hpp b/include/mbgl/style/expression/interpolate.hpp
index 8d11bbcb05..5e9842e774 100644
--- a/include/mbgl/style/expression/interpolate.hpp
+++ b/include/mbgl/style/expression/interpolate.hpp
@@ -32,6 +32,10 @@ public:
                                          },
                                          input);
     }
+    
+    bool operator==(const ExponentialInterpolator& rhs) const {
+        return base == rhs.base;
+    }
 };
 
 class CubicBezierInterpolator {
@@ -42,6 +46,10 @@ public:
         return ub.solve(input / (inputLevels.max - inputLevels.min), 1e-6);
     }
     
+    bool operator==(const CubicBezierInterpolator& rhs) const {
+        return ub == rhs.ub;
+    }
+    
     util::UnitBezier ub;
 };
 
@@ -111,6 +119,30 @@ public:
         }
     }
     
+    bool operator==(const Expression& e) const override {
+        if (auto rhs = dynamic_cast<const Interpolate*>(&e)) {
+            if (interpolator != rhs->interpolator ||
+                *input != *(rhs->input) ||
+                stops.size() != rhs->stops.size())
+            {
+                return false;
+            }
+            
+            for (auto leftChild = stops.begin(), rightChild = rhs->stops.begin();
+                 leftChild != stops.end();
+                 leftChild++, rightChild++)
+             {
+                 if (leftChild->first != rightChild->first ||
+                     *(leftChild->second) != *(rightChild->second))
+                 {
+                     return false;
+                 }
+             }
+             return true;
+        }
+        return false;
+    }
+    
     const std::unique_ptr<Expression>& getInput() const { return input; }
 
     // Return the smallest range of stops that covers the interval [lower, upper]
diff --git a/include/mbgl/style/expression/let.hpp b/include/mbgl/style/expression/let.hpp
index a9356853df..6c63e6ab64 100644
--- a/include/mbgl/style/expression/let.hpp
+++ b/include/mbgl/style/expression/let.hpp
@@ -25,7 +25,14 @@ public:
     
     EvaluationResult evaluate(const EvaluationContext& params) const override;
     void eachChild(const std::function<void(const Expression*)>&) const override;
-    
+
+    bool operator==(const Expression& e) const override {
+        if (auto rhs = dynamic_cast<const Let*>(&e)) {
+            return *result == *(rhs->result);
+        }
+        return false;
+    }
+
     Expression* getResult() const {
         return result.get();
     }
@@ -48,6 +55,13 @@ public:
     EvaluationResult evaluate(const EvaluationContext& params) const override;
     void eachChild(const std::function<void(const Expression*)>&) const override;
 
+    bool operator==(const Expression& e) const override {
+        if (auto rhs = dynamic_cast<const Var*>(&e)) {
+            return *value == *(rhs->value);
+        }
+        return false;
+    }
+    
 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
index 34d539fedf..4a94aa9221 100644
--- a/include/mbgl/style/expression/literal.hpp
+++ b/include/mbgl/style/expression/literal.hpp
@@ -22,6 +22,13 @@ public:
 
     void eachChild(const std::function<void(const Expression*)>&) const override {}
     
+    bool operator==(const Expression& e) const override {
+        if (auto rhs = dynamic_cast<const Literal*>(&e)) {
+            return value == rhs->value;
+        }
+        return false;
+    }
+    
 private:
     Value value;
 };
diff --git a/include/mbgl/style/expression/match.hpp b/include/mbgl/style/expression/match.hpp
index 01c0db5bf5..5012658682 100644
--- a/include/mbgl/style/expression/match.hpp
+++ b/include/mbgl/style/expression/match.hpp
@@ -27,6 +27,30 @@ public:
 
     void eachChild(const std::function<void(const Expression*)>& visit) const override;
 
+    bool operator==(const Expression& e) const override {
+        if (auto rhs = dynamic_cast<const Match*>(&e)) {
+            if (*input != *(rhs->input) ||
+                *otherwise != *(rhs->otherwise) ||
+                branches.size() != rhs->branches.size())
+            {
+                return false;
+            }
+            
+            for (auto leftChild = branches.begin(), rightChild = rhs->branches.begin();
+                 leftChild != branches.end();
+                 leftChild++, rightChild++)
+             {
+                 if (leftChild->first != rightChild->first ||
+                     *(leftChild->second) != *(rightChild->second))
+                 {
+                     return false;
+                 }
+             }
+             return true;
+        }
+        return false;
+    }
+
     EvaluationResult evaluate(const EvaluationContext& params) const override;
     
 private:
diff --git a/include/mbgl/style/expression/step.hpp b/include/mbgl/style/expression/step.hpp
index 81e1aef4e9..bb66f8e981 100644
--- a/include/mbgl/style/expression/step.hpp
+++ b/include/mbgl/style/expression/step.hpp
@@ -30,7 +30,30 @@ public:
 
     const std::unique_ptr<Expression>& getInput() const { return input; }
     Range<float> getCoveringStops(const double lower, const double upper) const;
-    
+
+    bool operator==(const Expression& e) const override {
+        if (auto rhs = dynamic_cast<const Step*>(&e)) {
+            if (*input != *(rhs->input) ||
+                stops.size() != rhs->stops.size())
+            {
+                return false;
+            }
+            
+            for (auto leftChild = stops.begin(), rightChild = rhs->stops.begin();
+                 leftChild != stops.end();
+                 leftChild++, rightChild++)
+             {
+                 if (leftChild->first != rightChild->first ||
+                     *(leftChild->second) != *(rightChild->second))
+                 {
+                     return false;
+                 }
+             }
+             return true;
+        }
+        return false;
+    }
+
     static ParseResult parse(const mbgl::style::conversion::Convertible& value, ParsingContext& ctx);
 
 private:
diff --git a/include/mbgl/style/function/camera_function.hpp b/include/mbgl/style/function/camera_function.hpp
index 1394c5eb8d..14a874cdfc 100644
--- a/include/mbgl/style/function/camera_function.hpp
+++ b/include/mbgl/style/function/camera_function.hpp
@@ -71,7 +71,7 @@ public:
     
     friend bool operator==(const CameraFunction& lhs,
                            const CameraFunction& rhs) {
-        return lhs.expression == rhs.expression;
+        return *lhs.expression == *rhs.expression;
     }
 
     bool useIntegerZoom = false;
diff --git a/include/mbgl/style/function/composite_function.hpp b/include/mbgl/style/function/composite_function.hpp
index ad9c2e83de..55bdaacd48 100644
--- a/include/mbgl/style/function/composite_function.hpp
+++ b/include/mbgl/style/function/composite_function.hpp
@@ -106,7 +106,7 @@ public:
 
     friend bool operator==(const CompositeFunction& lhs,
                            const CompositeFunction& rhs) {
-        return lhs.expression == rhs.expression;
+        return *lhs.expression == *rhs.expression;
     }
 
     std::string property;
diff --git a/include/mbgl/style/function/convert.hpp b/include/mbgl/style/function/convert.hpp
index 82537f5bfa..a16b37a13e 100644
--- a/include/mbgl/style/function/convert.hpp
+++ b/include/mbgl/style/function/convert.hpp
@@ -36,6 +36,10 @@ class ErrorExpression : public Expression {
 public:
     ErrorExpression(std::string message_) : Expression(type::Error), message(std::move(message_)) {}
     void eachChild(const std::function<void(const Expression*)>&) const override {}
+    
+    bool operator==(const Expression& e) const override {
+        return dynamic_cast<const ErrorExpression*>(&e);
+    }
 
     EvaluationResult evaluate(const EvaluationContext&) const override {
         return EvaluationError{message};
diff --git a/include/mbgl/style/function/source_function.hpp b/include/mbgl/style/function/source_function.hpp
index bdef9633b7..49018d2ddd 100644
--- a/include/mbgl/style/function/source_function.hpp
+++ b/include/mbgl/style/function/source_function.hpp
@@ -59,7 +59,7 @@ public:
 
     friend bool operator==(const SourceFunction& lhs,
                            const SourceFunction& rhs) {
-        return lhs.expression == rhs.expression;
+        return *lhs.expression == *rhs.expression;
     }
 
     bool useIntegerZoom = false;
diff --git a/include/mbgl/util/unitbezier.hpp b/include/mbgl/util/unitbezier.hpp
index 6e644e2d1f..92f23d6718 100644
--- a/include/mbgl/util/unitbezier.hpp
+++ b/include/mbgl/util/unitbezier.hpp
@@ -26,6 +26,7 @@
 #pragma once
 
 #include <cmath>
+#include <tuple>
 
 namespace mbgl {
 namespace util {
@@ -102,6 +103,11 @@ struct UnitBezier {
     double solve(double x, double epsilon) const {
         return sampleCurveY(solveCurveX(x, epsilon));
     }
+    
+    bool operator==(const UnitBezier& rhs) const {
+        return std::tie(cx, bx, ax, cy, by, ay) ==
+            std::tie(rhs.cx, rhs.bx, rhs.ax, rhs.cy, rhs.by, rhs.ay);
+    }
 
 private:
     const double cx;