Update tile unit tests

CHANGELOG.md

@@ -5,6 +5,7 @@
       - ADDED: New optional parameter `annotations` for `table` that accepts `distance`, `duration`, or both `distance,duration` as values [#4990](https://github.com/Project-OSRM/osrm-backend/pull/4990)
     - Infrastructure:
       - ADDED: Updated libosmium and added protozero and vtzero libraries [#5037](https://github.com/Project-OSRM/osrm-backend/pull/5037)
+      - CHANGED: Use vtzero library in tile plugin [#4686](https://github.com/Project-OSRM/osrm-backend/pull/4686)
 
 # 5.17.1
   - Changes from 5.17.0:

include/util/vector_tile.hpp

@@ -9,31 +9,6 @@ namespace util
 {
 namespace vector_tile
 {
-
-const constexpr std::uint32_t ID_TAG = 1;
-const constexpr std::uint32_t NAME_TAG = 1;
-const constexpr std::uint32_t FEATURE_TAG = 2;
-const constexpr std::uint32_t LAYER_TAG = 3;
-const constexpr std::uint32_t GEOMETRY_TAG = 3;
-const constexpr std::uint32_t KEY_TAG = 3;
-const constexpr std::uint32_t VARIANT_TAG = 4;
-const constexpr std::uint32_t EXTENT_TAG = 5;
-const constexpr std::uint32_t VERSION_TAG = 15;
-
-const constexpr std::uint32_t FEATURE_ATTRIBUTES_TAG = 2;
-const constexpr std::uint32_t FEATURE_GEOMETRIES_TAG = 4;
-
-const constexpr std::uint32_t GEOMETRY_TYPE_POINT = 1;
-const constexpr std::uint32_t GEOMETRY_TYPE_LINE = 2;
-
-const constexpr std::uint32_t VARIANT_TYPE_STRING = 1;
-const constexpr std::uint32_t VARIANT_TYPE_FLOAT = 2;
-const constexpr std::uint32_t VARIANT_TYPE_DOUBLE = 3;
-
-const constexpr std::uint32_t VARIANT_TYPE_UINT64 = 5;
-const constexpr std::uint32_t VARIANT_TYPE_SINT64 = 6;
-const constexpr std::uint32_t VARIANT_TYPE_BOOL = 7;
-
 // Vector tiles are 4096 virtual pixels on each side
 const constexpr double EXTENT = 4096.0;
 const constexpr double BUFFER = 128.0;

src/engine/plugins/tile.cpp

@@ -1,8 +1,8 @@
 #include "guidance/turn_instruction.hpp"
 
 #include "engine/plugins/plugin_base.hpp"
-#include "engine/plugins/tile.hpp"
 #include "engine/plugins/plugin_base.hpp"
+#include "engine/plugins/tile.hpp"
 
 #include "util/coordinate_calculation.hpp"
 #include "util/string_view.hpp"
@@ -279,7 +279,8 @@ std::vector<NodeID> getSegregatedNodes(const DataFacadeBase &facade,
     return result;
 }
 
-struct SpeedLayer : public vtzero::layer_builder {
+struct SpeedLayer : public vtzero::layer_builder
+{
 
     vtzero::value_index_small_uint uint_index;
     vtzero::value_index<vtzero::double_value_type, float, std::unordered_map> double_index;
@@ -294,118 +295,126 @@ struct SpeedLayer : public vtzero::layer_builder {
     vtzero::index_value key_name;
     vtzero::index_value key_rate;
 
-    SpeedLayer(vtzero::tile_builder& tile) :
+    SpeedLayer(vtzero::tile_builder &tile)
-        layer_builder(tile, "speeds"),
+        : layer_builder(tile, "speeds"), uint_index(*this), double_index(*this),
-        uint_index(*this),
+          string_index(*this), bool_index(*this), key_speed(add_key_without_dup_check("speed")),
-        double_index(*this),
+          key_is_small(add_key_without_dup_check("is_small")),
-        string_index(*this),
+          key_datasource(add_key_without_dup_check("datasource")),
-        bool_index(*this),
+          key_weight(add_key_without_dup_check("weight")),
-        key_speed(add_key_without_dup_check("speed")),
+          key_duration(add_key_without_dup_check("duration")),
-        key_is_small(add_key_without_dup_check("is_small")),
+          key_name(add_key_without_dup_check("name")), key_rate(add_key_without_dup_check("rate"))
-        key_datasource(add_key_without_dup_check("datasource")),
+    {
-        key_weight(add_key_without_dup_check("weight")),
-        key_duration(add_key_without_dup_check("duration")),
-        key_name(add_key_without_dup_check("name")),
-        key_rate(add_key_without_dup_check("rate")) {
     }
 
 }; // struct SpeedLayer
 
-class SpeedLayerFeatureBuilder : public vtzero::linestring_feature_builder {
+class SpeedLayerFeatureBuilder : public vtzero::linestring_feature_builder
+{
 
-    SpeedLayer& m_layer;
+    SpeedLayer &m_layer;
 
-public:
+  public:
-
+    SpeedLayerFeatureBuilder(SpeedLayer &layer, uint64_t id)
-    SpeedLayerFeatureBuilder(SpeedLayer& layer, uint64_t id) :
+        : vtzero::linestring_feature_builder(layer), m_layer(layer)
-        vtzero::linestring_feature_builder(layer),
+    {
-        m_layer(layer) {
         set_id(id);
     }
 
-    void set_speed(unsigned int value) {
+    void set_speed(unsigned int value)
-        add_property(m_layer.key_speed,
+    {
-                     m_layer.uint_index(std::min(value, 127u)));
+        add_property(m_layer.key_speed, m_layer.uint_index(std::min(value, 127u)));
     }
 
-    void set_is_small(bool value) {
+    void set_is_small(bool value) { add_property(m_layer.key_is_small, m_layer.bool_index(value)); }
-        add_property(m_layer.key_is_small, m_layer.bool_index(value));
-    }
 
-    void set_datasource(const std::string& value) {
+    void set_datasource(const std::string &value)
+    {
         add_property(m_layer.key_datasource,
                      m_layer.string_index(vtzero::encoded_property_value{value}));
     }
 
-    void set_weight(double value) {
+    void set_weight(double value) { add_property(m_layer.key_weight, m_layer.double_index(value)); }
-        add_property(m_layer.key_weight, m_layer.double_index(value));
-    }
 
-    void set_duration(double value) {
+    void set_duration(double value)
+    {
         add_property(m_layer.key_duration, m_layer.double_index(value));
     }
 
-    void set_name(const boost::string_ref& value) {
+    void set_name(const boost::string_ref &value)
-        add_property(m_layer.key_name,
+    {
-                     m_layer.string_index(vtzero::encoded_property_value{value.data(), value.size()}));
+        add_property(
+            m_layer.key_name,
+            m_layer.string_index(vtzero::encoded_property_value{value.data(), value.size()}));
     }
 
-    void set_rate(double value) {
+    void set_rate(double value) { add_property(m_layer.key_rate, m_layer.double_index(value)); }
-        add_property(m_layer.key_rate, m_layer.double_index(value));
-    }
 
 }; // class SpeedLayerFeatureBuilder
 
-struct TurnsLayer : public vtzero::layer_builder {
+struct TurnsLayer : public vtzero::layer_builder
+{
 
     vtzero::value_index<vtzero::sint_value_type, int, std::unordered_map> int_index;
     vtzero::value_index<vtzero::float_value_type, float, std::unordered_map> float_index;
+    vtzero::value_index_internal<std::unordered_map> string_index;
 
     vtzero::index_value key_bearing_in;
     vtzero::index_value key_turn_angle;
     vtzero::index_value key_cost;
     vtzero::index_value key_weight;
+    vtzero::index_value key_turn_type;
+    vtzero::index_value key_turn_modifier;
 
-    TurnsLayer(vtzero::tile_builder& tile) :
+    TurnsLayer(vtzero::tile_builder &tile)
-        layer_builder(tile, "turns"),
+        : layer_builder(tile, "turns"), int_index(*this), float_index(*this), string_index(*this),
-        int_index(*this),
+          key_bearing_in(add_key_without_dup_check("bearing_in")),
-        float_index(*this),
+          key_turn_angle(add_key_without_dup_check("turn_angle")),
-        key_bearing_in(add_key_without_dup_check("bearing_in")),
+          key_cost(add_key_without_dup_check("cost")),
-        key_turn_angle(add_key_without_dup_check("turn_angle")),
+          key_weight(add_key_without_dup_check("weight")),
-        key_cost(add_key_without_dup_check("cost")),
+          key_turn_type(add_key_without_dup_check("type")),
-        key_weight(add_key_without_dup_check("weight")) {
+          key_turn_modifier(add_key_without_dup_check("modifier"))
+    {
     }
 
 }; // struct TurnsLayer
 
-class TurnsLayerFeatureBuilder : public vtzero::point_feature_builder {
+class TurnsLayerFeatureBuilder : public vtzero::point_feature_builder
+{
 
-    TurnsLayer& m_layer;
+    TurnsLayer &m_layer;
 
-public:
+  public:
-
+    TurnsLayerFeatureBuilder(TurnsLayer &layer, uint64_t id)
-    TurnsLayerFeatureBuilder(TurnsLayer& layer, uint64_t id) :
+        : vtzero::point_feature_builder(layer), m_layer(layer)
-        vtzero::point_feature_builder(layer),
+    {
-        m_layer(layer) {
         set_id(id);
     }
 
-    void set_bearing_in(int value) {
+    void set_bearing_in(int value)
+    {
         add_property(m_layer.key_bearing_in, m_layer.int_index(value));
     }
 
-    void set_turn_angle(int value) {
+    void set_turn_angle(int value)
+    {
         add_property(m_layer.key_turn_angle, m_layer.int_index(value));
     }
 
-    void set_cost(float value) {
+    void set_cost(float value) { add_property(m_layer.key_cost, m_layer.float_index(value)); }
-        add_property(m_layer.key_cost, m_layer.float_index(value));
-    }
 
-    void set_weight(float value) {
+    void set_weight(float value) { add_property(m_layer.key_weight, m_layer.float_index(value)); }
-        add_property(m_layer.key_weight, m_layer.float_index(value));
-    }
 
+    void set_turn(osrm::guidance::TurnInstruction value)
+    {
+        const auto type = osrm::guidance::internalInstructionTypeToString(value.type);
+        const auto modifier = osrm::guidance::instructionModifierToString(value.direction_modifier);
+        add_property(
+            m_layer.key_turn_type,
+            m_layer.string_index(vtzero::encoded_property_value{type.data(), type.size()}));
+        add_property(
+            m_layer.key_turn_modifier,
+            m_layer.string_index(vtzero::encoded_property_value{modifier.data(), modifier.size()}));
+    }
 }; // class TurnsLayerFeatureBuilder
 
 void encodeVectorTile(const DataFacadeBase &facade,
@@ -501,7 +510,8 @@ void encodeVectorTile(const DataFacadeBase &facade,
 
                             fbuilder.set_speed(speed_kmh_idx);
                             fbuilder.set_is_small(component_id.is_tiny);
-                            fbuilder.set_datasource(facade.GetDatasourceName(forward_datasource_idx).to_string());
+                            fbuilder.set_datasource(
+                                facade.GetDatasourceName(forward_datasource_idx).to_string());
                             fbuilder.set_weight(forward_weight / 10.0);
                             fbuilder.set_duration(forward_duration / 10.0);
                             fbuilder.set_name(name);
@@ -533,7 +543,8 @@ void encodeVectorTile(const DataFacadeBase &facade,
 
                             fbuilder.set_speed(speed_kmh_idx);
                             fbuilder.set_is_small(component_id.is_tiny);
-                            fbuilder.set_datasource(facade.GetDatasourceName(reverse_datasource_idx).to_string());
+                            fbuilder.set_datasource(
+                                facade.GetDatasourceName(reverse_datasource_idx).to_string());
                             fbuilder.set_weight(reverse_weight / 10.0);
                             fbuilder.set_duration(reverse_duration / 10.0);
                             fbuilder.set_name(name);
@@ -552,9 +563,9 @@ void encodeVectorTile(const DataFacadeBase &facade,
         {
             TurnsLayer turns_layer{tile};
             uint64_t id = 0;
-            for (const auto& turn_data : all_turn_data) {
+            for (const auto &turn_data : all_turn_data)
-                const auto tile_point =
+            {
-                    coordinatesToTilePoint(turn_data.coordinate, tile_bbox);
+                const auto tile_point = coordinatesToTilePoint(turn_data.coordinate, tile_bbox);
                 if (boost::geometry::within(point_t(tile_point.x, tile_point.y), clip_box))
                 {
                     TurnsLayerFeatureBuilder fbuilder{turns_layer, ++id};
@@ -564,6 +575,7 @@ void encodeVectorTile(const DataFacadeBase &facade,
                     fbuilder.set_turn_angle(turn_data.turn_angle);
                     fbuilder.set_cost(turn_data.duration / 10.0);
                     fbuilder.set_weight(turn_data.weight / 10.0);
+                    fbuilder.set_turn(turn_data.turn_instruction);
 
                     fbuilder.commit();
                 }
@@ -595,7 +607,8 @@ void encodeVectorTile(const DataFacadeBase &facade,
                 }
 
                 vtzero::point_feature_builder fbuilder{osmnodes_layer};
-                fbuilder.set_id(static_cast<OSMNodeID::value_type>(facade.GetOSMNodeIDOfNode(internal_node)));
+                fbuilder.set_id(
+                    static_cast<OSMNodeID::value_type>(facade.GetOSMNodeIDOfNode(internal_node)));
                 fbuilder.add_point(tile_point);
                 fbuilder.commit();
             }

test/nodejs/constants.js

@@ -10,7 +10,7 @@ exports.three_test_coordinates = [[7.41337, 43.72956],
 
 exports.two_test_coordinates = exports.three_test_coordinates.slice(0, 2)
 
-exports.test_tile = {'at': [17059, 11948, 15], 'size': 168571};
+exports.test_tile = {'at': [17059, 11948, 15], 'size': 148750};
 
 // Test files generated by the routing engine; check test/data
 if (process.env.OSRM_DATA_PATH !== undefined) {

unit_tests/library/tile.cpp

@@ -14,252 +14,141 @@
 #include "util/typedefs.hpp"
 #include "util/vector_tile.hpp"
 
-#include <protozero/pbf_reader.hpp>
+#include <boost/variant.hpp>
+#include <vtzero/vector_tile.hpp>
+
+#include <map>
 
 #define CHECK_EQUAL_RANGE(R1, R2)                                                                  \
     BOOST_CHECK_EQUAL_COLLECTIONS(R1.begin(), R1.end(), R2.begin(), R2.end());
 
 BOOST_AUTO_TEST_SUITE(tile)
 
-void validate_value(protozero::pbf_reader value)
+using variant_type = boost::variant<std::string, float, double, int64_t, uint64_t, bool>;
+
+std::string to_string(const protozero::data_view &view)
 {
-    using namespace osrm;
+    return std::string{view.data(), view.size()};
-    while (value.next())
+}
+
+void validate_feature_layer(vtzero::layer layer)
+{
+    BOOST_CHECK_EQUAL(layer.version(), 2);
+    BOOST_CHECK_EQUAL(to_string(layer.name()), "speeds");
+    BOOST_CHECK_EQUAL(layer.extent(), osrm::util::vector_tile::EXTENT);
+    BOOST_CHECK_EQUAL(layer.key_table().size(), 7);
+    BOOST_CHECK(layer.num_features() > 2500);
+
+    while (auto feature = layer.next_feature())
     {
-        switch (value.tag())
+        BOOST_CHECK(feature.has_id());
-        {
+        BOOST_CHECK(feature.geometry_type() == vtzero::GeomType::LINESTRING);
-        case util::vector_tile::VARIANT_TYPE_BOOL:
+        BOOST_CHECK(!feature.empty());
-            value.get_bool();
+
-            break;
+        auto props = vtzero::create_properties_map<std::map<std::string, variant_type>>(feature);
-        case util::vector_tile::VARIANT_TYPE_DOUBLE:
+
-            value.get_double();
+        BOOST_CHECK(props.find("speed") != props.end());
-            break;
+        BOOST_CHECK(props["speed"].type() == typeid(uint64_t));
-        case util::vector_tile::VARIANT_TYPE_FLOAT:
+
-            value.get_float();
+        BOOST_CHECK(props.find("rate") != props.end());
-            break;
+        BOOST_CHECK(props["rate"].type() == typeid(double));
-        case util::vector_tile::VARIANT_TYPE_STRING:
+
-            value.get_string();
+        BOOST_CHECK(props.find("weight") != props.end());
-            break;
+        BOOST_CHECK(props["weight"].type() == typeid(double));
-        case util::vector_tile::VARIANT_TYPE_UINT64:
+
-            value.get_uint64();
+        BOOST_CHECK(props.find("duration") != props.end());
-            break;
+        BOOST_CHECK(props["duration"].type() == typeid(double));
-        case util::vector_tile::VARIANT_TYPE_SINT64:
+
-            value.get_sint64();
+        BOOST_CHECK(props.find("is_small") != props.end());
-            break;
+        BOOST_CHECK(props["is_small"].type() == typeid(bool));
-        }
+
+        BOOST_CHECK(props.find("datasource") != props.end());
+        BOOST_CHECK(props["datasource"].type() == typeid(std::string));
+
+        BOOST_CHECK(props.find("name") != props.end());
+        BOOST_CHECK(props["name"].type() == typeid(std::string));
+    }
+
+    auto number_of_uint_values =
+        std::count_if(layer.value_table().begin(), layer.value_table().end(), [](auto v) {
+            return v.type() == vtzero::property_value_type::uint_value;
+        });
+    BOOST_CHECK_EQUAL(number_of_uint_values, 77);
+}
+
+void validate_turn_layer(vtzero::layer layer)
+{
+    BOOST_CHECK_EQUAL(layer.version(), 2);
+    BOOST_CHECK_EQUAL(to_string(layer.name()), "turns");
+    BOOST_CHECK_EQUAL(layer.extent(), osrm::util::vector_tile::EXTENT);
+    BOOST_CHECK_EQUAL(layer.key_table().size(), 6);
+    BOOST_CHECK(layer.num_features() > 700);
+
+    while (auto feature = layer.next_feature())
+    {
+        BOOST_CHECK(feature.has_id());
+        BOOST_CHECK(feature.geometry_type() == vtzero::GeomType::POINT);
+        BOOST_CHECK(!feature.empty());
+
+        auto props = vtzero::create_properties_map<std::map<std::string, variant_type>>(feature);
+
+        BOOST_CHECK(props.find("bearing_in") != props.end());
+        BOOST_CHECK(props["bearing_in"].type() == typeid(std::int64_t));
+
+        BOOST_CHECK(props.find("turn_angle") != props.end());
+        BOOST_CHECK(props["turn_angle"].type() == typeid(std::int64_t));
+
+        BOOST_CHECK(props.find("weight") != props.end());
+        BOOST_CHECK(props["weight"].type() == typeid(float));
+
+        BOOST_CHECK(props.find("cost") != props.end());
+        BOOST_CHECK(props["cost"].type() == typeid(float));
+
+        BOOST_CHECK(props.find("type") != props.end());
+        BOOST_CHECK(props["type"].type() == typeid(std::string));
+
+        BOOST_CHECK(props.find("modifier") != props.end());
+        BOOST_CHECK(props["modifier"].type() == typeid(std::string));
+    }
+
+    auto number_of_float_values =
+        std::count_if(layer.value_table().begin(), layer.value_table().end(), [](auto v) {
+            return v.type() == vtzero::property_value_type::float_value;
+        });
+
+    BOOST_CHECK_EQUAL(number_of_float_values, 74);
+}
+
+void validate_node_layer(vtzero::layer layer)
+{
+    BOOST_CHECK_EQUAL(layer.version(), 2);
+    BOOST_CHECK_EQUAL(to_string(layer.name()), "osmnodes");
+    BOOST_CHECK_EQUAL(layer.extent(), osrm::util::vector_tile::EXTENT);
+    BOOST_CHECK_EQUAL(layer.key_table().size(), 0);
+    BOOST_CHECK_EQUAL(layer.num_features(), 1791);
+
+    while (auto feature = layer.next_feature())
+    {
+        BOOST_CHECK(feature.has_id());
+        BOOST_CHECK(feature.geometry_type() == vtzero::GeomType::POINT);
+        BOOST_CHECK(feature.empty());
     }
 }
 
-void validate_feature_layer(protozero::pbf_reader &layer_message)
+void validate_internal_nodes_layer(vtzero::layer layer)
 {
-    using namespace osrm;
+    BOOST_CHECK_EQUAL(layer.version(), 2);
+    BOOST_CHECK_EQUAL(to_string(layer.name()), "internal-nodes");
+    BOOST_CHECK_EQUAL(layer.extent(), osrm::util::vector_tile::EXTENT);
+    BOOST_CHECK_EQUAL(layer.key_table().size(), 0);
+    BOOST_CHECK_EQUAL(layer.num_features(), 24);
 
-    const auto check_feature = [](protozero::pbf_reader feature_message) {
+    while (auto feature = layer.next_feature())
-        feature_message.next(); // advance parser to first entry
-        BOOST_CHECK_EQUAL(feature_message.tag(), util::vector_tile::GEOMETRY_TAG);
-        BOOST_CHECK_EQUAL(feature_message.get_enum(), util::vector_tile::GEOMETRY_TYPE_LINE);
-
-        feature_message.next(); // advance to next entry
-        BOOST_CHECK_EQUAL(feature_message.tag(), util::vector_tile::ID_TAG);
-        feature_message.get_uint64(); // id
-
-        feature_message.next(); // advance to next entry
-        BOOST_CHECK_EQUAL(feature_message.tag(), util::vector_tile::FEATURE_ATTRIBUTES_TAG);
-        // properties
-        auto property_iter_pair = feature_message.get_packed_uint32();
-        auto value_begin = property_iter_pair.begin();
-        auto value_end = property_iter_pair.end();
-        BOOST_CHECK_EQUAL(std::distance(value_begin, value_end), 14);
-        auto iter = value_begin;
-        BOOST_CHECK_EQUAL(*iter++, 0); // speed key
-        BOOST_CHECK_LT(*iter++, 128);  // speed value
-        BOOST_CHECK_EQUAL(*iter++, 1); // component key
-        // component value
-        BOOST_CHECK_GE(*iter, 128);
-        BOOST_CHECK_LE(*iter, 129);
-        iter++;
-        BOOST_CHECK_EQUAL(*iter++, 2); // data source key
-        *iter++;                       // skip value check, can be valud uint32
-        BOOST_CHECK_EQUAL(*iter++, 3); // weight key
-        BOOST_CHECK_GT(*iter++, 130);  // weight value
-        BOOST_CHECK_EQUAL(*iter++, 4); // duration key
-        BOOST_CHECK_GT(*iter++, 130);  // duration value
-        // name
-        BOOST_CHECK_EQUAL(*iter++, 5);
-        BOOST_CHECK_GT(*iter++, 130);
-        // rate
-        BOOST_CHECK_EQUAL(*iter++, 6);
-        BOOST_CHECK_GT(*iter++, 130);
-        BOOST_CHECK(iter == value_end);
-        // geometry
-        feature_message.next();
-        auto geometry_iter_pair = feature_message.get_packed_uint32();
-        BOOST_CHECK_GT(std::distance(geometry_iter_pair.begin(), geometry_iter_pair.end()), 1);
-    };
-
-    auto number_of_speed_keys = 0u;
-    auto number_of_speed_values = 0u;
-
-    while (layer_message.next())
     {
-        switch (layer_message.tag())
+        BOOST_CHECK(!feature.has_id());
-        {
+        BOOST_CHECK(feature.geometry_type() == vtzero::GeomType::LINESTRING);
-        case util::vector_tile::VERSION_TAG:
+        BOOST_CHECK(feature.empty());
-            BOOST_CHECK_EQUAL(layer_message.get_uint32(), 2);
-            break;
-        case util::vector_tile::NAME_TAG:
-            BOOST_CHECK_EQUAL(layer_message.get_string(), "speeds");
-            break;
-        case util::vector_tile::EXTENT_TAG:
-            BOOST_CHECK_EQUAL(layer_message.get_uint32(), util::vector_tile::EXTENT);
-            break;
-        case util::vector_tile::FEATURE_TAG:
-            check_feature(layer_message.get_message());
-            break;
-        case util::vector_tile::KEY_TAG:
-            layer_message.get_string();
-            number_of_speed_keys++;
-            break;
-        case util::vector_tile::VARIANT_TAG:
-            validate_value(layer_message.get_message());
-            number_of_speed_values++;
-            break;
-        default:
-            BOOST_CHECK(false); // invalid tag
-            break;
-        }
     }
-
-    BOOST_CHECK_EQUAL(number_of_speed_keys, 7);
-    BOOST_CHECK_GT(number_of_speed_values, 128); // speed value resolution
-}
-
-void validate_turn_layer(protozero::pbf_reader &layer_message)
-{
-    using namespace osrm;
-
-    const auto check_turn_feature = [](protozero::pbf_reader feature_message) {
-        feature_message.next(); // advance parser to first entry
-        BOOST_CHECK_EQUAL(feature_message.tag(), util::vector_tile::GEOMETRY_TAG);
-        BOOST_CHECK_EQUAL(feature_message.get_enum(), util::vector_tile::GEOMETRY_TYPE_POINT);
-
-        feature_message.next(); // advance to next entry
-        BOOST_CHECK_EQUAL(feature_message.tag(), util::vector_tile::ID_TAG);
-        feature_message.get_uint64(); // id
-
-        feature_message.next(); // advance to next entry
-        BOOST_CHECK_EQUAL(feature_message.tag(), util::vector_tile::FEATURE_ATTRIBUTES_TAG);
-        // properties
-        auto feature_iter_pair = feature_message.get_packed_uint32();
-        BOOST_CHECK_EQUAL(std::distance(feature_iter_pair.begin(), feature_iter_pair.end()), 12);
-        auto iter = feature_iter_pair.begin();
-        BOOST_CHECK_EQUAL(*iter++, 0); // bearing_in key
-        *iter++;
-        BOOST_CHECK_EQUAL(*iter++, 1); // turn_angle key
-        *iter++;
-        BOOST_CHECK_EQUAL(*iter++, 2); // turn cost (duration) key
-        *iter++;                       // skip value check, can be valud uint32
-        BOOST_CHECK_EQUAL(*iter++, 3); // turn weight key
-        *iter++;                       // skip value check, can be valud uint32
-        BOOST_CHECK_EQUAL(*iter++, 4); // turn type key
-        *iter++;                       // skip value check, can be valud uint32
-        BOOST_CHECK_EQUAL(*iter++, 5); // turn modifier
-        *iter++;                       // skip value check, can be valud uint32
-        BOOST_CHECK(iter == feature_iter_pair.end());
-        // geometry
-        feature_message.next();
-        auto geometry_iter_pair = feature_message.get_packed_uint32();
-        BOOST_CHECK_GT(std::distance(geometry_iter_pair.begin(), geometry_iter_pair.end()), 1);
-    };
-
-    auto number_of_turn_keys = 0u;
-    auto number_of_turns_found = 0u;
-
-    while (layer_message.next())
-    {
-        switch (layer_message.tag())
-        {
-        case util::vector_tile::VERSION_TAG:
-            BOOST_CHECK_EQUAL(layer_message.get_uint32(), 2);
-            break;
-        case util::vector_tile::NAME_TAG:
-            BOOST_CHECK_EQUAL(layer_message.get_string(), "turns");
-            break;
-        case util::vector_tile::EXTENT_TAG:
-            BOOST_CHECK_EQUAL(layer_message.get_uint32(), util::vector_tile::EXTENT);
-            break;
-        case util::vector_tile::FEATURE_TAG:
-            check_turn_feature(layer_message.get_message());
-            number_of_turns_found++;
-            break;
-        case util::vector_tile::KEY_TAG:
-            layer_message.get_string();
-            number_of_turn_keys++;
-            break;
-        case util::vector_tile::VARIANT_TAG:
-            validate_value(layer_message.get_message());
-            break;
-        default:
-            BOOST_CHECK(false); // invalid tag
-            break;
-        }
-    }
-
-    BOOST_CHECK_EQUAL(number_of_turn_keys, 6);
-    BOOST_CHECK(number_of_turns_found > 700);
-}
-
-void validate_node_layer(protozero::pbf_reader &layer_message)
-{
-    using namespace osrm;
-    auto number_of_nodes_found = 0u;
-
-    const auto check_osmnode_feature = [](protozero::pbf_reader feature_message) {
-        feature_message.next(); // advance parser to first entry
-        BOOST_CHECK_EQUAL(feature_message.tag(), util::vector_tile::GEOMETRY_TAG);
-        BOOST_CHECK_EQUAL(feature_message.get_enum(), util::vector_tile::GEOMETRY_TYPE_POINT);
-
-        feature_message.next(); // advance to next entry
-        BOOST_CHECK_EQUAL(feature_message.tag(), util::vector_tile::ID_TAG);
-        feature_message.get_uint64(); // id
-
-        feature_message.next(); // advance to next entry
-        // Note - on this layer, there should be no feature attributes, the next thing
-        // we get should be the geometry
-        BOOST_CHECK_EQUAL(feature_message.tag(), util::vector_tile::FEATURE_GEOMETRIES_TAG);
-        auto geometry_iter_pair = feature_message.get_packed_uint32();
-        BOOST_CHECK_GT(std::distance(geometry_iter_pair.begin(), geometry_iter_pair.end()), 1);
-    };
-
-    while (layer_message.next())
-    {
-        switch (layer_message.tag())
-        {
-        case util::vector_tile::VERSION_TAG:
-            BOOST_CHECK_EQUAL(layer_message.get_uint32(), 2);
-            break;
-        case util::vector_tile::NAME_TAG:
-            BOOST_CHECK_EQUAL(layer_message.get_string(), "osmnodes");
-            break;
-        case util::vector_tile::EXTENT_TAG:
-            BOOST_CHECK_EQUAL(layer_message.get_uint32(), util::vector_tile::EXTENT);
-            break;
-        case util::vector_tile::FEATURE_TAG:
-            check_osmnode_feature(layer_message.get_message());
-            number_of_nodes_found++;
-            break;
-        case util::vector_tile::KEY_TAG:
-            BOOST_CHECK(false); // There should be no properties on node features
-            break;
-        case util::vector_tile::VARIANT_TAG:
-            BOOST_CHECK(false); // There should be no properties on node features
-            break;
-        default:
-            BOOST_CHECK(false); // invalid tag
-            break;
-        }
-    }
-    BOOST_CHECK_EQUAL(number_of_nodes_found, 1791);
 }
 
 void validate_tile(const osrm::OSRM &osrm)
@@ -275,22 +164,12 @@ void validate_tile(const osrm::OSRM &osrm)
 
     BOOST_CHECK(result.size() > 114000);
 
-    protozero::pbf_reader tile_message(result);
+    vtzero::vector_tile tile{result};
 
-    tile_message.next();
+    validate_feature_layer(tile.next_layer());
-    BOOST_CHECK_EQUAL(tile_message.tag(), util::vector_tile::LAYER_TAG); // must be a layer
+    validate_turn_layer(tile.next_layer());
-    protozero::pbf_reader layer_message = tile_message.get_message();
+    validate_node_layer(tile.next_layer());
-    validate_feature_layer(layer_message);
+    validate_internal_nodes_layer(tile.next_layer());
-
-    tile_message.next();
-    BOOST_CHECK_EQUAL(tile_message.tag(), util::vector_tile::LAYER_TAG); // must be a layer
-    layer_message = tile_message.get_message();
-    validate_turn_layer(layer_message);
-
-    tile_message.next();
-    BOOST_CHECK_EQUAL(tile_message.tag(), util::vector_tile::LAYER_TAG); // must be a layer
-    layer_message = tile_message.get_message();
-    validate_node_layer(layer_message);
 }
 
 BOOST_AUTO_TEST_CASE(test_tile_ch)
@@ -330,147 +209,50 @@ void test_tile_turns(const osrm::OSRM &osrm)
 
     BOOST_CHECK_GT(result.size(), 128);
 
-    protozero::pbf_reader tile_message(result);
+    vtzero::vector_tile tile{result};
-    tile_message.next();
-    BOOST_CHECK_EQUAL(tile_message.tag(), util::vector_tile::LAYER_TAG); // must be a layer
-    // Skip the segments layer
-    tile_message.skip();
 
-    tile_message.next();
+    tile.next_layer();
-    auto layer_message = tile_message.get_message();
+    auto layer = tile.next_layer();
+    BOOST_CHECK_EQUAL(to_string(layer.name()), "turns");
 
-    std::vector<int> found_bearing_in_indexes;
+    std::vector<float> actual_time_turn_penalties;
-    std::vector<int> found_turn_angles_indexes;
+    std::vector<float> actual_weight_turn_penalties;
-    std::vector<int> found_time_penalties_indexes;
+    std::vector<std::string> actual_turn_types;
-    std::vector<int> found_weight_penalties_indexes;
+    std::vector<std::string> actual_turn_modifiers;
-    std::vector<int> found_turn_type_indexes;
+    std::vector<std::int64_t> actual_turn_angles;
-    std::vector<int> found_turn_modifier_indexes;
+    std::vector<std::int64_t> actual_turn_bearings;
 
-    const auto check_turn_feature = [&](protozero::pbf_reader feature_message) {
+    while (auto feature = layer.next_feature())
-        feature_message.next(); // advance parser to first entry
-        BOOST_CHECK_EQUAL(feature_message.tag(), util::vector_tile::GEOMETRY_TAG);
-        BOOST_CHECK_EQUAL(feature_message.get_enum(), util::vector_tile::GEOMETRY_TYPE_POINT);
-
-        feature_message.next(); // advance to next entry
-        BOOST_CHECK_EQUAL(feature_message.tag(), util::vector_tile::ID_TAG);
-        feature_message.get_uint64(); // id
-
-        feature_message.next(); // advance to next entry
-        BOOST_CHECK_EQUAL(feature_message.tag(), util::vector_tile::FEATURE_ATTRIBUTES_TAG);
-        // properties
-        auto feature_iter_pair = feature_message.get_packed_uint32();
-        BOOST_CHECK_EQUAL(std::distance(feature_iter_pair.begin(), feature_iter_pair.end()), 12);
-        auto iter = feature_iter_pair.begin();
-        BOOST_CHECK_EQUAL(*iter++, 0); // bearing_in key
-        found_bearing_in_indexes.push_back(*iter++);
-        BOOST_CHECK_EQUAL(*iter++, 1); // turn_angle key
-        found_turn_angles_indexes.push_back(*iter++);
-        BOOST_CHECK_EQUAL(*iter++, 2);                     // "cost" key (actually duration)
-        found_time_penalties_indexes.push_back(*iter++);   // skip value check, can be valud uint32
-        BOOST_CHECK_EQUAL(*iter++, 3);                     // "weight" key
-        found_weight_penalties_indexes.push_back(*iter++); // skip value check, can be valud uint32
-        BOOST_CHECK_EQUAL(*iter++, 4);                     // "weight" key
-        found_turn_type_indexes.push_back(*iter++);        // skip value check, can be valud uint32
-        BOOST_CHECK_EQUAL(*iter++, 5);                     // "weight" key
-        found_turn_modifier_indexes.push_back(*iter++);    // skip value check, can be valud uint32
-        BOOST_CHECK(iter == feature_iter_pair.end());
-        // geometry
-        feature_message.next();
-        auto geometry_iter_pair = feature_message.get_packed_uint32();
-        BOOST_CHECK_GT(std::distance(geometry_iter_pair.begin(), geometry_iter_pair.end()), 1);
-    };
-
-    std::unordered_map<int, float> float_vals;
-    std::unordered_map<int, std::int64_t> sint64_vals;
-    std::unordered_map<int, std::string> string_vals;
-
-    int kv_index = 0;
-
-    const auto check_value = [&](protozero::pbf_reader value) {
-        while (value.next())
-        {
-            switch (value.tag())
-            {
-            case util::vector_tile::VARIANT_TYPE_FLOAT:
-                float_vals[kv_index] = value.get_float();
-                break;
-            case util::vector_tile::VARIANT_TYPE_SINT64:
-                sint64_vals[kv_index] = value.get_sint64();
-                break;
-            case util::vector_tile::VARIANT_TYPE_STRING:
-                string_vals[kv_index] = value.get_string();
-                break;
-            default:
-                BOOST_CHECK(false);
-            }
-            kv_index++;
-        }
-    };
-
-    auto number_of_turn_keys = 0u;
-    auto number_of_turns_found = 0u;
-
-    while (layer_message.next())
     {
-        switch (layer_message.tag())
+        auto props = vtzero::create_properties_map<std::map<std::string, variant_type>>(feature);
-        {
+
-        case util::vector_tile::VERSION_TAG:
+        BOOST_CHECK(props["cost"].type() == typeid(float));
-            BOOST_CHECK_EQUAL(layer_message.get_uint32(), 2);
+        actual_time_turn_penalties.push_back(boost::get<float>(props["cost"]));
-            break;
+        BOOST_CHECK(props["weight"].type() == typeid(float));
-        case util::vector_tile::NAME_TAG:
+        actual_weight_turn_penalties.push_back(boost::get<float>(props["weight"]));
-            BOOST_CHECK_EQUAL(layer_message.get_string(), "turns");
+        BOOST_CHECK(props["turn_angle"].type() == typeid(std::int64_t));
-            break;
+        actual_turn_angles.push_back(boost::get<std::int64_t>(props["turn_angle"]));
-        case util::vector_tile::EXTENT_TAG:
+        BOOST_CHECK(props["bearing_in"].type() == typeid(std::int64_t));
-            BOOST_CHECK_EQUAL(layer_message.get_uint32(), util::vector_tile::EXTENT);
+        actual_turn_bearings.push_back(boost::get<std::int64_t>(props["bearing_in"]));
-            break;
+        BOOST_CHECK(props["type"].type() == typeid(std::string));
-        case util::vector_tile::FEATURE_TAG:
+        actual_turn_types.push_back(boost::get<std::string>(props["type"]));
-            check_turn_feature(layer_message.get_message());
+        BOOST_CHECK(props["modifier"].type() == typeid(std::string));
-            number_of_turns_found++;
+        actual_turn_modifiers.push_back(boost::get<std::string>(props["modifier"]));
-            break;
-        case util::vector_tile::KEY_TAG:
-            layer_message.get_string();
-            number_of_turn_keys++;
-            break;
-        case util::vector_tile::VARIANT_TAG:
-            check_value(layer_message.get_message());
-            break;
-        default:
-            BOOST_CHECK(false); // invalid tag
-            break;
-        }
     }
 
     // Verify that we got the expected turn penalties
-    std::vector<float> actual_time_turn_penalties;
-    for (const auto &i : found_time_penalties_indexes)
-    {
-        BOOST_CHECK(float_vals.count(i) == 1);
-        actual_time_turn_penalties.push_back(float_vals[i]);
-    }
     std::sort(actual_time_turn_penalties.begin(), actual_time_turn_penalties.end());
     const std::vector<float> expected_time_turn_penalties = {
         0, 0, 0, 0, 0, 0, .1f, .1f, .3f, .4f, 1.2f, 1.9f, 5.3f, 5.5f, 5.8f, 7.1f, 7.2f, 7.2f};
     CHECK_EQUAL_RANGE(actual_time_turn_penalties, expected_time_turn_penalties);
 
     // Verify that we got the expected turn penalties
-    std::vector<float> actual_weight_turn_penalties;
-    for (const auto &i : found_weight_penalties_indexes)
-    {
-        BOOST_CHECK(float_vals.count(i) == 1);
-        actual_weight_turn_penalties.push_back(float_vals[i]);
-    }
     std::sort(actual_weight_turn_penalties.begin(), actual_weight_turn_penalties.end());
     const std::vector<float> expected_weight_turn_penalties = {
         0, 0, 0, 0, 0, 0, .1f, .1f, .3f, .4f, 1.2f, 1.9f, 5.3f, 5.5f, 5.8f, 7.1f, 7.2f, 7.2f};
     CHECK_EQUAL_RANGE(actual_weight_turn_penalties, expected_weight_turn_penalties);
 
     // Verify that we got the expected turn types
-    std::vector<std::string> actual_turn_types;
-    for (const auto &i : found_turn_type_indexes)
-    {
-        BOOST_CHECK(string_vals.count(i) == 1);
-        actual_turn_types.push_back(string_vals[i]);
-    }
     std::sort(actual_turn_types.begin(), actual_turn_types.end());
     const std::vector<std::string> expected_turn_types = {"(noturn)",
                                                           "(noturn)",
@@ -493,12 +275,6 @@ void test_tile_turns(const osrm::OSRM &osrm)
     CHECK_EQUAL_RANGE(actual_turn_types, expected_turn_types);
 
     // Verify that we got the expected turn modifiers
-    std::vector<std::string> actual_turn_modifiers;
-    for (const auto &i : found_turn_modifier_indexes)
-    {
-        BOOST_CHECK(string_vals.count(i) == 1);
-        actual_turn_modifiers.push_back(string_vals[i]);
-    }
     std::sort(actual_turn_modifiers.begin(), actual_turn_modifiers.end());
     const std::vector<std::string> expected_turn_modifiers = {"left",
                                                               "left",
@@ -521,24 +297,12 @@ void test_tile_turns(const osrm::OSRM &osrm)
     CHECK_EQUAL_RANGE(actual_turn_modifiers, expected_turn_modifiers);
 
     // Verify the expected turn angles
-    std::vector<std::int64_t> actual_turn_angles;
-    for (const auto &i : found_turn_angles_indexes)
-    {
-        BOOST_CHECK(sint64_vals.count(i) == 1);
-        actual_turn_angles.push_back(sint64_vals[i]);
-    }
     std::sort(actual_turn_angles.begin(), actual_turn_angles.end());
     const std::vector<std::int64_t> expected_turn_angles = {
         -122, -120, -117, -65, -57, -30, -28, -3, -2, 2, 3, 28, 30, 57, 65, 117, 120, 122};
     CHECK_EQUAL_RANGE(actual_turn_angles, expected_turn_angles);
 
     // Verify the expected bearings
-    std::vector<std::int64_t> actual_turn_bearings;
-    for (const auto &i : found_bearing_in_indexes)
-    {
-        BOOST_CHECK(sint64_vals.count(i) == 1);
-        actual_turn_bearings.push_back(sint64_vals[i]);
-    }
     std::sort(actual_turn_bearings.begin(), actual_turn_bearings.end());
     const std::vector<std::int64_t> expected_turn_bearings = {
         49, 49, 107, 107, 169, 169, 171, 171, 229, 229, 257, 257, 286, 286, 349, 349, 352, 352};
@@ -586,132 +350,18 @@ void test_tile_speeds(const osrm::OSRM &osrm)
 
     BOOST_CHECK_GT(result.size(), 128);
 
-    protozero::pbf_reader tile_message(result);
+    vtzero::vector_tile tile{result};
-    tile_message.next();
-    BOOST_CHECK_EQUAL(tile_message.tag(), util::vector_tile::LAYER_TAG); // must be a layer
-    protozero::pbf_reader layer_message = tile_message.get_message();
 
-    std::vector<int> found_speed_indexes;
+    auto layer = tile.next_layer();
-    std::vector<int> found_component_indexes;
+    BOOST_CHECK_EQUAL(to_string(layer.name()), "speeds");
-    std::vector<int> found_datasource_indexes;
-    std::vector<int> found_weight_indexes;
-    std::vector<int> found_duration_indexes;
-    std::vector<int> found_name_indexes;
-    std::vector<int> found_rate_indexes;
-
-    const auto check_feature = [&](protozero::pbf_reader feature_message) {
-        feature_message.next(); // advance parser to first entry
-        BOOST_CHECK_EQUAL(feature_message.tag(), util::vector_tile::GEOMETRY_TAG);
-        BOOST_CHECK_EQUAL(feature_message.get_enum(), util::vector_tile::GEOMETRY_TYPE_LINE);
-
-        feature_message.next(); // advance to next entry
-        BOOST_CHECK_EQUAL(feature_message.tag(), util::vector_tile::ID_TAG);
-        feature_message.get_uint64(); // id
-
-        feature_message.next(); // advance to next entry
-        BOOST_CHECK_EQUAL(feature_message.tag(), util::vector_tile::FEATURE_ATTRIBUTES_TAG);
-        // properties
-        auto property_iter_pair = feature_message.get_packed_uint32();
-        auto value_begin = property_iter_pair.begin();
-        auto value_end = property_iter_pair.end();
-        BOOST_CHECK_EQUAL(std::distance(value_begin, value_end), 14);
-        auto iter = value_begin;
-        BOOST_CHECK_EQUAL(*iter++, 0); // speed key
-        found_speed_indexes.push_back(*iter++);
-        BOOST_CHECK_EQUAL(*iter++, 1); // component key
-        // component value
-        found_component_indexes.push_back(*iter++);
-        BOOST_CHECK_EQUAL(*iter++, 2); // data source key
-        found_datasource_indexes.push_back(*iter++);
-        BOOST_CHECK_EQUAL(*iter++, 3); // weight key
-        found_weight_indexes.push_back(*iter++);
-        BOOST_CHECK_EQUAL(*iter++, 4); // duration key
-        found_duration_indexes.push_back(*iter++);
-        // name
-        BOOST_CHECK_EQUAL(*iter++, 5);
-        found_name_indexes.push_back(*iter++);
-        BOOST_CHECK_EQUAL(*iter++, 6);
-        found_rate_indexes.push_back(*iter++);
-        BOOST_CHECK(iter == value_end);
-        // geometry
-        feature_message.next();
-        auto geometry_iter_pair = feature_message.get_packed_uint32();
-        BOOST_CHECK_GT(std::distance(geometry_iter_pair.begin(), geometry_iter_pair.end()), 1);
-    };
-
-    std::unordered_map<int, std::string> string_vals;
-    std::unordered_map<int, bool> bool_vals;
-    std::unordered_map<int, std::uint64_t> uint64_vals;
-    std::unordered_map<int, double> double_vals;
-
-    int kv_index = 0;
-
-    const auto check_value = [&](protozero::pbf_reader value) {
-        while (value.next())
-        {
-            switch (value.tag())
-            {
-            case util::vector_tile::VARIANT_TYPE_BOOL:
-                bool_vals[kv_index] = value.get_bool();
-                break;
-            case util::vector_tile::VARIANT_TYPE_DOUBLE:
-                double_vals[kv_index] = value.get_double();
-                break;
-            case util::vector_tile::VARIANT_TYPE_FLOAT:
-                value.get_float();
-                break;
-            case util::vector_tile::VARIANT_TYPE_STRING:
-                string_vals[kv_index] = value.get_string();
-                break;
-            case util::vector_tile::VARIANT_TYPE_UINT64:
-                uint64_vals[kv_index] = value.get_uint64();
-                break;
-            case util::vector_tile::VARIANT_TYPE_SINT64:
-                value.get_sint64();
-                break;
-            }
-            kv_index++;
-        }
-    };
-
-    auto number_of_speed_keys = 0u;
-    auto number_of_speed_values = 0u;
-
-    while (layer_message.next())
-    {
-        switch (layer_message.tag())
-        {
-        case util::vector_tile::VERSION_TAG:
-            BOOST_CHECK_EQUAL(layer_message.get_uint32(), 2);
-            break;
-        case util::vector_tile::NAME_TAG:
-            BOOST_CHECK_EQUAL(layer_message.get_string(), "speeds");
-            break;
-        case util::vector_tile::EXTENT_TAG:
-            BOOST_CHECK_EQUAL(layer_message.get_uint32(), util::vector_tile::EXTENT);
-            break;
-        case util::vector_tile::FEATURE_TAG:
-            check_feature(layer_message.get_message());
-            break;
-        case util::vector_tile::KEY_TAG:
-            layer_message.get_string();
-            number_of_speed_keys++;
-            break;
-        case util::vector_tile::VARIANT_TAG:
-            check_value(layer_message.get_message());
-            number_of_speed_values++;
-            break;
-        default:
-            BOOST_CHECK(false); // invalid tag
-            break;
-        }
-    }
 
     std::vector<std::string> actual_names;
-    for (const auto &i : found_name_indexes)
+    while (auto feature = layer.next_feature())
     {
-        BOOST_CHECK(string_vals.count(i) == 1);
+        auto props = vtzero::create_properties_map<std::map<std::string, variant_type>>(feature);
-        actual_names.push_back(string_vals[i]);
+
+        BOOST_CHECK(props["name"].type() == typeid(std::string));
+        actual_names.push_back(boost::get<std::string>(props["name"]));
     }
     std::sort(actual_names.begin(), actual_names.end());
     const std::vector<std::string> expected_names = {"Avenue du Carnier",
@@ -780,62 +430,17 @@ void test_tile_nodes(const osrm::OSRM &osrm)
 
     BOOST_CHECK_GT(result.size(), 128);
 
-    protozero::pbf_reader tile_message(result);
+    vtzero::vector_tile tile{result};
-    tile_message.next();
-    BOOST_CHECK_EQUAL(tile_message.tag(), util::vector_tile::LAYER_TAG); // must be a layer
 
-    // Skip the segments and turns layers
+    tile.next_layer();
-    tile_message.skip();
+    tile.next_layer();
-    tile_message.next();
+    auto layer = tile.next_layer();
-    tile_message.skip();
+    BOOST_CHECK_EQUAL(to_string(layer.name()), "osmnodes");
-
-    // Get the osmnodes layer
-    tile_message.next();
-    protozero::pbf_reader layer_message = tile_message.get_message();
 
     std::vector<OSMNodeID::value_type> found_node_ids;
-
+    while (auto feature = layer.next_feature())
-    const auto check_feature = [&](protozero::pbf_reader feature_message) {
-        feature_message.next(); // advance parser to first entry
-        BOOST_CHECK_EQUAL(feature_message.tag(), util::vector_tile::GEOMETRY_TAG);
-        BOOST_CHECK_EQUAL(feature_message.get_enum(), util::vector_tile::GEOMETRY_TYPE_POINT);
-
-        feature_message.next(); // advance to next entry
-        BOOST_CHECK_EQUAL(feature_message.tag(), util::vector_tile::ID_TAG);
-        found_node_ids.push_back(feature_message.get_uint64()); // id
-
-        feature_message.next(); // advance to next entry
-        BOOST_CHECK_EQUAL(feature_message.tag(), util::vector_tile::FEATURE_GEOMETRIES_TAG);
-        auto geometry_iter_pair = feature_message.get_packed_uint32();
-        BOOST_CHECK_GT(std::distance(geometry_iter_pair.begin(), geometry_iter_pair.end()), 1);
-    };
-
-    while (layer_message.next())
     {
-        switch (layer_message.tag())
+        found_node_ids.push_back(feature.id());
-        {
-        case util::vector_tile::VERSION_TAG:
-            BOOST_CHECK_EQUAL(layer_message.get_uint32(), 2);
-            break;
-        case util::vector_tile::NAME_TAG:
-            BOOST_CHECK_EQUAL(layer_message.get_string(), "osmnodes");
-            break;
-        case util::vector_tile::EXTENT_TAG:
-            BOOST_CHECK_EQUAL(layer_message.get_uint32(), util::vector_tile::EXTENT);
-            break;
-        case util::vector_tile::FEATURE_TAG:
-            check_feature(layer_message.get_message());
-            break;
-        case util::vector_tile::KEY_TAG:
-            BOOST_CHECK(false); // There should be no keys
-            break;
-        case util::vector_tile::VARIANT_TAG:
-            BOOST_CHECK(false); // There should be no values
-            break;
-        default:
-            BOOST_CHECK(false); // invalid tag
-            break;
-        }
     }
 
     std::sort(found_node_ids.begin(), found_node_ids.end());