👷 Tidy up some code

Author: AshleyRoll

Diff for: include/msg/detail/rle_codec.hpp

@@ -16,25 +16,8 @@
 
 namespace msg::detail {
 
-template <std::size_t N> struct smallest_storage {
-    // select a minimum sized type for indexing into the RLE data blob
-    static CONSTEVAL auto select_index_storage() {
-        if constexpr (N <= std::numeric_limits<std::uint8_t>::max()) {
-            return std::uint8_t{};
-        } else if constexpr (N <= std::numeric_limits<std::uint16_t>::max()) {
-            return std::uint16_t{};
-        } else if constexpr (N <= std::numeric_limits<std::uint32_t>::max()) {
-            return std::uint32_t{};
-        } else {
-            return std::size_t{};
-        }
-    }
-
-    using type = decltype(select_index_storage());
-};
-
 template <std::size_t N>
-using smallest_storage_type = typename smallest_storage<N>::type;
+using smallest_storage_type = decltype(stdx::detail::select_storage<N, void>());
 
 // Captures RLE data for decoding and provides a mechanism to
 // get a single-use enumerator to step through bits in the encoded
@@ -204,11 +187,6 @@ struct rle_intersect {
     constexpr explicit rle_intersect(Decoders &&...decoders)
         : decoder_list{std::forward<Decoders>(decoders)...} {}
 
-    constexpr static auto min_chunk(chunk_type const &a, chunk_type const &b)
-        -> bool {
-        return a.bit_chunk() < b.bit_chunk();
-    }
-
     // iterate over set bits, passing them to bool (&f)(auto bit_number).
     // if f returns true, we abort and return true indicating early exit
     // otherwise return false to indicate no early abort of iteration
@@ -221,12 +199,18 @@ struct rle_intersect {
             chunks.push_back(d.make_chunk_enumerator());
         }
 
+        // advance all chunks by a number of bits
         auto advance = [&](std::size_t bits) {
             for (auto &c : chunks) {
                 c.advance(bits);
             }
         };
 
+        // comparison of chunk bit counts
+        auto min_chunk = [](chunk_type const &a, chunk_type const &b) -> bool {
+            return a.bit_chunk() < b.bit_chunk();
+        };
+
         std::size_t bit{0};
         while (bit < num_bits) {
             // the min "bit_chunk" item in the chunk list is the smallest run

Diff for: include/msg/rle_indexed_handler.hpp

@@ -13,8 +13,7 @@ struct rle_indices : IndicesT... {
         : IndicesT{index_args}..., storage{data} {}
 
     constexpr auto operator()(auto const &data) const {
-        // use a proxy to allow intersection without materializing a full
-        // bitset.
+        // proxy to allow intersection without materializing a full bitset.
         return detail::rle_intersect{std::forward<decltype(storage.decode(
             this->IndicesT::operator()(data)))>(
             storage.decode(this->IndicesT::operator()(data)))...};