reloco_debug.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 Jarosław Pelczar <jarek@jpelczar.com>
//
// SPDX-License-Identifier: BSD-2-Clause
 
#pragma once
 
#include <microfmt/microfmt.hpp>
#include <reloco/any.hpp>
#include <reloco/error.hpp>
#include <reloco/flat_hash_map.hpp>
#include <reloco/flat_hash_set.hpp>
#include <reloco/rc.hpp>
 
#include "reloco.hpp" // formatter<reloco::type_id>, reused by Debug<any> below
 
namespace reloco {
 
template <> struct Debug<any> {
  static void format(const any &val, const sink &out) noexcept {
    out.write("any(");
    microfmt::format_to(out, "{}", val.type_id());
    out.put(')');
  }
};
 
template <> struct Debug<error> {
  static void format(const error &val, const sink &out) noexcept { microfmt::formatter<error>{}.format(val, out); }
};
 
template <typename T, typename E> struct Debug<expected<T, E>> {
  static void format(const expected<T, E> &val, const sink &out) noexcept {
    if (val.has_value()) {
      microfmt::format_to(out, "Ok({})", microfmt::as_debug(val.value()));
    } else {
      microfmt::format_to(out, "Err({})", microfmt::as_debug(val.error()));
    }
  }
};
 
template <typename E> struct Debug<expected<void, E>> {
  static void format(const expected<void, E> &val, const sink &out) noexcept {
    if (val.has_value()) {
      out.write("Ok()");
    } else {
      microfmt::format_to(out, "Err({})", microfmt::as_debug(val.error()));
    }
  }
};
 
template <typename T> struct Debug<rc<T>> {
  static void format(const rc<T> &val, const sink &out) noexcept {
    microfmt::format_to(out, "rc(use_count: {}) {{ ", val.use_count());
    if (!val) {
      out.write("(null)");
    } else {
      microfmt::format_to(out, "{}", microfmt::as_debug(*val.get()));
    }
    out.write(" }");
  }
};
 
template <typename T> struct Debug<weak_rc<T>> {
  static void format(const weak_rc<T> &val, const sink &out) noexcept {
    microfmt::format_to(out, "rc(use_count: {}) {{ ", val.use_count());
    auto locked = val.lock();
    if (!locked.has_value()) {
      out.write("(expired)");
    } else {
      microfmt::format_to(out, "{}", microfmt::as_debug(*locked.value().get()));
    }
    out.write(" }");
  }
};
 
template <typename T, typename Hash, typename KeyEqual> struct Debug<flat_hash_set<T, Hash, KeyEqual>> {
  static void format(const flat_hash_set<T, Hash, KeyEqual> &val, const sink &out) noexcept {
    microfmt::format_to(out, "flat_hash_set(size: {}, capacity: {}, load_factor_permille: {}) [", val.size(),
                        val.capacity(), val.load_factor_permille());
    bool is_first = true;
    for (const auto &elem : val) {
      if (!is_first) {
        out.write(", ");
      }
      is_first = false;
      microfmt::format_to(out, "{}", microfmt::as_debug(elem));
    }
    out.put(']');
  }
};
 
template <typename Key, typename Mapped, typename Hash, typename KeyEqual>
struct Debug<flat_hash_map<Key, Mapped, Hash, KeyEqual>> {
  static void format(const flat_hash_map<Key, Mapped, Hash, KeyEqual> &val, const sink &out) noexcept {
    microfmt::format_to(out, "flat_hash_map(size: {}, capacity: {}, load_factor_permille: {}) {{", val.size(),
                        val.capacity(), val.load_factor_permille());
    bool is_first = true;
    for (const auto &entry : val) {
      if (!is_first) {
        out.write(", ");
      }
      is_first = false;
      microfmt::format_to(out, "{}: {}", microfmt::as_debug(entry.first), microfmt::as_debug(entry.second));
    }
    out.put('}');
  }
};
 
} // namespace reloco