Clean up operator==() implementation

17 files changed, 108 insertions, 152 deletions

diff --git a/include/mbgl/style/expression/assertion.hpp b/include/mbgl/style/expression/assertion.hpp
index 804f236a35..7d26e87f5f 100644
--- a/include/mbgl/style/expression/assertion.hpp
+++ b/include/mbgl/style/expression/assertion.hpp
@@ -21,19 +21,7 @@ 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;
-    }
+    bool operator==(const Expression& e) const override;
 
 private:
     std::vector<std::unique_ptr<Expression>> inputs;
diff --git a/include/mbgl/style/expression/boolean_operator.hpp b/include/mbgl/style/expression/boolean_operator.hpp
index e95c8ba5db..b9abe10664 100644
--- a/include/mbgl/style/expression/boolean_operator.hpp
+++ b/include/mbgl/style/expression/boolean_operator.hpp
@@ -19,20 +19,7 @@ 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;
-    }
+    bool operator==(const Expression& e) const override;
 
 private:
     std::vector<std::unique_ptr<Expression>> inputs;
@@ -50,19 +37,7 @@ 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;
-    }
+    bool operator==(const Expression& e) const override;
 
 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 9641448c65..fecee891f9 100644
--- a/include/mbgl/style/expression/case.hpp
+++ b/include/mbgl/style/expression/case.hpp
@@ -24,23 +24,7 @@ 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;
-    }
+    bool operator==(const Expression& e) const override;
 
 private:
     std::vector<Branch> branches;
diff --git a/include/mbgl/style/expression/coalesce.hpp b/include/mbgl/style/expression/coalesce.hpp
index 9768f66204..ef169faa19 100644
--- a/include/mbgl/style/expression/coalesce.hpp
+++ b/include/mbgl/style/expression/coalesce.hpp
@@ -26,19 +26,7 @@ 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;
-    }
+    bool operator==(const Expression& e) const override;
     
     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 a1800cb916..5b0889475e 100644
--- a/include/mbgl/style/expression/coercion.hpp
+++ b/include/mbgl/style/expression/coercion.hpp
@@ -22,19 +22,7 @@ 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;
-    }
+    bool operator==(const Expression& e) 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
index a34ea13cea..b19e7fe4d4 100644
--- a/include/mbgl/style/expression/compound_expression.hpp
+++ b/include/mbgl/style/expression/compound_expression.hpp
@@ -103,19 +103,7 @@ public:
 
     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 getName() == rhs->getName() && Expression::childrenEqual(args, rhs->args);
         }
         return false;
     }
diff --git a/include/mbgl/style/expression/expression.hpp b/include/mbgl/style/expression/expression.hpp
index 9bee02a49c..5999352ce2 100644
--- a/include/mbgl/style/expression/expression.hpp
+++ b/include/mbgl/style/expression/expression.hpp
@@ -123,6 +123,43 @@ public:
     type::Type getType() const { return type; };
     
     EvaluationResult evaluate(optional<float> zoom, const Feature& feature, optional<double> heatmapDensity) const;
+
+protected:
+    template <typename T>
+    static bool childrenEqual(const T& lhs, const T& rhs) {
+        if (lhs.size() != rhs.size()) return false;
+        for (auto leftChild = lhs.begin(), rightChild = rhs.begin();
+             leftChild != lhs.end();
+             leftChild++, rightChild++)
+         {
+             if (!Expression::childEqual(*leftChild, *rightChild)) return false;
+         }
+         return true;
+    }
+    
+    static bool childEqual(const std::unique_ptr<Expression>& lhs, const std::unique_ptr<Expression>& rhs) {
+        return *lhs == *rhs;
+    }
+    
+    template <typename T>
+    static bool childEqual(const std::pair<T, std::unique_ptr<Expression>>& lhs,
+                           const std::pair<T, std::unique_ptr<Expression>>& rhs) {
+        return lhs.first == rhs.first && *(lhs.second) == *(rhs.second);
+    }
+    
+    template <typename T>
+    static bool childEqual(const std::pair<T, std::shared_ptr<Expression>>& lhs,
+                           const std::pair<T, std::shared_ptr<Expression>>& rhs) {
+        return lhs.first == rhs.first && *(lhs.second) == *(rhs.second);
+    }
+    
+    static bool childEqual(const std::pair<std::unique_ptr<Expression>, std::unique_ptr<Expression>>& lhs,
+                           const std::pair<std::unique_ptr<Expression>, std::unique_ptr<Expression>>& rhs) {
+        return *(lhs.first) == *(rhs.first) && *(lhs.second) == *(rhs.second);
+    }
+    
+    
+
 private:
     type::Type type;
 };
diff --git a/include/mbgl/style/expression/interpolate.hpp b/include/mbgl/style/expression/interpolate.hpp
index 5e9842e774..b0b93ce911 100644
--- a/include/mbgl/style/expression/interpolate.hpp
+++ b/include/mbgl/style/expression/interpolate.hpp
@@ -128,17 +128,7 @@ public:
                 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 Expression::childrenEqual(stops, rhs->stops);
         }
         return false;
     }
diff --git a/include/mbgl/style/expression/match.hpp b/include/mbgl/style/expression/match.hpp
index 5012658682..83b2764976 100644
--- a/include/mbgl/style/expression/match.hpp
+++ b/include/mbgl/style/expression/match.hpp
@@ -27,29 +27,7 @@ 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;
-    }
+    bool operator==(const Expression& e) const override;
 
     EvaluationResult evaluate(const EvaluationContext& params) const override;
     
diff --git a/include/mbgl/style/expression/step.hpp b/include/mbgl/style/expression/step.hpp
index bb66f8e981..1884c75071 100644
--- a/include/mbgl/style/expression/step.hpp
+++ b/include/mbgl/style/expression/step.hpp
@@ -31,28 +31,7 @@ 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;
-    }
+    bool operator==(const Expression& e) const override;
 
     static ParseResult parse(const mbgl::style::conversion::Convertible& value, ParsingContext& ctx);
 
diff --git a/src/mbgl/style/expression/assertion.cpp b/src/mbgl/style/expression/assertion.cpp
index 8086127e3b..3e57377ece 100644
--- a/src/mbgl/style/expression/assertion.cpp
+++ b/src/mbgl/style/expression/assertion.cpp
@@ -59,6 +59,13 @@ void Assertion::eachChild(const std::function<void(const Expression*)>& visit) c
     }
 };
 
+bool Assertion::operator==(const Expression& e) const {
+    if (auto rhs = dynamic_cast<const Assertion*>(&e)) {
+        return getType() == rhs->getType() && Expression::childrenEqual(inputs, rhs->inputs);
+    }
+    return false;
+}
+
 } // namespace expression
 } // namespace style
 } // namespace mbgl
diff --git a/src/mbgl/style/expression/boolean_operator.cpp b/src/mbgl/style/expression/boolean_operator.cpp
index c960d5d79a..b5e1c39683 100644
--- a/src/mbgl/style/expression/boolean_operator.cpp
+++ b/src/mbgl/style/expression/boolean_operator.cpp
@@ -19,6 +19,14 @@ void Any::eachChild(const std::function<void(const Expression*)>& visit) const {
     }
 }
 
+bool Any::operator==(const Expression& e) const {
+    if (auto rhs = dynamic_cast<const Any*>(&e)) {
+        return Expression::childrenEqual(inputs, rhs->inputs);
+    }
+    return false;
+}
+
+
 EvaluationResult All::evaluate(const EvaluationContext& params) const {
     for (auto it = inputs.begin(); it != inputs.end(); it++) {
         const EvaluationResult result = (*it)->evaluate(params);
@@ -34,6 +42,13 @@ void All::eachChild(const std::function<void(const Expression*)>& visit) const {
     }
 }
 
+bool All::operator==(const Expression& e) const {
+    if (auto rhs = dynamic_cast<const All*>(&e)) {
+        return Expression::childrenEqual(inputs, rhs->inputs);
+    }
+    return false;
+}
+
 using namespace mbgl::style::conversion;
 
 template <class T>
diff --git a/src/mbgl/style/expression/case.cpp b/src/mbgl/style/expression/case.cpp
index 1d2fd70978..54175cba9a 100644
--- a/src/mbgl/style/expression/case.cpp
+++ b/src/mbgl/style/expression/case.cpp
@@ -26,6 +26,13 @@ void Case::eachChild(const std::function<void(const Expression*)>& visit) const
     visit(otherwise.get());
 }
 
+bool Case::operator==(const Expression& e) const {
+    if (auto rhs = dynamic_cast<const Case*>(&e)) {
+        return *otherwise == *(rhs->otherwise) && Expression::childrenEqual(branches, rhs->branches);
+    }
+    return false;
+}
+
 using namespace mbgl::style::conversion;
 ParseResult Case::parse(const Convertible& value, ParsingContext& ctx) {
     assert(isArray(value));
diff --git a/src/mbgl/style/expression/coalesce.cpp b/src/mbgl/style/expression/coalesce.cpp
index 54ac0fa499..72097c5bf4 100644
--- a/src/mbgl/style/expression/coalesce.cpp
+++ b/src/mbgl/style/expression/coalesce.cpp
@@ -19,6 +19,13 @@ void Coalesce::eachChild(const std::function<void(const Expression*)>& visit) co
     }
 }
 
+bool Coalesce::operator==(const Expression& e) const {
+    if (auto rhs = dynamic_cast<const Coalesce*>(&e)) {
+        return Expression::childrenEqual(args, rhs->args);
+    }
+    return false;
+}
+
 using namespace mbgl::style::conversion;
 ParseResult Coalesce::parse(const Convertible& value, ParsingContext& ctx) {
     assert(isArray(value));
diff --git a/src/mbgl/style/expression/coercion.cpp b/src/mbgl/style/expression/coercion.cpp
index 7b100163c1..9945d8d3d9 100644
--- a/src/mbgl/style/expression/coercion.cpp
+++ b/src/mbgl/style/expression/coercion.cpp
@@ -128,6 +128,13 @@ void Coercion::eachChild(const std::function<void(const Expression*)>& visit) co
     }
 };
 
+bool Coercion::operator==(const Expression& e) const {
+    if (auto rhs = dynamic_cast<const Coercion*>(&e)) {
+        return getType() == rhs->getType() && Expression::childrenEqual(inputs, rhs->inputs);
+    }
+    return false;
+}
+
 } // namespace expression
 } // namespace style
 } // namespace mbgl
diff --git a/src/mbgl/style/expression/match.cpp b/src/mbgl/style/expression/match.cpp
index 22f6a9f3e5..aef022cffa 100644
--- a/src/mbgl/style/expression/match.cpp
+++ b/src/mbgl/style/expression/match.cpp
@@ -15,6 +15,17 @@ void Match<T>::eachChild(const std::function<void(const Expression*)>& visit) co
     visit(otherwise.get());
 }
 
+template <typename T>
+bool Match<T>::operator==(const Expression& e) const {
+    if (auto rhs = dynamic_cast<const Match*>(&e)) {
+        return (*input == *(rhs->input) &&
+                *otherwise == *(rhs->otherwise) &&
+                Expression::childrenEqual(branches, rhs->branches));
+    }
+    return false;
+}
+
+
 template<> EvaluationResult Match<std::string>::evaluate(const EvaluationContext& params) const {
     const EvaluationResult inputValue = input->evaluate(params);
     if (!inputValue) {
diff --git a/src/mbgl/style/expression/step.cpp b/src/mbgl/style/expression/step.cpp
index f180f5c587..00bf9a4132 100644
--- a/src/mbgl/style/expression/step.cpp
+++ b/src/mbgl/style/expression/step.cpp
@@ -32,6 +32,13 @@ void Step::eachChild(const std::function<void(const Expression*)>& visit) const
     }
 }
 
+bool Step::operator==(const Expression& e) const {
+    if (auto rhs = dynamic_cast<const Step*>(&e)) {
+        return *input == *(rhs->input) && Expression::childrenEqual(stops, rhs->stops);
+    }
+    return false;
+}
+
 Range<float> Step::getCoveringStops(const double lower, const double upper) const {
     return ::mbgl::style::expression::getCoveringStops(stops, lower, upper);
 }