Update qtils

Author: Harrm

include/morum/archive_backend.hpp

@@ -6,7 +6,7 @@
 
 #pragma once
 
-#include <qtils/macro.hpp>
+#include <qtils/macro/common.hpp>
 
 #include <morum/common.hpp>
 #include <morum/db.hpp>

include/morum/common.hpp

@@ -10,20 +10,20 @@
 #include <cassert>
 #include <chrono>
 #include <expected>
-#include <iostream>
-#include <print>
 #include <source_location>
 #include <vector>
 
+#include <fmt/format.h>
+
 #include <qtils/bytes.hpp>
 
 #ifdef MORUM_ENABLE_TRACE
 
 #define MORUM_TRACE(msg, ...)                               \
-  std::println("{}:{}: {}",                                 \
+  fmt::println("{}:{}: {}",                                 \
                std::source_location::current().file_name(), \
                std::source_location::current().line(),      \
-               std::format(msg __VA_OPT__(, ) __VA_ARGS__));
+               fmt::format(msg __VA_OPT__(, ) __VA_ARGS__));
 
 namespace morum {
   template <char... Name>
@@ -91,7 +91,7 @@ namespace morum {
 }  // namespace morum
 
 template <>
-struct std::formatter<morum::StorageError, char> {
+struct fmt::formatter<morum::StorageError, char> {
   template <class ParseContext>
   constexpr ParseContext::iterator parse(ParseContext &ctx) {
     auto it = ctx.begin();
@@ -102,7 +102,7 @@ struct std::formatter<morum::StorageError, char> {
   FmtContext::iterator format(const morum::StorageError &e,
                               FmtContext &ctx) const {
     auto out = ctx.out();
-    std::format_to(out,
+    fmt::format_to(out,
                    "From {}:{} - {}\n",
                    e.origin.file_name(),
                    e.origin.line(),

include/morum/merkle_tree.hpp

@@ -18,8 +18,9 @@
 #include <variant>
 
 #include <qtils/assert.hpp>
-#include <qtils/bytes.hpp>
 #include <qtils/bitspan.hpp>
+#include <qtils/bytes.hpp>
+#include <qtils/fixed_byte_vector.hpp>
 #include <qtils/optional_ref.hpp>
 
 #include <morum/common.hpp>

src/merkle_tree/archive_backend.cpp

@@ -1,5 +1,7 @@
 #include <morum/archive_backend.hpp>
 
+#include <qtils/macro/unwrap.hpp>
+
 namespace morum {
 
   std::expected<std::optional<TreeNode>, StorageError> ArchiveNodeLoader::load(

src/merkle_tree/db.cpp

@@ -12,7 +12,8 @@
 #include <rocksdb/status.h>
 #include <rocksdb/write_batch.h>
 #include <qtils/assert.hpp>
-#include <qtils/macro.hpp>
+#include <qtils/byte_utils.hpp>
+#include <qtils/macro/unwrap.hpp>
 
 namespace morum {
 
@@ -90,7 +91,8 @@ namespace morum {
 
     family_idx = 0;
     for ([[maybe_unused]] auto &handle : handles) {
-      [[maybe_unused]] auto name = to_string(static_cast<ColumnFamilyId>(family_idx++));
+      [[maybe_unused]] auto name =
+          to_string(static_cast<ColumnFamilyId>(family_idx++));
       QTILS_ASSERT(name.has_value());
       QTILS_ASSERT_EQ(handle->GetName(), *name);
     }
@@ -111,27 +113,26 @@ namespace morum {
 
     std::expected<void, StorageError> write(
         qtils::ByteSpan key, qtils::ByteSpan value) override {
-      return wrap_status(batch.Put(default_cf,
-          qtils::to_string_view(key),
-          qtils::to_string_view(value)));
+      return wrap_status(
+          batch.Put(default_cf, qtils::byte2str(key), qtils::byte2str(value)));
     }
 
     std::expected<void, StorageError> remove(qtils::ByteSpan key) override {
-      return wrap_status(batch.Delete(default_cf, qtils::to_string_view(key)));
+      return wrap_status(batch.Delete(default_cf, qtils::byte2str(key)));
     }
 
     std::expected<void, StorageError> write(ColumnFamilyId cf,
         qtils::ByteSpan key,
         qtils::ByteSpan value) override {
       return wrap_status(batch.Put(db->handles[static_cast<size_t>(cf)],
-          qtils::to_string_view(key),
-          qtils::to_string_view(value)));
+          qtils::byte2str(key),
+          qtils::byte2str(value)));
     }
 
     std::expected<void, StorageError> remove(
         ColumnFamilyId cf, qtils::ByteSpan key) override {
       return wrap_status(batch.Delete(
-          db->handles[static_cast<size_t>(cf)], qtils::to_string_view(key)));
+          db->handles[static_cast<size_t>(cf)], qtils::byte2str(key)));
     }
 
     std::shared_ptr<RocksDb> db;
@@ -181,8 +182,8 @@ namespace morum {
       qtils::ByteSpan key, qtils::ByteSpan value) {
     rocksdb::WriteBatch updates;
     QTILS_UNWRAP_void(wrap_status(updates.Put(handle,
-        rocksdb::Slice{qtils::to_string_view(key)},
-        rocksdb::Slice{qtils::to_string_view(value)})));
+        rocksdb::Slice{qtils::byte2str(key)},
+        rocksdb::Slice{qtils::byte2str(value)})));
     QTILS_UNWRAP_void(
         wrap_status(db->db->Write(rocksdb::WriteOptions{}, &updates)));
     return {};
@@ -193,7 +194,7 @@ namespace morum {
     std::string value;
     auto status = db->db->Get(rocksdb::ReadOptions{},
         handle,
-        rocksdb::Slice{qtils::to_string_view(key)},
+        rocksdb::Slice{qtils::byte2str(key)},
         &value);
     if (status.IsNotFound()) {
       return std::nullopt;
@@ -208,7 +209,7 @@ namespace morum {
     std::string res;
     auto status = db->db->Get(rocksdb::ReadOptions{},
         handle,
-        rocksdb::Slice{qtils::to_string_view(key)},
+        rocksdb::Slice{qtils::byte2str(key)},
         &res);
     if (status.IsNotFound()) {
       return std::nullopt;
@@ -220,8 +221,8 @@ namespace morum {
 
   std::expected<void, StorageError> RocksDbColumnFamily::remove(
       qtils::ByteSpan key) const {
-    QTILS_UNWRAP_void(wrap_status(db->db->Delete(
-        rocksdb::WriteOptions{}, handle, qtils::to_string_view(key))));
+    QTILS_UNWRAP_void(wrap_status(
+        db->db->Delete(rocksdb::WriteOptions{}, handle, qtils::byte2str(key))));
     return {};
   }
 

src/merkle_tree/merkle_tree.cpp

@@ -10,7 +10,6 @@
 
 #include <algorithm>
 #include <filesystem>
-#include <format>
 #include <functional>
 #include <iterator>
 #include <memory>
@@ -21,7 +20,10 @@
 #include <vector>
 
 #include <blake2.h>
-#include <qtils/macro.hpp>
+#include <fmt/ranges.h>
+#include <qtils/byte_utils.hpp>
+#include <qtils/hex.hpp>
+#include <qtils/macro/unwrap.hpp>
 
 #include <morum/common.hpp>
 #include <morum/db.hpp>
@@ -204,8 +206,8 @@ namespace morum {
     if (auto hash = branch.get_child_hash(bit); hash.has_value()) {
       QTILS_UNWRAP(auto node_opt, loader_->load(path, *hash));
       if (!node_opt) {
-        return std::unexpected(StorageError{
-            std::format("Node hash {} path {} not found", *hash, path)});
+        return std::unexpected(StorageError{fmt::format(
+            "Node hash {} path {} not found", qtils::Hex{*hash}, path)});
       }
       auto node_id = nodes_->store(*node_opt);
       branch.set_child(bit, node_id);

src/merkle_tree/nomt_backend.cpp

@@ -1,5 +1,7 @@
 #include <morum/nomt_backend.hpp>
 
+#include <qtils/macro/unwrap.hpp>
+
 namespace morum {
 
   qtils::OptionalRef<RawNode> Page::get_node(qtils::BitSpan<> path) {

test/merkle_tree/tree_test.cpp

@@ -6,11 +6,9 @@
 #include <cstdlib>
 #include <expected>
 #include <filesystem>
-#include <format>
 #include <functional>
 #include <memory>
 #include <optional>
-#include <print>
 #include <random>
 #include <ranges>
 #include <span>
@@ -26,6 +24,7 @@
 #include <client/TracyScoped.hpp>
 #include <qtils/assert.hpp>
 #include <qtils/bytes.hpp>
+#include <qtils/hex.hpp>
 #include <tracy/Tracy.hpp>
 
 #include <morum/archive_backend.hpp>
@@ -86,7 +85,7 @@ template <typename Duration>
 NiceDuration(const Duration&) -> NiceDuration<Duration>;
 
 template <typename Duration>
-struct std::formatter<NiceDuration<Duration>> {
+struct fmt::formatter<NiceDuration<Duration>> {
   template <class ParseContext>
   constexpr ParseContext::iterator parse(ParseContext &ctx) {
     auto it = ctx.begin();
@@ -100,22 +99,22 @@ struct std::formatter<NiceDuration<Duration>> {
 
     if (auto n = std::chrono::duration_cast<std::chrono::seconds>(dur).count();
         n > 10) {
-      std::format_to(out, "{}s", n);
+      fmt::format_to(out, "{}s", n);
       return out;
     }
     if (auto n =
             std::chrono::duration_cast<std::chrono::milliseconds>(dur).count();
         n > 10) {
-      std::format_to(out, "{}ms", n);
+      fmt::format_to(out, "{}ms", n);
       return out;
     }
     if (auto n =
             std::chrono::duration_cast<std::chrono::microseconds>(dur).count();
         n > 10) {
-      std::format_to(out, "{}us", n);
+      fmt::format_to(out, "{}us", n);
       return out;
     }
-    std::format_to(out, "{}ns", dur.count());
+    fmt::format_to(out, "{}ns", dur.count());
     return out;
   }
 };
@@ -207,9 +206,9 @@ int main() {
         QTILS_ASSERT_RANGE_EQ(res_opt.value().value(), v);
       }
       previous_root = nomt.get_root_and_store(*tree).value();
-      std::println("{} - {} - total_duration: {}",
+      fmt::println("{} - {} - total_duration: {}",
           step,
-          previous_root,
+          qtils::Hex{previous_root},
           NiceDuration(Clock::now() - total_start));
       totals[step].nomt = Clock::now() - total_start;
     }
@@ -326,32 +325,21 @@ int main() {
 
     stats[step].total_duration += Clock::now() - total_start;
 
-    std::println(
+    fmt::println(
         "\r{} - {}, {}, {} nodes and {} values written, {} bytes of values, "
         "{} "
         "bytes of nodes",
         step,
-        hash,
+        qtils::Hex{hash},
         stats[step].total_duration,
         stats[step].new_nodes_written,
         stats[step].new_values_written,
         stats[step].new_values_size,
         stats[step].new_nodes_written * sizeof(morum::Leaf));
-    std::println("total_duration: {}", stats[step].total_duration);
+    fmt::println("total_duration: {}", stats[step].total_duration);
     totals[step].archive = stats[step].total_duration;
 
-    // std::println("node_reads_duration: {}",
-    // stats[step].node_reads_duration); std::println("value_reads_duration:
-    // {}", stats[step].value_reads_duration);
-    // std::println("writes_in_batch_duration: {}",
-    //              stats[step].writes_in_batch_duration);
-    // std::println("{} - batch_write_duration: {}",
-    //              step,
-    //              stats[step].batch_write_duration);
-
-    // std::println("{}", rocksdb::get_perf_context()->ToString(true));
-    // std::println("{}", rocksdb::get_iostats_context()->ToString());
-    std::println(
+    fmt::println(
         "{}", "=========================================================");
     FrameMark;
   }
@@ -398,32 +386,8 @@ int main() {
   avg.value_reads_duration /= stats.size();
   avg.writes_in_batch_duration /= stats.size();
 
-  // std::println("Avg:");
-  // std::println("total_duration: {}", avg.total_duration);
-  // std::println("batch_write_duration: {}", avg.batch_write_duration);
-  // std::println("node_reads_duration: {}", avg.node_reads_duration);
-  // std::println("value_reads_duration: {}", avg.value_reads_duration);
-  // std::println("writes_in_batch_duration: {}",
-  // avg.writes_in_batch_duration);
-
-  // std::println("Max:");
-  // std::println("total_duration: {}", max.total_duration);
-  // std::println("batch_write_duration: {}", max.batch_write_duration);
-  // std::println("node_reads_duration: {}", max.node_reads_duration);
-  // std::println("value_reads_duration: {}", max.value_reads_duration);
-  // std::println("writes_in_batch_duration: {}",
-  // max.writes_in_batch_duration);
-
-  // std::println("Min:");
-  // std::println("total_duration: {}", min.total_duration);
-  // std::println("batch_write_duration: {}", min.batch_write_duration);
-  // std::println("node_reads_duration: {}", min.node_reads_duration);
-  // std::println("value_reads_duration: {}", min.value_reads_duration);
-  // std::println("writes_in_batch_duration: {}",
-  // min.writes_in_batch_duration);
-
   for (int i = 0; i < STEPS_NUM; i++) {
-    std::println("#{}: NOMT {} vs Archive {}: {:.1f}%",
+    fmt::println("#{}: NOMT {} vs Archive {}: {:.1f}%",
         i,
         NiceDuration(totals[i].nomt),
         NiceDuration(totals[i].archive),

vcpkg-overlay/qtils/portfile.cmake

@@ -2,8 +2,8 @@ vcpkg_check_linkage(ONLY_STATIC_LIBRARY)
 vcpkg_from_github(
   OUT_SOURCE_PATH SOURCE_PATH
   REPO qdrvm/qtils
-  REF 5f46bf03ec9af39c7a1bd85e5f96ccbaa9f4a064
-  SHA512 848577aa4f9abd3d5f8154af9bdf01c81ecb4e41ceb2993e752831ce92706e2fce31fb67a414ee0e5c69424e896941f66877d582f6fd334c193dae365f9297d1
+  REF 837b925296b3824d9fd6b46104990dc56671a1a7
+  SHA512 c84c82b77797fd84c1970371edc00029b784ee73682dea31503fc4f03be8f9474b1387a68ad595c217f53fa61fa2398e17014c2e6e6b1b0764bd687e0a4a3d2a
 )
 vcpkg_cmake_configure(SOURCE_PATH "${SOURCE_PATH}"
   OPTIONS