New quadkey_t class to capture the quad key concept

Use it in expire code.

Author: joto

src/expire-tiles.cpp

@@ -249,9 +249,9 @@ int expire_tiles::from_result(pg_result_t const &result, osmid_t osm_id)
     return num_tuples;
 }
 
-std::vector<uint64_t> expire_tiles::get_tiles()
+quadkey_list_t expire_tiles::get_tiles()
 {
-    std::vector<uint64_t> tiles;
+    quadkey_list_t tiles;
     tiles.reserve(m_dirty_tiles.size());
     tiles.assign(m_dirty_tiles.begin(), m_dirty_tiles.end());
     std::sort(tiles.begin(), tiles.end());
@@ -276,7 +276,7 @@ void expire_tiles::merge_and_destroy(expire_tiles *other)
     }
 }
 
-std::size_t output_tiles_to_file(std::vector<uint64_t> const &tiles_maxzoom,
+std::size_t output_tiles_to_file(quadkey_list_t const &tiles_maxzoom,
                                  char const *filename, uint32_t minzoom,
                                  uint32_t maxzoom)
 {

src/expire-tiles.hpp

@@ -52,7 +52,7 @@ class expire_tiles
      * Get tiles as a vector of quadkeys and remove them from the expire_tiles
      * object.
      */
-    std::vector<uint64_t> get_tiles();
+    quadkey_list_t get_tiles();
 
     /**
      * Merge the list of expired tiles in the other object into this
@@ -80,7 +80,7 @@ class expire_tiles
     void from_point_list(geom::point_list_t const &list);
 
     /// This is where we collect all the expired tiles.
-    std::unordered_set<uint64_t> m_dirty_tiles;
+    std::unordered_set<quadkey_t> m_dirty_tiles;
 
     /// The tile which has been added last to the unordered set.
     tile_t m_prev_tile;
@@ -104,7 +104,7 @@ class expire_tiles
  * \param output Output function
  */
 template <class OUTPUT>
-std::size_t for_each_tile(std::vector<uint64_t> const &tiles, uint32_t minzoom,
+std::size_t for_each_tile(quadkey_list_t const &tiles, uint32_t minzoom,
                           uint32_t maxzoom, OUTPUT &&output)
 {
     assert(minzoom <= maxzoom);
@@ -119,30 +119,24 @@ std::size_t for_each_tile(std::vector<uint64_t> const &tiles, uint32_t minzoom,
 
     /**
      * Loop over all requested zoom levels (from maximum down to the minimum
-     * zoom level). Tile IDs of the tiles enclosing this tile at lower zoom
-     * levels are calculated using bit shifts.
-     *
-     * last_quadkey is initialized with a value which is not expected to exist
-     * (larger than largest possible quadkey).
+     * zoom level).
      */
-    uint64_t last_quadkey = 1ULL << (2 * maxzoom);
+    quadkey_t last_quadkey{};
     std::size_t count = 0;
     for (auto const quadkey : tiles) {
         for (uint32_t dz = 0; dz <= maxzoom - minzoom; ++dz) {
-            // scale down to the current zoom level
-            uint64_t const qt_current = quadkey >> (dz * 2);
+            auto const qt_current = quadkey.down(dz);
             /**
              * If dz > 0, there are probably multiple elements whose quadkey
              * is equal because they are all sub-tiles of the same tile at the
              * current zoom level. We skip all of them after we have written
              * the first sibling.
              */
-            if (qt_current == last_quadkey >> (dz * 2)) {
-                continue;
+            if (qt_current != last_quadkey.down(dz)) {
+                std::forward<OUTPUT>(output)(
+                    tile_t::from_quadkey(qt_current, maxzoom - dz));
+                ++count;
             }
-            auto const tile = tile_t::from_quadkey(qt_current, maxzoom - dz);
-            std::forward<OUTPUT>(output)(tile);
-            ++count;
         }
         last_quadkey = quadkey;
     }
@@ -157,7 +151,7 @@ std::size_t for_each_tile(std::vector<uint64_t> const &tiles, uint32_t minzoom,
  * \param minzoom Minimum zoom level
  * \param maxzoom Maximum zoom level
  */
-std::size_t output_tiles_to_file(std::vector<uint64_t> const &tiles,
+std::size_t output_tiles_to_file(quadkey_list_t const &tiles,
                                  char const *filename, uint32_t minzoom,
                                  uint32_t maxzoom);
 

src/tile.cpp

@@ -53,14 +53,14 @@ static uint32_t deinterleave_lowuint32(uint64_t word) noexcept
     return static_cast<uint32_t>(word);
 }
 
-uint64_t tile_t::quadkey() const noexcept
+quadkey_t tile_t::quadkey() const noexcept
 {
-    return interleave_uint32_with_zeros(m_x) |
-           (interleave_uint32_with_zeros(m_y) << 1U);
+    return {interleave_uint32_with_zeros(m_x) |
+            (interleave_uint32_with_zeros(m_y) << 1U)};
 }
 
-tile_t tile_t::from_quadkey(uint64_t quadkey, uint32_t zoom) noexcept
+tile_t tile_t::from_quadkey(quadkey_t quadkey, uint32_t zoom) noexcept
 {
-    return {zoom, deinterleave_lowuint32(quadkey),
-            deinterleave_lowuint32(quadkey >> 1U)};
+    return {zoom, deinterleave_lowuint32(quadkey.value()),
+            deinterleave_lowuint32(quadkey.value() >> 1U)};
 }

src/tile.hpp

@@ -15,6 +15,56 @@
 #include <cstdint>
 #include <limits>
 
+class quadkey_t
+{
+public:
+    quadkey_t() noexcept = default;
+
+    quadkey_t(uint64_t value) noexcept : m_value(value) {}
+
+    uint64_t value() const noexcept { return m_value; }
+
+    /**
+     * Calculate quad key with the given number of zoom levels down from the
+     * zoom level of this quad key.
+     */
+    quadkey_t down(uint32_t levels) const noexcept
+    {
+        quadkey_t qk;
+        qk.m_value = m_value >> (levels * 2);
+        return qk;
+    }
+
+    friend bool operator==(quadkey_t a, quadkey_t b) noexcept
+    {
+        return a.m_value == b.m_value;
+    }
+
+    friend bool operator!=(quadkey_t a, quadkey_t b) noexcept
+    {
+        return !(a == b);
+    }
+
+    friend bool operator<(quadkey_t a, quadkey_t b) noexcept
+    {
+        return a.value() < b.value();
+    }
+
+private:
+    uint64_t m_value = std::numeric_limits<uint64_t>::max();
+}; // class quadkey_t
+
+template <>
+struct std::hash<quadkey_t>
+{
+    std::size_t operator()(quadkey_t quadkey) const noexcept
+    {
+        return quadkey.value();
+    }
+};
+
+using quadkey_list_t = std::vector<quadkey_t>;
+
 /**
  * A tile in the usual web tile format.
  */
@@ -148,12 +198,12 @@ class tile_t
      * bits from the x and y values, similar to what's used for Bing maps:
      * https://docs.microsoft.com/en-us/bingmaps/articles/bing-maps-tile-system
      */
-    uint64_t quadkey() const noexcept;
+    quadkey_t quadkey() const noexcept;
 
     /**
      * Construct tile from quadkey.
      */
-    static tile_t from_quadkey(uint64_t quadkey, uint32_t zoom) noexcept;
+    static tile_t from_quadkey(quadkey_t quadkey, uint32_t zoom) noexcept;
 
 private:
     static constexpr uint32_t const invalid_zoom =