Use pod_vector for mmap zero-copy support in serialized data structures

Replace std::vector with essentials::pod_vector in all serialized
data structure members. pod_vector supports dual-mode operation:
owned storage (like std::vector) and non-owning view over externally
managed memory (e.g., mmap'd regions), enabling zero-copy deserialization.

Changes:
- bit_vector: m_bits std::vector<uint64_t> -> pod_vector<uint64_t>
- compact_vector: m_bits std::vector<uint64_t> -> pod_vector<uint64_t>
- rank9: m_block_rank_pairs std::vector<uint64_t> -> pod_vector<uint64_t>
- darray: m_positions std::vector<uint64_t> -> pod_vector<uint64_t>,
         templatize access methods for const correctness
- cache_line_elias_fano: m_data std::vector<uint8_t> -> pod_vector<uint8_t>
- endpoints_sequence: m_hints_0 std::vector<uint8_t> -> pod_vector<uint8_t>

No behavioral change for existing code -- pod_vector is a drop-in
replacement when used in owned mode.

Author: adamant-pwn

include/bit_vector.hpp

@@ -322,7 +322,7 @@ struct bit_vector  //
     iterator begin() const { return get_iterator_at(0); }
 
     uint64_t num_bits() const { return m_num_bits; }
-    std::vector<uint64_t> const& data() const { return m_data; }
+    essentials::pod_vector<uint64_t> const& data() const { return m_data; }
 
     uint64_t num_bytes() const { return sizeof(m_num_bits) + essentials::vec_bytes(m_data); }
 
@@ -343,7 +343,7 @@ struct bit_vector  //
 
 protected:
     uint64_t m_num_bits;
-    std::vector<uint64_t> m_data;
+    essentials::pod_vector<uint64_t> m_data;
 
     template <typename Visitor, typename T>
     static void visit_impl(Visitor& visitor, T&& t) {

include/cache_line_elias_fano.hpp

@@ -149,7 +149,7 @@ struct cache_line_elias_fano {
 private:
     uint64_t m_back;
     uint64_t m_size;
-    std::vector<uint8_t> m_bits;
+    essentials::pod_vector<uint8_t> m_bits;
 
     template <typename Visitor, typename T>
     static void visit_impl(Visitor& visitor, T&& t) {

include/compact_vector.hpp

@@ -262,7 +262,7 @@ struct compact_vector  //
     uint64_t back() const { return operator[](size() - 1); }
     uint64_t size() const { return m_size; }
     uint64_t width() const { return m_width; }
-    std::vector<uint64_t> const& data() const { return m_data; }
+    essentials::pod_vector<uint64_t> const& data() const { return m_data; }
 
     typedef enumerator<compact_vector> iterator;
     iterator get_iterator_at(uint64_t pos) const { return iterator(this, pos); }
@@ -293,7 +293,7 @@ struct compact_vector  //
     uint64_t m_size;
     uint64_t m_width;
     uint64_t m_mask;
-    std::vector<uint64_t> m_data;
+    essentials::pod_vector<uint64_t> m_data;
 
     template <typename Visitor, typename T>
     static void visit_impl(Visitor& visitor, T&& t) {

include/darray.hpp

@@ -81,7 +81,7 @@ struct darray {
     darray() : m_positions(0) {}
 
     void build(bit_vector const& B) {
-        std::vector<uint64_t> const& data = B.data();
+        auto const& data = B.data();
         std::vector<uint64_t> cur_block_positions;
         std::vector<int64_t> block_inventory;
         std::vector<uint16_t> subblock_inventory;
@@ -174,7 +174,7 @@ struct darray {
         uint64_t reminder = i & (subblock_size - 1);
         if (!reminder) return start_pos;
 
-        std::vector<uint64_t> const& data = B.data();
+        auto const& data = B.data();
         uint64_t word_idx = start_pos >> 6;
         uint64_t word_shift = start_pos & 63;
         uint64_t word = WordGetter()(data, word_idx) & (uint64_t(-1) << word_shift);
@@ -214,9 +214,9 @@ struct darray {
 
 protected:
     uint64_t m_positions;
-    std::vector<int64_t> m_block_inventory;
-    std::vector<uint16_t> m_subblock_inventory;
-    std::vector<uint64_t> m_overflow_positions;
+    essentials::pod_vector<int64_t> m_block_inventory;
+    essentials::pod_vector<uint16_t> m_subblock_inventory;
+    essentials::pod_vector<uint64_t> m_overflow_positions;
 
     template <typename Visitor, typename T>
     static void visit_impl(Visitor& visitor, T&& t) {
@@ -262,11 +262,13 @@ struct darray {
 namespace util {
 
 struct identity_getter {
-    uint64_t operator()(std::vector<uint64_t> const& data, uint64_t i) const { return data[i]; }
+    template <typename Vec>
+    uint64_t operator()(Vec const& data, uint64_t i) const { return data[i]; }
 };
 
 struct negating_getter {
-    uint64_t operator()(std::vector<uint64_t> const& data, uint64_t i) const { return ~data[i]; }
+    template <typename Vec>
+    uint64_t operator()(Vec const& data, uint64_t i) const { return ~data[i]; }
 };
 
 }  // namespace util

include/endpoints_sequence.hpp

@@ -141,7 +141,7 @@ struct endpoints_sequence {
         uint64_t m_pos;
         uint64_t m_val;
         bit_vector::iterator m_high_bits_it;
-        std::vector<uint8_t>::const_iterator m_low_bits_it;
+        const uint8_t* m_low_bits_it;
 
         void read_next_value() {
             assert(m_pos < m_ptr->size());
@@ -226,7 +226,7 @@ struct endpoints_sequence {
     bit_vector m_high_bits;
     DArray1 m_high_bits_d1;
     compact_vector m_hints_0;
-    std::vector<uint8_t> m_low_bits;
+    essentials::pod_vector<uint8_t> m_low_bits;
 
     template <typename Visitor, typename T>
     static void visit_impl(Visitor& visitor, T&& t) {

include/rank9.hpp

@@ -46,7 +46,7 @@ struct rank9 {
     rank9() {}
 
     void build(bit_vector const& B) {
-        std::vector<uint64_t> const& data = B.data();
+        auto const& data = B.data();
         std::vector<uint64_t> block_rank_pairs;
         uint64_t next_rank = 0;
         uint64_t cur_subrank = 0;
@@ -96,7 +96,7 @@ struct rank9 {
         uint64_t r = sub_block_rank(sub_block);
         uint64_t sub_left = i % 64;
         if (sub_left) {
-            std::vector<uint64_t> const& data = B.data();
+            auto const& data = B.data();
             r += util::popcount(data[sub_block] << (64 - sub_left));
         }
         return r;
@@ -146,7 +146,7 @@ struct rank9 {
     }
 
     static const uint64_t block_size = 8;  // in 64bit words
-    std::vector<uint64_t> m_block_rank_pairs;
+    essentials::pod_vector<uint64_t> m_block_rank_pairs;
 };
 
 }  // namespace bits