move to abstract interfaces to more be in line with original API

9 files changed, 178 insertions, 115 deletions

diff --git a/src/mbgl/geometry/glyph_atlas.cpp b/src/mbgl/geometry/glyph_atlas.cpp
index fd429d41a3..4aaa77f38d 100644
--- a/src/mbgl/geometry/glyph_atlas.cpp
+++ b/src/mbgl/geometry/glyph_atlas.cpp
@@ -1,5 +1,4 @@
 #include <mbgl/geometry/glyph_atlas.hpp>
-#include <mbgl/map/vector_tile.hpp>
 
 #include <mbgl/platform/gl.hpp>
 #include <mbgl/platform/platform.hpp>
diff --git a/src/mbgl/map/geometry_tile.cpp b/src/mbgl/map/geometry_tile.cpp
index defff0ebfb..2800712ef2 100644
--- a/src/mbgl/map/geometry_tile.cpp
+++ b/src/mbgl/map/geometry_tile.cpp
@@ -16,20 +16,9 @@ std::ostream& mbgl::operator<<(std::ostream& os, const GeometryFeatureType& type
 }
 
 std::ostream& mbgl::operator<<(std::ostream& os, const GeometryTileFeature& feature) {
-    os << "Feature(" << feature.id << "): " << feature.type << std::endl;
-    for (const auto& prop : feature.properties) {
+    os << "Feature(" << feature.getID() << "): " << feature.getType() << std::endl;
+    for (const auto& prop : feature.getProperties()) {
         os << "  - " << prop.first << ": " << &prop.second << std::endl;
     }
     return os;
 }
-
-GeometryFilteredTileLayer::GeometryFilteredTileLayer(const util::ptr<GeometryTileLayer> layer_, const FilterExpression& filterExpression_)
-    : layer(layer_),
-      filterExpression(filterExpression_) {}
-
-GeometryTile& GeometryTile::operator=(GeometryTile&& other) {
-    if (this != &other) {
-        layers.swap(other.layers);
-    }
-    return *this;
-}
diff --git a/src/mbgl/map/geometry_tile.hpp b/src/mbgl/map/geometry_tile.hpp
index ccb200248f..5eb031667f 100644
--- a/src/mbgl/map/geometry_tile.hpp
+++ b/src/mbgl/map/geometry_tile.hpp
@@ -5,7 +5,6 @@
 #include <mbgl/style/value.hpp>
 #include <mbgl/text/glyph.hpp>
 #include <mbgl/util/optional.hpp>
-#include <mbgl/util/ptr.hpp>
 #include <mbgl/util/variant.hpp>
 #include <mbgl/util/vec.hpp>
 
@@ -40,12 +39,15 @@ class GeometryTileLayer;
 
 class GeometryTileFeature {
 public:
+    virtual ~GeometryTileFeature();
+
+    virtual uint64_t getID() const = 0;
+    virtual GeometryFeatureType getType() const = 0;
+    virtual std::map<std::string, Value> getProperties() const = 0;
     virtual GeometryCollection nextGeometry() = 0;
 
-public:
-    uint64_t id = 0;
-    GeometryFeatureType type = GeometryFeatureType::Unknown;
-    std::map<std::string, Value> properties;
+protected:
+    GeometryTileFeature();
 };
 
 std::ostream& operator<<(std::ostream&, const GeometryTileFeature& feature);
@@ -53,7 +55,7 @@ std::ostream& operator<<(std::ostream&, const GeometryTileFeature& feature);
 template <typename Tags>
 class GeometryTileTagExtractor {
 public:
-    GeometryTileTagExtractor(const util::ptr<GeometryTileLayer>);
+    GeometryTileTagExtractor(const GeometryTileLayer&);
 
     inline void setTags(const Tags& tags_) { tags = tags_; }
     virtual mapbox::util::optional<Value> getValue(const std::string &key) const;
@@ -66,43 +68,49 @@ public:
     Tags tags;
 
 protected:
-    const util::ptr<GeometryTileLayer> layer;
+    const GeometryTileLayer& layer;
 };
 
 class GeometryFilteredTileLayer {
 public:
-    GeometryFilteredTileLayer(const util::ptr<GeometryTileLayer>, const FilterExpression&);
+    class iterator {};
+
+public:
+    virtual ~GeometryFilteredTileLayer();
 
-    virtual util::ptr<GeometryTileFeature> nextMatchingFeature() = 0;
+    virtual iterator begin() const = 0;
+    virtual iterator end() const = 0;
 
 protected:
-    const util::ptr<GeometryTileLayer> layer;
-    const FilterExpression& filterExpression;
+    GeometryFilteredTileLayer();
 };
 
 std::ostream& operator<<(std::ostream&, const PositionedGlyph&);
 
 class GeometryTileLayer {
 public:
-    virtual util::ptr<GeometryFilteredTileLayer> createFilter(const FilterExpression&) = 0;
+    virtual ~GeometryTileLayer();
 
-public:
-    std::string name;
-    uint32_t extent = 4096;
-    std::vector<std::string> keys;
-    std::unordered_map<std::string, uint32_t> key_index;
-    std::vector<Value> values;
-    std::map<std::string, std::map<Value, Shaping>> shaping;
+    virtual const std::string getName() const = 0;
+    virtual uint32_t getExtent() const = 0;
+    virtual const std::vector<std::string> getKeys() const = 0;
+    virtual const std::unordered_map<std::string, uint32_t> getKeyIndex() const = 0;
+    virtual const std::vector<Value> getValues() const = 0;
+    virtual const std::map<std::string, std::map<Value, Shaping>> getShaping() const = 0;
+    virtual std::unique_ptr<GeometryFilteredTileLayer> createFilteredTileLayer(const FilterExpression&) const = 0;
+
+protected:
+    GeometryTileLayer();
 };
 
 class GeometryTile {
 public:
-    GeometryTile& operator=(GeometryTile&& other);
+    virtual ~GeometryTile();
 
-    virtual void logDebug() const = 0;
+    virtual std::map<std::string, const GeometryTileLayer> getLayers() const = 0;
 
-public:
-    std::map<std::string, const util::ptr<GeometryTileLayer>> layers;
+protected:
+    GeometryTile();
 };
 
 }
diff --git a/src/mbgl/map/tile_parser.cpp b/src/mbgl/map/tile_parser.cpp
index c920ca473a..dd97b62b31 100644
--- a/src/mbgl/map/tile_parser.cpp
+++ b/src/mbgl/map/tile_parser.cpp
@@ -187,9 +187,9 @@ std::unique_ptr<Bucket> TileParser::createBucket(const StyleBucket &bucketDesc)
     if (tile.id.z >= std::ceil(bucketDesc.max_zoom)) return nullptr;
     if (bucketDesc.visibility == mbgl::VisibilityType::None) return nullptr;
 
-    auto layer_it = vectorTile.layers.find(bucketDesc.source_layer);
-    if (layer_it != vectorTile.layers.end()) {
-        const util::ptr<GeometryTileLayer> layer = layer_it->second;
+    auto layer_it = vectorTile.getLayers().find(bucketDesc.source_layer);
+    if (layer_it != vectorTile.getLayers().end()) {
+        const GeometryTileLayer& layer = layer_it->second;
         if (bucketDesc.type == StyleLayerType::Fill) {
             return createFillBucket(layer, bucketDesc);
         } else if (bucketDesc.type == StyleLayerType::Line) {
@@ -213,24 +213,23 @@ std::unique_ptr<Bucket> TileParser::createBucket(const StyleBucket &bucketDesc)
 }
 
 template <class Bucket>
-    void TileParser::addBucketGeometries(Bucket& bucket, const util::ptr<GeometryTileLayer> layer, const FilterExpression &filter) {
-    util::ptr<GeometryFilteredTileLayer> filtered_layer = layer->createFilter(filter);
-    util::ptr<GeometryTileFeature> feature = filtered_layer->nextMatchingFeature();
-    while (feature->type != GeometryFeatureType::Unknown) {
+void TileParser::addBucketGeometries(Bucket& bucket, const GeometryTileLayer& layer, const FilterExpression &filter) {
+
+    std::unique_ptr<GeometryFilteredTileLayer> filtered_layer = layer.createFilteredTileLayer(filter);
+
+    for (auto feature : *filtered_layer) {
         if (obsolete())
             return;
 
-        GeometryCollection geometry = feature->nextGeometry();
+        GeometryCollection geometry = feature.nextGeometry();
         while (geometry.size()) {
             bucket->addGeometry(geometry);
-            geometry = feature->nextGeometry();
+            geometry = feature.nextGeometry();
         }
-
-        feature = filtered_layer->nextMatchingFeature();
     }
 }
 
-std::unique_ptr<Bucket> TileParser::createFillBucket(const util::ptr<GeometryTileLayer> layer,
+std::unique_ptr<Bucket> TileParser::createFillBucket(const GeometryTileLayer& layer,
                                                      const StyleBucket &bucket_desc) {
     auto fill = parseStyleLayoutFill(bucket_desc, tile.id.z);
     auto bucket = util::make_unique<FillBucket>(std::move(fill),
@@ -241,7 +240,7 @@ std::unique_ptr<Bucket> TileParser::createFillBucket(const util::ptr<GeometryTil
     return obsolete() ? nullptr : std::move(bucket);
 }
 
-std::unique_ptr<Bucket> TileParser::createLineBucket(const util::ptr<GeometryTileLayer> layer,
+std::unique_ptr<Bucket> TileParser::createLineBucket(const GeometryTileLayer& layer,
                                                      const StyleBucket &bucket_desc) {
     auto line = parseStyleLayoutLine(bucket_desc, tile.id.z);
     auto bucket = util::make_unique<LineBucket>(std::move(line),
@@ -252,7 +251,7 @@ std::unique_ptr<Bucket> TileParser::createLineBucket(const util::ptr<GeometryTil
     return obsolete() ? nullptr : std::move(bucket);
 }
 
-std::unique_ptr<Bucket> TileParser::createSymbolBucket(const util::ptr<GeometryTileLayer> layer,
+std::unique_ptr<Bucket> TileParser::createSymbolBucket(const GeometryTileLayer& layer,
                                                        const StyleBucket &bucket_desc) {
     auto symbol = parseStyleLayoutSymbol(bucket_desc, tile.id.z);
     auto bucket = util::make_unique<SymbolBucket>(std::move(symbol), *collision);
diff --git a/src/mbgl/map/tile_parser.hpp b/src/mbgl/map/tile_parser.hpp
index ee134911fc..841ae1749c 100644
--- a/src/mbgl/map/tile_parser.hpp
+++ b/src/mbgl/map/tile_parser.hpp
@@ -53,11 +53,11 @@ private:
     void parseStyleLayers(util::ptr<const StyleLayerGroup> group);
 
     std::unique_ptr<Bucket> createBucket(const StyleBucket& bucketDesc);
-    std::unique_ptr<Bucket> createFillBucket(const util::ptr<GeometryTileLayer> layer, const StyleBucket& bucketDesc);
-    std::unique_ptr<Bucket> createLineBucket(const util::ptr<GeometryTileLayer> layer, const StyleBucket& bucketDesc);
-    std::unique_ptr<Bucket> createSymbolBucket(const util::ptr<GeometryTileLayer> layer, const StyleBucket& bucketDesc);
+    std::unique_ptr<Bucket> createFillBucket(const GeometryTileLayer& layer, const StyleBucket& bucketDesc);
+    std::unique_ptr<Bucket> createLineBucket(const GeometryTileLayer& layer, const StyleBucket& bucketDesc);
+    std::unique_ptr<Bucket> createSymbolBucket(const GeometryTileLayer& layer, const StyleBucket& bucketDesc);
 
-    template <class Bucket> void addBucketGeometries(Bucket& bucket, const util::ptr<GeometryTileLayer> layer, const FilterExpression& filter);
+    template <class Bucket> void addBucketGeometries(Bucket& bucket, const GeometryTileLayer& layer, const FilterExpression& filter);
 
 private:
     const VectorTile vectorTile;
diff --git a/src/mbgl/map/vector_tile.cpp b/src/mbgl/map/vector_tile.cpp
index 30357848f0..f31dd27aa2 100644
--- a/src/mbgl/map/vector_tile.cpp
+++ b/src/mbgl/map/vector_tile.cpp
@@ -1,14 +1,15 @@
 #include <mbgl/map/vector_tile.hpp>
 #include <mbgl/geometry/pbf_geometry.hpp>
 #include <mbgl/style/filter_expression_private.hpp>
-#include <mbgl/util/variant_io.hpp>
+#include <mbgl/util/std.hpp>
+#include <mbgl/util/pbf.hpp>
 
 #include <type_traits>
 #include <ostream>
 
 using namespace mbgl;
 
-VectorTileFeature::VectorTileFeature(pbf feature_pbf, const util::ptr<GeometryTileLayer> layer) {
+VectorTileFeature::VectorTileFeature(pbf feature_pbf, const GeometryTileLayer& layer) {
     while (feature_pbf.next()) {
         if (feature_pbf.tag == 1) { // id
             id = feature_pbf.varint<uint64_t>();
@@ -18,17 +19,17 @@ VectorTileFeature::VectorTileFeature(pbf feature_pbf, const util::ptr<GeometryTi
             while (tags) {
                 uint32_t tag_key = tags.varint();
 
-                if (layer->keys.size() <= tag_key) {
+                if (layer.getKeys().size() <= tag_key) {
                     throw std::runtime_error("feature referenced out of range key");
                 }
 
                 if (tags) {
                     uint32_t tag_val = tags.varint();
-                    if (layer->values.size() <= tag_val) {
+                    if (layer.getValues().size() <= tag_val) {
                         throw std::runtime_error("feature referenced out of range value");
                     }
 
-                    properties.emplace(layer->keys[tag_key], layer->values[tag_val]);
+                    properties.emplace(layer.getKeys()[tag_key], layer.getValues()[tag_val]);
                 } else {
                     throw std::runtime_error("uneven number of feature tag ids");
                 }
@@ -99,16 +100,19 @@ GeometryCollection VectorTileFeature::nextGeometry() {
 VectorTile::VectorTile(pbf tile_pbf) {
     while (tile_pbf.next()) {
         if (tile_pbf.tag == 3) { // layer
-            util::ptr<VectorTileLayer> layer = std::make_shared<VectorTileLayer>(tile_pbf.message());
-            layers.emplace(layer->name, std::forward<util::ptr<VectorTileLayer>>(layer));
+            VectorTileLayer layer(tile_pbf.message());
+            layers.emplace(layer.getName(), std::forward<VectorTileLayer>(layer));
         } else {
             tile_pbf.skip();
         }
     }
 }
 
-void VectorTile::logDebug() const {
-    printf("got here for VectorTile\n");
+VectorTile& VectorTile::operator=(VectorTile&& other) {
+    if (this != &other) {
+        layers.swap(other.layers);
+    }
+    return *this;
 }
 
 VectorTileLayer::VectorTileLayer(pbf layer_pbf)
@@ -129,14 +133,31 @@ VectorTileLayer::VectorTileLayer(pbf layer_pbf)
     }
 }
 
-FilteredVectorTileLayer::FilteredVectorTileLayer(const util::ptr<VectorTileLayer> layer_, const FilterExpression& filterExpression_)
-    : GeometryFilteredTileLayer(layer_, filterExpression_) {
-    feature_pbf = layer_->feature_pbf;
-    nextMatchingFeature();
+std::unique_ptr<GeometryFilteredTileLayer> VectorTileLayer::createFilteredTileLayer(const FilterExpression& filterExpression) const {
+    return util::make_unique<FilteredVectorTileLayer>(*this, filterExpression);
+}
+
+FilteredVectorTileLayer::FilteredVectorTileLayer(const VectorTileLayer& layer_, const FilterExpression& filterExpression_)
+    : layer(layer_),
+      filterExpression(filterExpression_) {}
+
+GeometryFilteredTileLayer::iterator FilteredVectorTileLayer::begin() const {
+    return iterator(*this, layer.feature_pbf);
+}
+
+GeometryFilteredTileLayer::iterator FilteredVectorTileLayer::end() const {
+    return iterator(*this, pbf(layer.feature_pbf.end, 0));
+}
+
+FilteredVectorTileLayer::iterator::iterator(const FilteredVectorTileLayer& parent_, const pbf& feature_pbf_)
+    : parent(parent_),
+      feature(VectorTileFeature(pbf(), parent_.layer)),
+      feature_pbf(feature_pbf_) {
+    operator++();
 }
 
 template <>
-GeometryTileTagExtractor<pbf>::GeometryTileTagExtractor(const util::ptr<GeometryTileLayer> layer_)
+GeometryTileTagExtractor<pbf>::GeometryTileTagExtractor(const GeometryTileLayer& layer_)
     : layer(layer_) {}
 
 template <>
@@ -147,8 +168,8 @@ mapbox::util::optional<Value> GeometryTileTagExtractor<pbf>::getValue(const std:
 
     mapbox::util::optional<Value> value;
 
-    auto field_it = layer->key_index.find(key);
-    if (field_it != layer->key_index.end()) {
+    auto field_it = layer.getKeyIndex().find(key);
+    if (field_it != layer.getKeyIndex().end()) {
         const uint32_t filter_key = field_it->second;
 
         // Now loop through all the key/value pair tags.
@@ -166,8 +187,8 @@ mapbox::util::optional<Value> GeometryTileTagExtractor<pbf>::getValue(const std:
             tag_val = tags_pbf_.varint();
 
             if (tag_key == filter_key) {
-                if (layer->values.size() > tag_val) {
-                    value = layer->values[tag_val];
+                if (layer.getValues().size() > tag_val) {
+                    value = layer.getValues()[tag_val];
                 } else {
                     fprintf(stderr, "[WARNING] feature references out of range value\n");
                     break;
@@ -181,31 +202,41 @@ mapbox::util::optional<Value> GeometryTileTagExtractor<pbf>::getValue(const std:
 
 template bool mbgl::evaluate(const FilterExpression&, const GeometryTileTagExtractor<pbf>&);
 
-util::ptr<GeometryTileFeature> FilteredVectorTileLayer::nextMatchingFeature() {
-    while (feature_pbf.next(2)) {
-        pbf matching_feature_pbf = feature_pbf.message();
-        pbf current_feature_pbf = matching_feature_pbf;
+void FilteredVectorTileLayer::iterator::operator++() {
+    valid = false;
+
+    const FilterExpression &expression = parent.filterExpression;
 
-        GeometryTileTagExtractor<pbf> extractor(layer);
+    while (feature_pbf.next(2)) { // feature
+        feature = VectorTileFeature(feature_pbf.message(), parent.layer);
+        pbf feature_pbf_ = feature_pbf.message();
 
-        while (current_feature_pbf.next()) {
-            if (current_feature_pbf.tag == 2) { // tags
-                extractor.setTags(current_feature_pbf.message());
-            } else if (current_feature_pbf.tag == 3) { // geometry type
-                extractor.setType(GeometryFeatureType(current_feature_pbf.varint()));
+        GeometryTileTagExtractor<pbf> extractor(parent.layer);
+
+        // Retrieve the basic information
+        while (feature_pbf_.next()) {
+            if (feature_pbf_.tag == 2) { // tags
+                extractor.setTags(feature_pbf_.message());
+            } else if (feature_pbf_.tag == 3) { // geometry type
+                extractor.setType(GeometryFeatureType(feature_pbf_.varint()));
             } else {
-                current_feature_pbf.skip();
+                feature_pbf_.skip();
             }
         }
 
-        if (evaluate(filterExpression, extractor)) {
-            return std::make_shared<VectorTileFeature>(matching_feature_pbf, layer);
+        if (evaluate(expression, extractor)) {
+            valid = true;
+            return; // data loop
+        } else {
+            valid = false;
         }
     }
+}
 
-    return std::make_shared<VectorTileFeature>(pbf(), layer);
+bool FilteredVectorTileLayer::iterator::operator!=(const iterator& other) const {
+    return !(feature_pbf.data == other.feature_pbf.data && feature_pbf.end == other.feature_pbf.end && valid == other.valid);
 }
 
-util::ptr<GeometryFilteredTileLayer> VectorTileLayer::createFilter(const FilterExpression& filterExpression) {
-    return std::make_shared<FilteredVectorTileLayer>(shared_from_this(), filterExpression);
+const VectorTileFeature& FilteredVectorTileLayer::iterator::operator*() const {
+    return feature;
 }
diff --git a/src/mbgl/map/vector_tile.hpp b/src/mbgl/map/vector_tile.hpp
index 0fee14ac50..a306f524dc 100644
--- a/src/mbgl/map/vector_tile.hpp
+++ b/src/mbgl/map/vector_tile.hpp
@@ -2,52 +2,89 @@
 #define MBGL_MAP_VECTOR_TILE
 
 #include <mbgl/map/geometry_tile.hpp>
-#include <mbgl/geometry/pbf_geometry.hpp>
 #include <mbgl/style/filter_expression.hpp>
-#include <mbgl/util/ptr.hpp>
-#include <mbgl/util/pbf.hpp>
 
 namespace mbgl {
 
 class VectorTileLayer;
+struct pbf;
 
 class VectorTileFeature : public GeometryTileFeature {
 public:
-    VectorTileFeature(pbf, const util::ptr<GeometryTileLayer>);
+    VectorTileFeature(pbf, const GeometryTileLayer&);
 
-    GeometryCollection nextGeometry();
+    virtual inline uint64_t getID() const { return id; };
+    virtual inline GeometryFeatureType getType() const { return type; }
+    virtual inline std::map<std::string, Value> getProperties() const { return properties; }
+    virtual GeometryCollection nextGeometry();
 
 private:
+    uint64_t id = 0;
+    GeometryFeatureType type = GeometryFeatureType::Unknown;
+    std::map<std::string, Value> properties;
     pbf geometry_pbf;
 };
 
 class FilteredVectorTileLayer : public GeometryFilteredTileLayer {
 public:
-    FilteredVectorTileLayer(const util::ptr<VectorTileLayer>, const FilterExpression&);
+    class iterator : public GeometryFilteredTileLayer::iterator {
+    public:
+        iterator(const FilteredVectorTileLayer&, const pbf&);
+        void operator++();
+        bool operator!=(const iterator&) const;
+        const VectorTileFeature& operator*() const;
+
+    private:
+        const FilteredVectorTileLayer& parent;
+        bool valid = false;
+        VectorTileFeature feature;
+        pbf feature_pbf;
+    };
 
-    virtual util::ptr<GeometryTileFeature> nextMatchingFeature();
+public:
+    FilteredVectorTileLayer(const VectorTileLayer&, const FilterExpression&);
 
-private:
-    pbf feature_pbf;
+    virtual GeometryFilteredTileLayer::iterator begin() const;
+    virtual GeometryFilteredTileLayer::iterator end() const;
 
+private:
+    const VectorTileLayer& layer;
+    const FilterExpression& filterExpression;
 };
 
-class VectorTileLayer : public GeometryTileLayer, public std::enable_shared_from_this<VectorTileLayer> {
+class VectorTileLayer : public GeometryTileLayer {
     friend class FilteredVectorTileLayer;
 public:
     VectorTileLayer(pbf);
 
-    virtual util::ptr<GeometryFilteredTileLayer> createFilter(const FilterExpression&);
+    virtual inline const std::string getName() const { return name; }
+    virtual inline uint32_t getExtent() const { return extent; }
+    virtual inline const std::vector<std::string> getKeys() const { return keys; }
+    virtual inline const std::unordered_map<std::string, uint32_t> getKeyIndex() const { return key_index; }
+    virtual inline const std::vector<Value> getValues() const { return values; }
+    virtual inline const std::map<std::string, std::map<Value, Shaping>> getShaping() const { return shaping; }
+
+    virtual std::unique_ptr<GeometryFilteredTileLayer> createFilteredTileLayer(const FilterExpression&) const;
 
 private:
-    pbf feature_pbf;
+    std::string name;
+    uint32_t extent = 4096;
+    std::vector<std::string> keys;
+    std::unordered_map<std::string, uint32_t> key_index;
+    std::vector<Value> values;
+    std::map<std::string, std::map<Value, Shaping>> shaping;
+    const pbf feature_pbf;
 };
 
 class VectorTile : public GeometryTile {
 public:
     VectorTile(pbf);
 
-    virtual void logDebug() const;
+    VectorTile& operator=(VectorTile&&);
+    virtual std::map<std::string, const GeometryTileLayer> getLayers() const;
+
+private:
+    std::map<std::string, const VectorTileLayer> layers;
 };
 
 }
diff --git a/src/mbgl/renderer/symbol_bucket.cpp b/src/mbgl/renderer/symbol_bucket.cpp
index 462ac72ab7..511add4de2 100644
--- a/src/mbgl/renderer/symbol_bucket.cpp
+++ b/src/mbgl/renderer/symbol_bucket.cpp
@@ -1,5 +1,6 @@
 #include <mbgl/renderer/symbol_bucket.hpp>
 #include <mbgl/map/geometry_tile.hpp>
+#include <mbgl/map/vector_tile.hpp>
 #include <mbgl/style/style_layout.hpp>
 #include <mbgl/geometry/text_buffer.hpp>
 #include <mbgl/geometry/icon_buffer.hpp>
@@ -18,6 +19,7 @@
 #include <mbgl/util/token.hpp>
 #include <mbgl/util/math.hpp>
 #include <mbgl/util/merge_lines.hpp>
+#include <mbgl/util/std.hpp>
 
 namespace mbgl {
 
@@ -47,7 +49,7 @@ void SymbolBucket::addGlyphsToAtlas(uint64_t tileid, const std::string stackname
     glyphAtlas.addGlyphs(tileid, text, stackname, fontStack,face);
 }
 
-std::vector<SymbolFeature> SymbolBucket::processFeatures(const util::ptr<GeometryTileLayer> layer,
+std::vector<SymbolFeature> SymbolBucket::processFeatures(const GeometryTileLayer& layer,
                                                          const FilterExpression &filter,
                                                          GlyphStore &glyphStore,
                                                          const Sprite &sprite) {
@@ -64,14 +66,14 @@ std::vector<SymbolFeature> SymbolBucket::processFeatures(const util::ptr<Geometr
     // Determine and load glyph ranges
     std::set<GlyphRange> ranges;
 
-    util::ptr<GeometryFilteredTileLayer> filtered_layer = layer->createFilter(filter);
-    util::ptr<GeometryTileFeature> feature = filtered_layer->nextMatchingFeature();
-    while (feature->type != GeometryFeatureType::Unknown) {
+    std::unique_ptr<GeometryFilteredTileLayer> filtered_layer = layer.createFilteredTileLayer(filter);
+
+    for (auto feature : *filtered_layer) {
 
         SymbolFeature ft;
 
         if (has_text) {
-            std::string u8string = util::replaceTokens(layout.text.field, feature->properties);
+            std::string u8string = util::replaceTokens(layout.text.field, feature.getProperties());
 
             if (layout.text.transform == TextTransformType::Uppercase) {
                 u8string = platform::uppercase(u8string);
@@ -90,14 +92,14 @@ std::vector<SymbolFeature> SymbolBucket::processFeatures(const util::ptr<Geometr
         }
 
         if (has_icon) {
-            ft.sprite = util::replaceTokens(layout.icon.image, feature->properties);
+            ft.sprite = util::replaceTokens(layout.icon.image, feature.getProperties());
         }
 
         if (ft.label.length() || ft.sprite.length()) {
 
             auto &multiline = ft.geometry;
 
-            GeometryCollection geometryCollection = feature->nextGeometry();
+            GeometryCollection geometryCollection = feature.nextGeometry();
             multiline.emplace_back();
             for (auto& geometry : geometryCollection) {
                 const GeometryLine& line = geometry.get<GeometryLine>();
@@ -109,8 +111,6 @@ std::vector<SymbolFeature> SymbolBucket::processFeatures(const util::ptr<Geometr
 
             features.push_back(std::move(ft));
         }
-
-        feature = filtered_layer->nextMatchingFeature();
     }
 
     if (layout.placement == PlacementType::Line) {
@@ -123,7 +123,7 @@ std::vector<SymbolFeature> SymbolBucket::processFeatures(const util::ptr<Geometr
     return features;
 }
 
-void SymbolBucket::addFeatures(const util::ptr<GeometryTileLayer> layer, const FilterExpression &filter,
+void SymbolBucket::addFeatures(const GeometryTileLayer& layer, const FilterExpression &filter,
                                const Tile::ID &id, SpriteAtlas &spriteAtlas, Sprite &sprite,
                                GlyphAtlas & glyphAtlas, GlyphStore &glyphStore) {
     auto &layout = *styleLayout;
diff --git a/src/mbgl/renderer/symbol_bucket.hpp b/src/mbgl/renderer/symbol_bucket.hpp
index d9b461afaa..0f9e8faa31 100644
--- a/src/mbgl/renderer/symbol_bucket.hpp
+++ b/src/mbgl/renderer/symbol_bucket.hpp
@@ -65,7 +65,7 @@ public:
     bool hasTextData() const;
     bool hasIconData() const;
 
-    void addFeatures(const util::ptr<GeometryTileLayer> layer, const FilterExpression &filter,
+    void addFeatures(const GeometryTileLayer& layer, const FilterExpression &filter,
                      const Tile::ID &id, SpriteAtlas &spriteAtlas, Sprite &sprite,
                      GlyphAtlas &glyphAtlas, GlyphStore &glyphStore);
 
@@ -78,9 +78,9 @@ public:
 
 private:
 
-    std::vector<SymbolFeature> processFeatures(const util::ptr<GeometryTileLayer> layer, const FilterExpression &filter, GlyphStore &glyphStore, const Sprite &sprite);
+    std::vector<SymbolFeature> processFeatures(const GeometryTileLayer& layer, const FilterExpression &filter, GlyphStore &glyphStore, const Sprite &sprite);
 
-    void addFeature(const GeometryLine &line, const Shaping &shaping, const GlyphPositions &face, const Rect<uint16_t> &image);
+    void addFeature(const std::vector<Coordinate> &line, const Shaping &shaping, const GlyphPositions &face, const Rect<uint16_t> &image);
 
     // Adds placed items to the buffer.
     template <typename Buffer, typename GroupType>