[core] Simplify FilterEvaluator and fix crash

Previous implementation was assigning a temporary to FilterEvaluator<T>::extractor.

5 files changed, 20 insertions, 39 deletions

diff --git a/src/mbgl/renderer/symbol_bucket.cpp b/src/mbgl/renderer/symbol_bucket.cpp
index 65539e491a..e14bad6735 100644
--- a/src/mbgl/renderer/symbol_bucket.cpp
+++ b/src/mbgl/renderer/symbol_bucket.cpp
@@ -119,7 +119,7 @@ void SymbolBucket::parseFeatures(const GeometryTileLayer& layer, const Filter& f
     for (GLsizei i = 0; i < featureCount; i++) {
         auto feature = layer.getFeature(i);
 
-        FilterEvaluator<GeometryTileFeatureExtractor> evaluator(*feature);
+        FilterEvaluator evaluator(*feature);
         if (!Filter::visit(filter, evaluator))
             continue;
 
diff --git a/src/mbgl/style/filter_evaluator.hpp b/src/mbgl/style/filter_evaluator.hpp
index 0f3ee2a424..ab550ee26c 100644
--- a/src/mbgl/style/filter_evaluator.hpp
+++ b/src/mbgl/style/filter_evaluator.hpp
@@ -1,54 +1,53 @@
 #pragma once
 
 #include <mbgl/style/filter.hpp>
-#include <mbgl/util/optional.hpp>
+#include <mbgl/tile/geometry_tile.hpp>
 
 #include <type_traits>
 
 namespace mbgl {
 
-template <class Extractor>
 class FilterEvaluator {
 public:
-    FilterEvaluator(const Extractor& extractor_)
-        : extractor(extractor_) {}
+    FilterEvaluator(const GeometryTileFeature& feature_)
+        : feature(feature_) {}
 
     bool operator()(const NullFilter&) const {
         return true;
     }
 
     bool operator()(const EqualsFilter& filter) const {
-        optional<Value> actual = extractor.getValue(filter.key);
+        optional<Value> actual = getValue(filter.key);
         return actual && equal(*actual, filter.value);
     }
 
     bool operator()(const NotEqualsFilter& filter) const {
-        optional<Value> actual = extractor.getValue(filter.key);
+        optional<Value> actual = getValue(filter.key);
         return !actual || !equal(*actual, filter.value);
     }
 
     bool operator()(const LessThanFilter& filter) const {
-        optional<Value> actual = extractor.getValue(filter.key);
+        optional<Value> actual = getValue(filter.key);
         return actual && compare(*actual, filter.value, [] (const auto& lhs_, const auto& rhs_) { return lhs_ < rhs_; });
     }
 
     bool operator()(const LessThanEqualsFilter& filter) const {
-        optional<Value> actual = extractor.getValue(filter.key);
+        optional<Value> actual = getValue(filter.key);
         return actual && compare(*actual, filter.value, [] (const auto& lhs_, const auto& rhs_) { return lhs_ <= rhs_; });
     }
 
     bool operator()(const GreaterThanFilter& filter) const {
-        optional<Value> actual = extractor.getValue(filter.key);
+        optional<Value> actual = getValue(filter.key);
         return actual && compare(*actual, filter.value, [] (const auto& lhs_, const auto& rhs_) { return lhs_ > rhs_; });
     }
 
     bool operator()(const GreaterThanEqualsFilter& filter) const {
-        optional<Value> actual = extractor.getValue(filter.key);
+        optional<Value> actual = getValue(filter.key);
         return actual && compare(*actual, filter.value, [] (const auto& lhs_, const auto& rhs_) { return lhs_ >= rhs_; });
     }
 
     bool operator()(const InFilter& filter) const {
-        optional<Value> actual = extractor.getValue(filter.key);
+        optional<Value> actual = getValue(filter.key);
         if (!actual)
             return false;
         for (const auto& v: filter.values) {
@@ -60,7 +59,7 @@ public:
     }
 
     bool operator()(const NotInFilter& filter) const {
-        optional<Value> actual = extractor.getValue(filter.key);
+        optional<Value> actual = getValue(filter.key);
         if (!actual)
             return true;
         for (const auto& v: filter.values) {
@@ -99,6 +98,12 @@ public:
     }
 
 private:
+    optional<Value> getValue(const std::string& key) const {
+        return key == "$type"
+            ? optional<Value>(uint64_t(feature.getType()))
+            : feature.getValue(key);
+    }
+
     template <class Op>
     struct Comparator {
         const Op& op;
@@ -142,7 +147,7 @@ private:
         return compare(lhs, rhs, [] (const auto& lhs_, const auto& rhs_) { return lhs_ == rhs_; });
     }
 
-    const Extractor& extractor;
+    const GeometryTileFeature& feature;
 };
 
 } // namespace mbgl
diff --git a/src/mbgl/style/style_bucket_parameters.cpp b/src/mbgl/style/style_bucket_parameters.cpp
index cf5184bd8b..0b4b2affcd 100644
--- a/src/mbgl/style/style_bucket_parameters.cpp
+++ b/src/mbgl/style/style_bucket_parameters.cpp
@@ -10,7 +10,7 @@ void StyleBucketParameters::eachFilteredFeature(const Filter& filter,
     for (std::size_t i = 0; !cancelled() && i < layer.featureCount(); i++) {
         auto feature = layer.getFeature(i);
 
-        FilterEvaluator<GeometryTileFeatureExtractor> evaluator(*feature);
+        FilterEvaluator evaluator(*feature);
         if (!Filter::visit(filter, evaluator))
             continue;
 
diff --git a/src/mbgl/tile/geometry_tile.cpp b/src/mbgl/tile/geometry_tile.cpp
deleted file mode 100644
index e3c7437a9c..0000000000
--- a/src/mbgl/tile/geometry_tile.cpp
+++ /dev/null
@@ -1,13 +0,0 @@
-#include <mbgl/tile/geometry_tile.hpp>
-
-namespace mbgl {
-
-optional<Value> GeometryTileFeatureExtractor::getValue(const std::string& key) const {
-    if (key == "$type") {
-        return Value(uint64_t(feature.getType()));
-    }
-
-    return feature.getValue(key);
-}
-
-} // namespace mbgl
diff --git a/src/mbgl/tile/geometry_tile.hpp b/src/mbgl/tile/geometry_tile.hpp
index 0bcb92b47b..0b01a230c5 100644
--- a/src/mbgl/tile/geometry_tile.hpp
+++ b/src/mbgl/tile/geometry_tile.hpp
@@ -80,17 +80,6 @@ public:
     virtual std::unique_ptr<AsyncRequest> monitorTile(const Callback&) = 0;
 };
 
-class GeometryTileFeatureExtractor {
-public:
-    GeometryTileFeatureExtractor(const GeometryTileFeature& feature_)
-        : feature(feature_) {}
-
-    optional<Value> getValue(const std::string& key) const;
-
-private:
-    const GeometryTileFeature& feature;
-};
-
 } // namespace mbgl
 
 #endif