port to protozero v1.4.2

Dane Springmeyer · Dane Springmeyer · commit de6628c00c1b · 2016-09-09T10:03:00.000-07:00
diff --git a/Makefile b/Makefile
@@ -2,7 +2,7 @@ MAPNIK_PLUGINDIR := $(shell mapnik-config --input-plugins)
 BUILDTYPE ?= Release
 
 CLIPPER_REVISION=ac8d6bf2517f46c05647b5c19cac113fb180ffb4
-PROTOZERO_REVISION=v1.3.0
+PROTOZERO_REVISION=v1.4.2
 GYP_REVISION=3464008
 
 all: libvtile
diff --git a/src/vector_tile_composite.hpp b/src/vector_tile_composite.hpp
@@ -57,8 +57,8 @@ void composite(merc_tile & target_vt,
         while (tile_message.next(Tile_Encoding::LAYERS))
         {
             bool reencode_layer = reencode_tile;
-            auto data_pair = tile_message.get_data();
-            protozero::pbf_reader layer_message(data_pair);
+            const auto data_view = tile_message.get_view();
+            protozero::pbf_reader layer_message(data_view);
             if (!layer_message.next(Layer_Encoding::NAME))
             {
                 continue;
@@ -68,15 +68,15 @@ void composite(merc_tile & target_vt,
             
             if (!reencode_layer)
             {
-                target_vt.append_layer_buffer(data_pair.first, data_pair.second, layer_name);
+                target_vt.append_layer_buffer(data_view.data(), data_view.size(), layer_name);
             }
             
             if (target_vt.has_layer(layer_name))
             {
                 continue;
             }
 
-            protozero::pbf_reader layer_pbf(data_pair);
+            protozero::pbf_reader layer_pbf(data_view);
             auto ds = std::make_shared<mapnik::vector_tile_impl::tile_datasource_pbf>(
                         layer_pbf,
                         vt->x(),
diff --git a/src/vector_tile_datasource_pbf.ipp b/src/vector_tile_datasource_pbf.ipp
@@ -74,14 +74,14 @@ tile_datasource_pbf::tile_datasource_pbf(protozero::pbf_reader const& layer,
                 break;
             case Layer_Encoding::FEATURES:
                 {
-                    auto data_pair = layer_.get_data();
-                    protozero::pbf_reader check_feature(data_pair);
+                    const auto data_view = layer_.get_view();
+                    protozero::pbf_reader check_feature(data_view);
                     while (check_feature.next(Feature_Encoding::RASTER))
                     {
                         type_ = datasource::Raster;
                         check_feature.skip();
                     }
-                    protozero::pbf_reader f_msg(data_pair);
+                    protozero::pbf_reader f_msg(data_view);
                     features_.push_back(f_msg);
                 }
                 break;
diff --git a/src/vector_tile_featureset_pbf.ipp b/src/vector_tile_featureset_pbf.ipp
@@ -123,7 +123,7 @@ feature_ptr tile_featureset_pbf<Filter>::next()
         int32_t geometry_type = 0; // vector_tile::Tile_GeomType_UNKNOWN
         bool has_geometry = false;
         bool has_geometry_type = false;
-        std::pair<protozero::pbf_reader::const_uint32_iterator, protozero::pbf_reader::const_uint32_iterator> geom_itr;
+        GeometryPBF::pbf_itr geom_itr;
         bool has_raster = false;
         std::unique_ptr<mapnik::image_reader> reader;
         while (f.next())
@@ -136,10 +136,10 @@ feature_ptr tile_featureset_pbf<Filter>::next()
                 case 2:
                     {
                         auto tag_iterator = f.get_packed_uint32();
-                        for (auto _i = tag_iterator.first; _i != tag_iterator.second;)
+                        for (auto _i = tag_iterator.begin(); _i != tag_iterator.end();)
                         {
                             std::size_t key_name = *(_i++);
-                            if (_i == tag_iterator.second)
+                            if (_i == tag_iterator.end())
                             {
                                 throw std::runtime_error("Vector Tile has a feature with an odd number of tags, therefore the tile is invalid.");
                             }
@@ -186,8 +186,8 @@ feature_ptr tile_featureset_pbf<Filter>::next()
                             throw std::runtime_error("Vector Tile has a feature with multiple raster fields, it must have only one of them");
                         }
                         has_raster = true;
-                        auto image_buffer = f.get_data();
-                        reader = std::unique_ptr<mapnik::image_reader>(mapnik::get_image_reader(image_buffer.first, image_buffer.second));
+                        auto image_buffer = f.get_view();
+                        reader = std::unique_ptr<mapnik::image_reader>(mapnik::get_image_reader(image_buffer.data(), image_buffer.size()));
                     }
                     break;
                 case 4:
diff --git a/src/vector_tile_geometry_decoder.hpp b/src/vector_tile_geometry_decoder.hpp
@@ -31,7 +31,8 @@ class GeometryPBF
 {
 public:
     using value_type = std::int64_t;
-    using pbf_itr = std::pair<protozero::pbf_reader::const_uint32_iterator, protozero::pbf_reader::const_uint32_iterator >;
+    using iterator_type = protozero::pbf_reader::const_uint32_iterator;
+    using pbf_itr = protozero::iterator_range<iterator_type>;
     
     explicit GeometryPBF(pbf_itr const& geo_iterator);
 
@@ -53,7 +54,8 @@ class GeometryPBF
     command ring_next(value_type & rx, value_type & ry, bool skip_lineto_zero);
 
 private:
-    std::pair< protozero::pbf_reader::const_uint32_iterator, protozero::pbf_reader::const_uint32_iterator > geo_iterator_;
+    iterator_type geo_itr_;
+    iterator_type geo_end_itr_;
     value_type x, y;
     value_type ox, oy;
     uint32_t length;
diff --git a/src/vector_tile_geometry_decoder.ipp b/src/vector_tile_geometry_decoder.ipp
@@ -554,7 +554,8 @@ void decode_polygon(mapnik::geometry::geometry<geom_value_type> & geom,
 } // end ns detail
 
 GeometryPBF::GeometryPBF(pbf_itr const& geo_iterator)
-    : geo_iterator_(geo_iterator),
+    : geo_itr_(geo_iterator.begin()),
+      geo_end_itr_(geo_iterator.end()),
       x(0),
       y(0),
       ox(0), 
@@ -571,9 +572,9 @@ typename GeometryPBF::command GeometryPBF::point_next(value_type & rx, value_typ
 {
     if (length == 0) 
     {
-        if (geo_iterator_.first != geo_iterator_.second)
+        if (geo_itr_ != geo_end_itr_)
         {
-            uint32_t cmd_length = static_cast<uint32_t>(*geo_iterator_.first++);
+            uint32_t cmd_length = static_cast<uint32_t>(*geo_itr_++);
             cmd = cmd_length & 0x7;
             length = cmd_length >> 3;
             if (cmd == move_to)
@@ -611,8 +612,8 @@ typename GeometryPBF::command GeometryPBF::point_next(value_type & rx, value_typ
     // If an exception occurs it will likely be a end_of_buffer_exception with the text:
     // "end of buffer exception"
     // While this error message is not verbose a try catch here would slow down processing.
-    int32_t dx = protozero::decode_zigzag32(static_cast<uint32_t>(*geo_iterator_.first++));
-    int32_t dy = protozero::decode_zigzag32(static_cast<uint32_t>(*geo_iterator_.first++));
+    int32_t dx = protozero::decode_zigzag32(static_cast<uint32_t>(*geo_itr_++));
+    int32_t dy = protozero::decode_zigzag32(static_cast<uint32_t>(*geo_itr_++));
     detail::move_cursor(x, y, dx, dy);
     rx = x;
     ry = y;
@@ -625,9 +626,9 @@ typename GeometryPBF::command GeometryPBF::line_next(value_type & rx,
 {
     if (length == 0)
     {
-        if (geo_iterator_.first != geo_iterator_.second)
+        if (geo_itr_ != geo_end_itr_)
         {
-            uint32_t cmd_length = static_cast<uint32_t>(*geo_iterator_.first++);
+            uint32_t cmd_length = static_cast<uint32_t>(*geo_itr_++);
             cmd = cmd_length & 0x7;
             length = cmd_length >> 3;
             if (cmd == move_to)
@@ -642,8 +643,8 @@ typename GeometryPBF::command GeometryPBF::line_next(value_type & rx,
                 // If an exception occurs it will likely be a end_of_buffer_exception with the text:
                 // "end of buffer exception"
                 // While this error message is not verbose a try catch here would slow down processing.
-                int32_t dx = protozero::decode_zigzag32(static_cast<uint32_t>(*geo_iterator_.first++));
-                int32_t dy = protozero::decode_zigzag32(static_cast<uint32_t>(*geo_iterator_.first++));
+                int32_t dx = protozero::decode_zigzag32(static_cast<uint32_t>(*geo_itr_++));
+                int32_t dy = protozero::decode_zigzag32(static_cast<uint32_t>(*geo_itr_++));
                 detail::move_cursor(x, y, dx, dy);
                 rx = x;
                 ry = y;
@@ -680,8 +681,8 @@ typename GeometryPBF::command GeometryPBF::line_next(value_type & rx,
     // If an exception occurs it will likely be a end_of_buffer_exception with the text:
     // "end of buffer exception"
     // While this error message is not verbose a try catch here would slow down processing.
-    int32_t dx = protozero::decode_zigzag32(static_cast<uint32_t>(*geo_iterator_.first++));
-    int32_t dy = protozero::decode_zigzag32(static_cast<uint32_t>(*geo_iterator_.first++));
+    int32_t dx = protozero::decode_zigzag32(static_cast<uint32_t>(*geo_itr_++));
+    int32_t dy = protozero::decode_zigzag32(static_cast<uint32_t>(*geo_itr_++));
     if (skip_lineto_zero && dx == 0 && dy == 0)
     {
         // We are going to skip this vertex as the point doesn't move call line_next again
@@ -699,9 +700,9 @@ typename GeometryPBF::command GeometryPBF::ring_next(value_type & rx,
 {
     if (length == 0)
     {
-        if (geo_iterator_.first != geo_iterator_.second)
+        if (geo_itr_ != geo_end_itr_)
         {
-            uint32_t cmd_length = static_cast<uint32_t>(*geo_iterator_.first++);
+            uint32_t cmd_length = static_cast<uint32_t>(*geo_itr_++);
             cmd = cmd_length & 0x7;
             length = cmd_length >> 3;
             if (cmd == move_to)
@@ -716,8 +717,8 @@ typename GeometryPBF::command GeometryPBF::ring_next(value_type & rx,
                 // If an exception occurs it will likely be a end_of_buffer_exception with the text:
                 // "end of buffer exception"
                 // While this error message is not verbose a try catch here would slow down processing.
-                int32_t dx = protozero::decode_zigzag32(static_cast<uint32_t>(*geo_iterator_.first++));
-                int32_t dy = protozero::decode_zigzag32(static_cast<uint32_t>(*geo_iterator_.first++));
+                int32_t dx = protozero::decode_zigzag32(static_cast<uint32_t>(*geo_itr_++));
+                int32_t dy = protozero::decode_zigzag32(static_cast<uint32_t>(*geo_itr_++));
                 detail::move_cursor(x, y, dx, dy);
                 rx = x;
                 ry = y;
@@ -759,8 +760,8 @@ typename GeometryPBF::command GeometryPBF::ring_next(value_type & rx,
     // If an exception occurs it will likely be a end_of_buffer_exception with the text:
     // "end of buffer exception"
     // While this error message is not verbose a try catch here would slow down processing.
-    int32_t dx = protozero::decode_zigzag32(static_cast<uint32_t>(*geo_iterator_.first++));
-    int32_t dy = protozero::decode_zigzag32(static_cast<uint32_t>(*geo_iterator_.first++));
+    int32_t dx = protozero::decode_zigzag32(static_cast<uint32_t>(*geo_itr_++));
+    int32_t dy = protozero::decode_zigzag32(static_cast<uint32_t>(*geo_itr_++));
     if (skip_lineto_zero && dx == 0 && dy == 0)
     {
         // We are going to skip this vertex as the point doesn't move call ring_next again
diff --git a/src/vector_tile_is_valid.hpp b/src/vector_tile_is_valid.hpp
@@ -201,7 +201,7 @@ inline void feature_is_valid(protozero::pbf_reader & feature_msg,
                 }
                 has_raster = true;
                 ++raster_feature_count;
-                feature_msg.get_data();
+                feature_msg.get_view();
                 break;
             default:
                 errors.insert(FEATURE_HAS_UNKNOWN_TAG);
diff --git a/src/vector_tile_load_tile.hpp b/src/vector_tile_load_tile.hpp
@@ -62,8 +62,8 @@ void merge_from_buffer(merc_tile & t, const char * data, std::size_t size, bool
         {
             case Tile_Encoding::LAYERS:
                 {
-                    auto layer_data = tile_msg.get_data();
-                    protozero::pbf_reader layer_props_msg(layer_data);
+                    const auto layer_view = tile_msg.get_view();
+                    protozero::pbf_reader layer_props_msg(layer_view);
                     auto layer_info = get_layer_name_and_version(layer_props_msg);
                     std::string const& layer_name = layer_info.first;
                     std::uint32_t version = layer_info.second;
@@ -78,7 +78,7 @@ void merge_from_buffer(merc_tile & t, const char * data, std::size_t size, bool
                         {
                             errors.insert(TILE_REPEATED_LAYER_NAMES);
                         }
-                        protozero::pbf_reader layer_valid_msg(layer_data);
+                        protozero::pbf_reader layer_valid_msg(layer_view);
                         layer_is_valid(layer_valid_msg, errors);
                         if (!errors.empty())
                         {
@@ -94,7 +94,7 @@ void merge_from_buffer(merc_tile & t, const char * data, std::size_t size, bool
                     if (upgrade && version == 1)
                     {
                             // v1 tiles will be converted to v2
-                            protozero::pbf_reader layer_msg(layer_data);
+                            protozero::pbf_reader layer_msg(layer_view);
                             ds_vec.push_back(std::make_shared<mapnik::vector_tile_impl::tile_datasource_pbf>(
                                         layer_msg,
                                         t.x(),
@@ -104,7 +104,7 @@ void merge_from_buffer(merc_tile & t, const char * data, std::size_t size, bool
                     }
                     else
                     {
-                        t.append_layer_buffer(layer_data.first, layer_data.second, layer_name);
+                        t.append_layer_buffer(layer_view.data(), layer_view.size(), layer_name);
                     }
                 }
                 break;
diff --git a/test/geometry_visual_test.cpp b/test/geometry_visual_test.cpp
@@ -68,7 +68,7 @@ void clip_geometry(mapnik::Map const& map,
         {
             protozero::pbf_reader feature_reader = layer_reader.get_message();
             int32_t geometry_type = mapnik::vector_tile_impl::Geometry_Type::UNKNOWN; 
-            std::pair<protozero::pbf_reader::const_uint32_iterator, protozero::pbf_reader::const_uint32_iterator> geom_itr;
+            mapnik::vector_tile_impl::GeometryPBF::pbf_itr geom_itr;
             while (feature_reader.next())
             {
                 if (feature_reader.tag() == mapnik::vector_tile_impl::Feature_Encoding::GEOMETRY)
diff --git a/test/unit/load/merge.cpp b/test/unit/load/merge.cpp
@@ -24,15 +24,15 @@ TEST_CASE( "merge_from_compressed_buffer - vector" )
         protozero::pbf_reader tile_msg(tile.get_buffer());
         while (tile_msg.next(mapnik::vector_tile_impl::Tile_Encoding::LAYERS))
         {
-            auto layer_data = tile_msg.get_data();
-            protozero::pbf_reader layer_props_msg(layer_data);
+            const auto layer_view = tile_msg.get_view();
+            protozero::pbf_reader layer_props_msg(layer_view);
             auto layer_info = mapnik::vector_tile_impl::get_layer_name_and_version(layer_props_msg);
             std::string const& layer_name = layer_info.first;
             std::uint32_t version = layer_info.second;
             CHECK(layer_name == "water");
             CHECK(version == 1);
             std::set<mapnik::vector_tile_impl::validity_error> errors;
-            protozero::pbf_reader layer_valid_msg(layer_data);
+            protozero::pbf_reader layer_valid_msg(layer_view);
             layer_is_valid(layer_valid_msg, errors);
             CHECK(errors.size() == 0);
         }
@@ -51,15 +51,15 @@ TEST_CASE( "merge_from_compressed_buffer - vector" )
         protozero::pbf_reader tile_msg(tile2.get_buffer());
         while (tile_msg.next(mapnik::vector_tile_impl::Tile_Encoding::LAYERS))
         {
-            auto layer_data = tile_msg.get_data();
-            protozero::pbf_reader layer_props_msg(layer_data);
+            const auto layer_view = tile_msg.get_view();
+            protozero::pbf_reader layer_props_msg(layer_view);
             auto layer_info = mapnik::vector_tile_impl::get_layer_name_and_version(layer_props_msg);
             std::string const& layer_name = layer_info.first;
             std::uint32_t version = layer_info.second;
             CHECK(layer_name == "water");
             CHECK(version == 2);
             std::set<mapnik::vector_tile_impl::validity_error> errors;
-            protozero::pbf_reader layer_valid_msg(layer_data);
+            protozero::pbf_reader layer_valid_msg(layer_view);
             layer_is_valid(layer_valid_msg, errors);
             CHECK(errors.size() == 0);
         }
@@ -79,15 +79,15 @@ TEST_CASE( "merge_from_compressed_buffer - raster" )
         protozero::pbf_reader tile_msg(tile.get_buffer());
         while (tile_msg.next(mapnik::vector_tile_impl::Tile_Encoding::LAYERS))
         {
-            auto layer_data = tile_msg.get_data();
-            protozero::pbf_reader layer_props_msg(layer_data);
+            const auto layer_view = tile_msg.get_view();
+            protozero::pbf_reader layer_props_msg(layer_view);
             auto layer_info = mapnik::vector_tile_impl::get_layer_name_and_version(layer_props_msg);
             std::string const& layer_name = layer_info.first;
             std::uint32_t version = layer_info.second;
             CHECK(layer_name == "layer");
             CHECK(version == 2);
             std::set<mapnik::vector_tile_impl::validity_error> errors;
-            protozero::pbf_reader layer_valid_msg(layer_data);
+            protozero::pbf_reader layer_valid_msg(layer_view);
             layer_is_valid(layer_valid_msg, errors);
             CHECK(errors.size() == 0);
         }
diff --git a/test/utils/encoding_util.cpp b/test/utils/encoding_util.cpp
@@ -65,7 +65,7 @@ std::string compare_pbf(mapnik::geometry::geometry<std::int64_t> const& g, unsig
     REQUIRE(mapnik::vector_tile_impl::encode_geometry_pbf(g, feature_writer, x, y));
     protozero::pbf_reader feature_reader(feature_str);
     int32_t geometry_type = mapnik::vector_tile_impl::Geometry_Type::UNKNOWN; 
-    std::pair<protozero::pbf_reader::const_uint32_iterator, protozero::pbf_reader::const_uint32_iterator> geom_itr;
+    mapnik::vector_tile_impl::GeometryPBF::pbf_itr geom_itr;
     while (feature_reader.next())
     {
         if (feature_reader.tag() == mapnik::vector_tile_impl::Feature_Encoding::GEOMETRY)
diff --git a/test/utils/round_trip.cpp b/test/utils/round_trip.cpp
@@ -70,7 +70,7 @@ mapnik::geometry::geometry<double> round_trip(mapnik::geometry::geometry<double>
     }
     protozero::pbf_reader feature_reader = layer_reader.get_message();
     int32_t geometry_type = mapnik::vector_tile_impl::Geometry_Type::UNKNOWN; 
-    std::pair<protozero::pbf_reader::const_uint32_iterator, protozero::pbf_reader::const_uint32_iterator> geom_itr;
+    mapnik::vector_tile_impl::GeometryPBF::pbf_itr geom_itr;
     while (feature_reader.next())
     {
         if (feature_reader.tag() == mapnik::vector_tile_impl::Feature_Encoding::GEOMETRY)
diff --git a/test/vector_tile.cpp b/test/vector_tile.cpp
@@ -71,7 +71,7 @@ TEST_CASE("vector tile from simplified geojson")
     REQUIRE(layer_reader.next(mapnik::vector_tile_impl::Layer_Encoding::FEATURES));
     protozero::pbf_reader feature_reader = layer_reader.get_message();
     int32_t geometry_type = mapnik::vector_tile_impl::Geometry_Type::UNKNOWN; 
-    std::pair<protozero::pbf_reader::const_uint32_iterator, protozero::pbf_reader::const_uint32_iterator> geom_itr;
+    mapnik::vector_tile_impl::GeometryPBF::pbf_itr geom_itr;
     while (feature_reader.next())
     {
         if (feature_reader.tag() == mapnik::vector_tile_impl::Feature_Encoding::GEOMETRY)
diff --git a/test/vector_tile_pbf.cpp b/test/vector_tile_pbf.cpp
@@ -414,7 +414,7 @@ TEST_CASE("pbf vector tile from simplified geojson")
       while (!found && pbf_feature.next(4))
       {
           found = true;
-          std::pair< protozero::pbf_reader::const_uint32_iterator, protozero::pbf_reader::const_uint32_iterator > geom_itr = pbf_feature.get_packed_uint32();
+          mapnik::vector_tile_impl::GeometryPBF::pbf_itr geom_itr = pbf_feature.get_packed_uint32();
           mapnik::vector_tile_impl::GeometryPBF geoms(geom_itr);
           auto geom = mapnik::vector_tile_impl::decode_geometry<double>(geoms, f.type(), 2, tile_x, tile_y, scale, -1.0 * scale);
           unsigned int n_err = 0;

Original file line number	Diff line number	Diff line change
`@@ -57,8 +57,8 @@ void composite(merc_tile & target_vt,`
`57`	`57`	`while (tile_message.next(Tile_Encoding::LAYERS))`
`58`	`58`	`{`
`59`	`59`	`bool reencode_layer = reencode_tile;`
`60`		`- auto data_pair = tile_message.get_data();`
`61`		`- protozero::pbf_reader layer_message(data_pair);`
	`60`	`+ const auto data_view = tile_message.get_view();`
	`61`	`+ protozero::pbf_reader layer_message(data_view);`
`62`	`62`	`if (!layer_message.next(Layer_Encoding::NAME))`
`63`	`63`	`{`
`64`	`64`	`continue;`
`@@ -68,15 +68,15 @@ void composite(merc_tile & target_vt,`
`68`	`68`
`69`	`69`	`if (!reencode_layer)`
`70`	`70`	`{`
`71`		`- target_vt.append_layer_buffer(data_pair.first, data_pair.second, layer_name);`
	`71`	`+ target_vt.append_layer_buffer(data_view.data(), data_view.size(), layer_name);`
`72`	`72`	`}`
`73`	`73`
`74`	`74`	`if (target_vt.has_layer(layer_name))`
`75`	`75`	`{`
`76`	`76`	`continue;`
`77`	`77`	`}`
`78`	`78`
`79`		`- protozero::pbf_reader layer_pbf(data_pair);`
	`79`	`+ protozero::pbf_reader layer_pbf(data_view);`
`80`	`80`	`auto ds = std::make_shared<mapnik::vector_tile_impl::tile_datasource_pbf>(`
`81`	`81`	`layer_pbf,`
`82`	`82`	`vt->x(),`
Original file line number	Diff line number	Diff line change
`@@ -74,14 +74,14 @@ tile_datasource_pbf::tile_datasource_pbf(protozero::pbf_reader const& layer,`
`74`	`74`	`break;`
`75`	`75`	`case Layer_Encoding::FEATURES:`
`76`	`76`	`{`
`77`		`- auto data_pair = layer_.get_data();`
`78`		`- protozero::pbf_reader check_feature(data_pair);`
	`77`	`+ const auto data_view = layer_.get_view();`
	`78`	`+ protozero::pbf_reader check_feature(data_view);`
`79`	`79`	`while (check_feature.next(Feature_Encoding::RASTER))`
`80`	`80`	`{`
`81`	`81`	`type_ = datasource::Raster;`
`82`	`82`	`check_feature.skip();`
`83`	`83`	`}`
`84`		`- protozero::pbf_reader f_msg(data_pair);`
	`84`	`+ protozero::pbf_reader f_msg(data_view);`
`85`	`85`	`features_.push_back(f_msg);`
`86`	`86`	`}`
`87`	`87`	`break;`
Original file line number	Diff line number	Diff line change
`@@ -123,7 +123,7 @@ feature_ptr tile_featureset_pbf<Filter>::next()`
`123`	`123`	`int32_t geometry_type = 0; // vector_tile::Tile_GeomType_UNKNOWN`
`124`	`124`	`bool has_geometry = false;`
`125`	`125`	`bool has_geometry_type = false;`
`126`		`- std::pair<protozero::pbf_reader::const_uint32_iterator, protozero::pbf_reader::const_uint32_iterator> geom_itr;`
	`126`	`+ GeometryPBF::pbf_itr geom_itr;`
`127`	`127`	`bool has_raster = false;`
`128`	`128`	`std::unique_ptr<mapnik::image_reader> reader;`
`129`	`129`	`while (f.next())`
`@@ -136,10 +136,10 @@ feature_ptr tile_featureset_pbf<Filter>::next()`
`136`	`136`	`case 2:`
`137`	`137`	`{`
`138`	`138`	`auto tag_iterator = f.get_packed_uint32();`
`139`		`- for (auto _i = tag_iterator.first; _i != tag_iterator.second;)`
	`139`	`+ for (auto _i = tag_iterator.begin(); _i != tag_iterator.end();)`
`140`	`140`	`{`
`141`	`141`	`std::size_t key_name = *(_i++);`
`142`		`- if (_i == tag_iterator.second)`
	`142`	`+ if (_i == tag_iterator.end())`
`143`	`143`	`{`
`144`	`144`	`throw std::runtime_error("Vector Tile has a feature with an odd number of tags, therefore the tile is invalid.");`
`145`	`145`	`}`
`@@ -186,8 +186,8 @@ feature_ptr tile_featureset_pbf<Filter>::next()`
`186`	`186`	`throw std::runtime_error("Vector Tile has a feature with multiple raster fields, it must have only one of them");`
`187`	`187`	`}`
`188`	`188`	`has_raster = true;`
`189`		`- auto image_buffer = f.get_data();`
`190`		`- reader = std::unique_ptr<mapnik::image_reader>(mapnik::get_image_reader(image_buffer.first, image_buffer.second));`
	`189`	`+ auto image_buffer = f.get_view();`
	`190`	`+ reader = std::unique_ptr<mapnik::image_reader>(mapnik::get_image_reader(image_buffer.data(), image_buffer.size()));`
`191`	`191`	`}`
`192`	`192`	`break;`
`193`	`193`	`case 4:`
Original file line number	Diff line number	Diff line change
`@@ -201,7 +201,7 @@ inline void feature_is_valid(protozero::pbf_reader & feature_msg,`
`201`	`201`	`}`
`202`	`202`	`has_raster = true;`
`203`	`203`	`++raster_feature_count;`
`204`		`- feature_msg.get_data();`
	`204`	`+ feature_msg.get_view();`
`205`	`205`	`break;`
`206`	`206`	`default:`
`207`	`207`	`errors.insert(FEATURE_HAS_UNKNOWN_TAG);`
Original file line number	Diff line number	Diff line change
`@@ -62,8 +62,8 @@ void merge_from_buffer(merc_tile & t, const char * data, std::size_t size, bool`
`62`	`62`	`{`
`63`	`63`	`case Tile_Encoding::LAYERS:`
`64`	`64`	`{`
`65`		`- auto layer_data = tile_msg.get_data();`
`66`		`- protozero::pbf_reader layer_props_msg(layer_data);`
	`65`	`+ const auto layer_view = tile_msg.get_view();`
	`66`	`+ protozero::pbf_reader layer_props_msg(layer_view);`
`67`	`67`	`auto layer_info = get_layer_name_and_version(layer_props_msg);`
`68`	`68`	`std::string const& layer_name = layer_info.first;`
`69`	`69`	`std::uint32_t version = layer_info.second;`
`@@ -78,7 +78,7 @@ void merge_from_buffer(merc_tile & t, const char * data, std::size_t size, bool`
`78`	`78`	`{`
`79`	`79`	`errors.insert(TILE_REPEATED_LAYER_NAMES);`
`80`	`80`	`}`
`81`		`- protozero::pbf_reader layer_valid_msg(layer_data);`
	`81`	`+ protozero::pbf_reader layer_valid_msg(layer_view);`
`82`	`82`	`layer_is_valid(layer_valid_msg, errors);`
`83`	`83`	`if (!errors.empty())`
`84`	`84`	`{`
`@@ -94,7 +94,7 @@ void merge_from_buffer(merc_tile & t, const char * data, std::size_t size, bool`
`94`	`94`	`if (upgrade && version == 1)`
`95`	`95`	`{`
`96`	`96`	`// v1 tiles will be converted to v2`
`97`		`- protozero::pbf_reader layer_msg(layer_data);`
	`97`	`+ protozero::pbf_reader layer_msg(layer_view);`
`98`	`98`	`ds_vec.push_back(std::make_shared<mapnik::vector_tile_impl::tile_datasource_pbf>(`
`99`	`99`	`layer_msg,`
`100`	`100`	`t.x(),`
`@@ -104,7 +104,7 @@ void merge_from_buffer(merc_tile & t, const char * data, std::size_t size, bool`
`104`	`104`	`}`
`105`	`105`	`else`
`106`	`106`	`{`
`107`		`- t.append_layer_buffer(layer_data.first, layer_data.second, layer_name);`
	`107`	`+ t.append_layer_buffer(layer_view.data(), layer_view.size(), layer_name);`
`108`	`108`	`}`
`109`	`109`	`}`
`110`	`110`	`break;`
Original file line number	Diff line number	Diff line change
`@@ -68,7 +68,7 @@ void clip_geometry(mapnik::Map const& map,`
`68`	`68`	`{`
`69`	`69`	`protozero::pbf_reader feature_reader = layer_reader.get_message();`
`70`	`70`	`int32_t geometry_type = mapnik::vector_tile_impl::Geometry_Type::UNKNOWN;`
`71`		`- std::pair<protozero::pbf_reader::const_uint32_iterator, protozero::pbf_reader::const_uint32_iterator> geom_itr;`
	`71`	`+ mapnik::vector_tile_impl::GeometryPBF::pbf_itr geom_itr;`
`72`	`72`	`while (feature_reader.next())`
`73`	`73`	`{`
`74`	`74`	`if (feature_reader.tag() == mapnik::vector_tile_impl::Feature_Encoding::GEOMETRY)`
Original file line number	Diff line number	Diff line change
`@@ -65,7 +65,7 @@ std::string compare_pbf(mapnik::geometry::geometry<std::int64_t> const& g, unsig`
`65`	`65`	`REQUIRE(mapnik::vector_tile_impl::encode_geometry_pbf(g, feature_writer, x, y));`
`66`	`66`	`protozero::pbf_reader feature_reader(feature_str);`
`67`	`67`	`int32_t geometry_type = mapnik::vector_tile_impl::Geometry_Type::UNKNOWN;`
`68`		`- std::pair<protozero::pbf_reader::const_uint32_iterator, protozero::pbf_reader::const_uint32_iterator> geom_itr;`
	`68`	`+ mapnik::vector_tile_impl::GeometryPBF::pbf_itr geom_itr;`
`69`	`69`	`while (feature_reader.next())`
`70`	`70`	`{`
`71`	`71`	`if (feature_reader.tag() == mapnik::vector_tile_impl::Feature_Encoding::GEOMETRY)`
Original file line number	Diff line number	Diff line change
`@@ -70,7 +70,7 @@ mapnik::geometry::geometry<double> round_trip(mapnik::geometry::geometry<double>`
`70`	`70`	`}`
`71`	`71`	`protozero::pbf_reader feature_reader = layer_reader.get_message();`
`72`	`72`	`int32_t geometry_type = mapnik::vector_tile_impl::Geometry_Type::UNKNOWN;`
`73`		`- std::pair<protozero::pbf_reader::const_uint32_iterator, protozero::pbf_reader::const_uint32_iterator> geom_itr;`
	`73`	`+ mapnik::vector_tile_impl::GeometryPBF::pbf_itr geom_itr;`
`74`	`74`	`while (feature_reader.next())`
`75`	`75`	`{`
`76`	`76`	`if (feature_reader.tag() == mapnik::vector_tile_impl::Feature_Encoding::GEOMETRY)`
Original file line number	Diff line number	Diff line change
`@@ -71,7 +71,7 @@ TEST_CASE("vector tile from simplified geojson")`
`71`	`71`	`REQUIRE(layer_reader.next(mapnik::vector_tile_impl::Layer_Encoding::FEATURES));`
`72`	`72`	`protozero::pbf_reader feature_reader = layer_reader.get_message();`
`73`	`73`	`int32_t geometry_type = mapnik::vector_tile_impl::Geometry_Type::UNKNOWN;`
`74`		`- std::pair<protozero::pbf_reader::const_uint32_iterator, protozero::pbf_reader::const_uint32_iterator> geom_itr;`
	`74`	`+ mapnik::vector_tile_impl::GeometryPBF::pbf_itr geom_itr;`
`75`	`75`	`while (feature_reader.next())`
`76`	`76`	`{`
`77`	`77`	`if (feature_reader.tag() == mapnik::vector_tile_impl::Feature_Encoding::GEOMETRY)`
Original file line number	Diff line number	Diff line change
`@@ -414,7 +414,7 @@ TEST_CASE("pbf vector tile from simplified geojson")`
`414`	`414`	`while (!found && pbf_feature.next(4))`
`415`	`415`	`{`
`416`	`416`	`found = true;`
`417`		`- std::pair< protozero::pbf_reader::const_uint32_iterator, protozero::pbf_reader::const_uint32_iterator > geom_itr = pbf_feature.get_packed_uint32();`
	`417`	`+ mapnik::vector_tile_impl::GeometryPBF::pbf_itr geom_itr = pbf_feature.get_packed_uint32();`
`418`	`418`	`mapnik::vector_tile_impl::GeometryPBF geoms(geom_itr);`
`419`	`419`	`auto geom = mapnik::vector_tile_impl::decode_geometry<double>(geoms, f.type(), 2, tile_x, tile_y, scale, -1.0 * scale);`
`420`	`420`	`unsigned int n_err = 0;`