#include <array>
#include <atomic>
#include <cstddef>
#include <cstdlib>
#include <exception>
#include <format>
#include <optional>
#include <string>
#include <string_view>
#include <utility>
#include <rex/platform.h>
#include <rex/result.h>
#include <rex/types.h>
#include <rex/utility.h>

Classes
class	rex::log::LogCategory
struct	rex::log::CategoryState
class	rex::log::OncePerKey< Count >

Namespaces
namespace	rex
namespace	rex::log

Macros
#define	REXLOG_CATEGORY(name, description)
#define	REXLOG_TABLE(table, ...)
#define	REXLOG_DETAIL_WRITE(cat, level, fmt, ...)
#define	REXLOG_CAT_ONCE(cat, level, once, key, fmt, ...)
#define	REXLOG_CAT_TRACE(cat, fmt, ...)
#define	REXLOG_CAT_DEV(cat, fmt, ...)
#define	REXLOG_CAT_DEBUG(cat, fmt, ...)
#define	REXLOG_CAT_INFO(cat, fmt, ...)
#define	REXLOG_CAT_WARN(cat, fmt, ...)
#define	REXLOG_CAT_ERROR(cat, fmt, ...)
#define	REXLOG_CAT_CRITICAL(cat, fmt, ...)
#define	REX_CAT_FAIL(cat, value, fmt, ...)
#define	REX_CAT_FATAL(cat, fmt, ...)
#define	REX_CAT_CHECK(cat, cond, fmt, ...)
#define	REXLOG_TRACE(fmt, ...)
#define	REXLOG_DEV(fmt, ...)
#define	REXLOG_DEBUG(fmt, ...)
#define	REXLOG_INFO(fmt, ...)
#define	REXLOG_WARN(fmt, ...)
#define	REXLOG_ERROR(fmt, ...)
#define	REXLOG_CRITICAL(fmt, ...)
#define	REXLOG_WARN_ONCE(once, key, fmt, ...)
#define	REX_FAIL(value, fmt, ...)
#define	REX_FATAL(fmt, ...)
#define	REX_CHECK(cond, fmt, ...)
#define	REXSYS_TRACE(fmt, ...)
#define	REXSYS_DEV(fmt, ...)
#define	REXSYS_DEBUG(fmt, ...)
#define	REXSYS_INFO(fmt, ...)
#define	REXSYS_WARN(fmt, ...)
#define	REXSYS_ERROR(fmt, ...)
#define	REXSYS_CRITICAL(fmt, ...)
#define	REXSYS_WARN_ONCE(once, key, fmt, ...)
#define	REXSYS_FAIL(value, fmt, ...)
#define	REXSYS_FATAL(fmt, ...)
#define	REXSYS_CHECK(cond, fmt, ...)
#define	REXAPU_TRACE(fmt, ...)
#define	REXAPU_DEV(fmt, ...)
#define	REXAPU_DEBUG(fmt, ...)
#define	REXAPU_INFO(fmt, ...)
#define	REXAPU_WARN(fmt, ...)
#define	REXAPU_ERROR(fmt, ...)
#define	REXAPU_CRITICAL(fmt, ...)
#define	REXAPU_WARN_ONCE(once, key, fmt, ...)
#define	REXAPU_FAIL(value, fmt, ...)
#define	REXAPU_FATAL(fmt, ...)
#define	REXAPU_CHECK(cond, fmt, ...)
#define	REXFS_TRACE(fmt, ...)
#define	REXFS_DEV(fmt, ...)
#define	REXFS_DEBUG(fmt, ...)
#define	REXFS_INFO(fmt, ...)
#define	REXFS_WARN(fmt, ...)
#define	REXFS_ERROR(fmt, ...)
#define	REXFS_CRITICAL(fmt, ...)
#define	REXFS_WARN_ONCE(once, key, fmt, ...)
#define	REXFS_FAIL(value, fmt, ...)
#define	REXFS_FATAL(fmt, ...)
#define	REXFS_CHECK(cond, fmt, ...)
#define	REXGPU_TRACE(fmt, ...)
#define	REXGPU_DEV(fmt, ...)
#define	REXGPU_DEBUG(fmt, ...)
#define	REXGPU_INFO(fmt, ...)
#define	REXGPU_WARN(fmt, ...)
#define	REXGPU_ERROR(fmt, ...)
#define	REXGPU_CRITICAL(fmt, ...)
#define	REXGPU_WARN_ONCE(once, key, fmt, ...)
#define	REXGPU_FAIL(value, fmt, ...)
#define	REXGPU_FATAL(fmt, ...)
#define	REXGPU_CHECK(cond, fmt, ...)
#define	REXHID_TRACE(fmt, ...)
#define	REXHID_DEV(fmt, ...)
#define	REXHID_DEBUG(fmt, ...)
#define	REXHID_INFO(fmt, ...)
#define	REXHID_WARN(fmt, ...)
#define	REXHID_ERROR(fmt, ...)
#define	REXHID_CRITICAL(fmt, ...)
#define	REXHID_WARN_ONCE(once, key, fmt, ...)
#define	REXHID_FAIL(value, fmt, ...)
#define	REXHID_FATAL(fmt, ...)
#define	REXHID_CHECK(cond, fmt, ...)
#define	REXCPU_TRACE(fmt, ...)
#define	REXCPU_DEV(fmt, ...)
#define	REXCPU_DEBUG(fmt, ...)
#define	REXCPU_INFO(fmt, ...)
#define	REXCPU_WARN(fmt, ...)
#define	REXCPU_ERROR(fmt, ...)
#define	REXCPU_CRITICAL(fmt, ...)
#define	REXCPU_WARN_ONCE(once, key, fmt, ...)
#define	REXCPU_FAIL(value, fmt, ...)
#define	REXCPU_FATAL(fmt, ...)
#define	REXCPU_CHECK(cond, fmt, ...)
#define	REXUI_TRACE(fmt, ...)
#define	REXUI_DEV(fmt, ...)
#define	REXUI_DEBUG(fmt, ...)
#define	REXUI_INFO(fmt, ...)
#define	REXUI_WARN(fmt, ...)
#define	REXUI_ERROR(fmt, ...)
#define	REXUI_CRITICAL(fmt, ...)
#define	REXUI_WARN_ONCE(once, key, fmt, ...)
#define	REXUI_FAIL(value, fmt, ...)
#define	REXUI_FATAL(fmt, ...)
#define	REXUI_CHECK(cond, fmt, ...)
#define	REXCON_TRACE(fmt, ...)
#define	REXCON_DEV(fmt, ...)
#define	REXCON_DEBUG(fmt, ...)
#define	REXCON_INFO(fmt, ...)
#define	REXCON_WARN(fmt, ...)
#define	REXCON_ERROR(fmt, ...)
#define	REXCON_CRITICAL(fmt, ...)
#define	REXCON_WARN_ONCE(once, key, fmt, ...)
#define	REXCON_FAIL(value, fmt, ...)
#define	REXCON_FATAL(fmt, ...)
#define	REXCON_CHECK(cond, fmt, ...)

Enumerations
enum class	rex::log::Level : u8 { rex::log::kTrace , rex::log::kDev , rex::log::kDebug , rex::log::kInfo , rex::log::kWarn , rex::log::kError , rex::log::kCritical , rex::log::kOff }

Functions
Result< Level >	rex::log::ParseLevel (std::string_view text)
std::string_view	rex::log::LevelName (Level level)
void	rex::log::Flush ()
template<typename Fn>
void	rex::log::NoThrow (const LogCategory &category, Fn &&fn) noexcept

Variables
constexpr std::array< std::string_view, 8 >	rex::log::kLevelNames
constexpr size_t	rex::log::kMessageLevelCount = 7

Detailed Description

Copyright: Copyright (c) 2026 Tom Clay tomc@.nosp@m.tcte.nosp@m.chstu.nosp@m.ff.c.nosp@m.om All rights reserved.

License: BSD 3-Clause License See LICENSE file in the project root for full license text.

Macro Definition Documentation

◆ REX_CAT_CHECK

#define REX_CAT_CHECK	(	cat,
		cond,
		fmt,
		... )

Value:

do {                                                                                \
  if (!(cond)) {                                                                    \
    REX_CAT_FATAL(cat, "check failed: " #cond ". " fmt __VA_OPT__(, ) __VA_ARGS__); \
  }                                                                                 \
} while (0)

Writes a Critical message, flushes every sink and aborts when a condition is false.

Parameters

cat	A rex::log::LogCategory lvalue.
cond	The condition that must hold.
fmt	std::format string literal.
...	Format arguments.

REX_CAT_CHECK(category, base != nullptr, "the guest memory base is not mapped");

REX_CAT_CHECK

#define REX_CAT_CHECK(cat, cond, fmt,...)

Definition log_category.h:415

◆ REX_CAT_FAIL

#define REX_CAT_FAIL	(	cat,
		value,
		fmt,
		... )

Value:

do {                                                     \
  REXLOG_CAT_ERROR(cat, fmt __VA_OPT__(, ) __VA_ARGS__); \
  return value;                                          \
} while (0)

Writes an Error message and returns a value from the enclosing function.

Parameters

cat	A rex::log::LogCategory lvalue.
value	The expression the enclosing function returns.
fmt	std::format string literal.
...	Format arguments.

REX_CAT_FAIL(category, X_STATUS_INVALID_PARAMETER, "{} is out of range", index);

REX_CAT_FAIL

#define REX_CAT_FAIL(cat, value, fmt,...)

Definition log_category.h:379

◆ REX_CAT_FATAL

#define REX_CAT_FATAL	(	cat,
		fmt,
		... )

Value:

do {                                                        \
  REXLOG_CAT_CRITICAL(cat, fmt __VA_OPT__(, ) __VA_ARGS__); \
  ::rex::log::Flush();                                      \
  ::std::abort();                                           \
} while (0)

Writes a Critical message, flushes every sink and aborts.

Parameters

cat	A rex::log::LogCategory lvalue.
fmt	std::format string literal.
...	Format arguments.

REX_CAT_FATAL(category, "heap {} is corrupted", name);

REX_CAT_FATAL

#define REX_CAT_FATAL(cat, fmt,...)

Definition log_category.h:396

◆ REX_CHECK

#define REX_CHECK	(	cond,
		fmt,
		... )

Value:

do {                                                                       \
  if (!(cond)) {                                                           \
    REX_FATAL("check failed: " #cond ". " fmt __VA_OPT__(, ) __VA_ARGS__); \
  }                                                                        \
} while (0)

◆ REX_FAIL

#define REX_FAIL	(	value,
		fmt,
		... )

Value:

REX_CAT_FAIL(::rex::log::core, value, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REX_FATAL

#define REX_FATAL	(		fmt,
			... )

Value:

REX_CAT_FATAL(::rex::log::core, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXAPU_CHECK

#define REXAPU_CHECK	(	cond,
		fmt,
		... )

Value:

do {                                                                          \
  if (!(cond)) {                                                              \
    REXAPU_FATAL("check failed: " #cond ". " fmt __VA_OPT__(, ) __VA_ARGS__); \
  }                                                                           \
} while (0)

◆ REXAPU_CRITICAL

#define REXAPU_CRITICAL	(		fmt,
			... )

Value:

REXLOG_CAT_CRITICAL(::rex::log::apu, fmt __VA_OPT__(, ) __VA_ARGS__)

REXLOG_CAT_CRITICAL

#define REXLOG_CAT_CRITICAL(cat, fmt,...)

Definition log_category.h:364

◆ REXAPU_DEBUG

#define REXAPU_DEBUG	(		fmt,
			... )

Value:

REXLOG_CAT_DEBUG(::rex::log::apu, fmt __VA_OPT__(, ) __VA_ARGS__)

REXLOG_CAT_DEBUG

#define REXLOG_CAT_DEBUG(cat, fmt,...)

Definition log_category.h:308

◆ REXAPU_DEV

#define REXAPU_DEV	(		fmt,
			... )

Value:

REXLOG_CAT_DEV(::rex::log::apu, fmt __VA_OPT__(, ) __VA_ARGS__)

REXLOG_CAT_DEV

#define REXLOG_CAT_DEV(cat, fmt,...)

Definition log_category.h:294

◆ REXAPU_ERROR

#define REXAPU_ERROR	(		fmt,
			... )

Value:

REXLOG_CAT_ERROR(::rex::log::apu, fmt __VA_OPT__(, ) __VA_ARGS__)

REXLOG_CAT_ERROR

#define REXLOG_CAT_ERROR(cat, fmt,...)

Definition log_category.h:350

◆ REXAPU_FAIL

#define REXAPU_FAIL	(	value,
		fmt,
		... )

Value:

REX_CAT_FAIL(::rex::log::apu, value, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXAPU_FATAL

#define REXAPU_FATAL	(		fmt,
			... )

Value:

REX_CAT_FATAL(::rex::log::apu, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXAPU_INFO

#define REXAPU_INFO	(		fmt,
			... )

Value:

REXLOG_CAT_INFO(::rex::log::apu, fmt __VA_OPT__(, ) __VA_ARGS__)

REXLOG_CAT_INFO

#define REXLOG_CAT_INFO(cat, fmt,...)

Definition log_category.h:322

◆ REXAPU_TRACE

#define REXAPU_TRACE	(		fmt,
			... )

Value:

REXLOG_CAT_TRACE(::rex::log::apu, fmt __VA_OPT__(, ) __VA_ARGS__)

REXLOG_CAT_TRACE

#define REXLOG_CAT_TRACE(cat, fmt,...)

Definition log_category.h:280

◆ REXAPU_WARN

#define REXAPU_WARN	(		fmt,
			... )

Value:

REXLOG_CAT_WARN(::rex::log::apu, fmt __VA_OPT__(, ) __VA_ARGS__)

REXLOG_CAT_WARN

#define REXLOG_CAT_WARN(cat, fmt,...)

Definition log_category.h:336

◆ REXAPU_WARN_ONCE

#define REXAPU_WARN_ONCE	(	once,
		key,
		fmt,
		... )

Value:

REXLOG_CAT_ONCE(::rex::log::apu, ::rex::log::Level::kWarn, once, key, \

fmt __VA_OPT__(, ) __VA_ARGS__)

REXLOG_CAT_ONCE

#define REXLOG_CAT_ONCE(cat, level, once, key, fmt,...)

Definition log_category.h:262

rex::log::Level::kWarn

@ kWarn

Definition log_category.h:37

◆ REXCON_CHECK

#define REXCON_CHECK	(	cond,
		fmt,
		... )

Value:

do {                                                                          \
  if (!(cond)) {                                                              \
    REXCON_FATAL("check failed: " #cond ". " fmt __VA_OPT__(, ) __VA_ARGS__); \
  }                                                                           \
} while (0)

◆ REXCON_CRITICAL

#define REXCON_CRITICAL	(		fmt,
			... )

Value:

REXLOG_CAT_CRITICAL(::rex::log::console, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXCON_DEBUG

#define REXCON_DEBUG	(		fmt,
			... )

Value:

REXLOG_CAT_DEBUG(::rex::log::console, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXCON_DEV

#define REXCON_DEV	(		fmt,
			... )

Value:

REXLOG_CAT_DEV(::rex::log::console, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXCON_ERROR

#define REXCON_ERROR	(		fmt,
			... )

Value:

REXLOG_CAT_ERROR(::rex::log::console, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXCON_FAIL

#define REXCON_FAIL	(	value,
		fmt,
		... )

Value:

REX_CAT_FAIL(::rex::log::console, value, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXCON_FATAL

#define REXCON_FATAL	(		fmt,
			... )

Value:

REX_CAT_FATAL(::rex::log::console, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXCON_INFO

#define REXCON_INFO	(		fmt,
			... )

Value:

REXLOG_CAT_INFO(::rex::log::console, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXCON_TRACE

#define REXCON_TRACE	(		fmt,
			... )

Value:

REXLOG_CAT_TRACE(::rex::log::console, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXCON_WARN

#define REXCON_WARN	(		fmt,
			... )

Value:

REXLOG_CAT_WARN(::rex::log::console, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXCON_WARN_ONCE

#define REXCON_WARN_ONCE	(	once,
		key,
		fmt,
		... )

Value:

REXLOG_CAT_ONCE(::rex::log::console, ::rex::log::Level::kWarn, once, key, \

fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXCPU_CHECK

#define REXCPU_CHECK	(	cond,
		fmt,
		... )

Value:

do {                                                                          \
  if (!(cond)) {                                                              \
    REXCPU_FATAL("check failed: " #cond ". " fmt __VA_OPT__(, ) __VA_ARGS__); \
  }                                                                           \
} while (0)

◆ REXCPU_CRITICAL

#define REXCPU_CRITICAL	(		fmt,
			... )

Value:

REXLOG_CAT_CRITICAL(::rex::log::cpu, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXCPU_DEBUG

#define REXCPU_DEBUG	(		fmt,
			... )

Value:

REXLOG_CAT_DEBUG(::rex::log::cpu, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXCPU_DEV

#define REXCPU_DEV	(		fmt,
			... )

Value:

REXLOG_CAT_DEV(::rex::log::cpu, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXCPU_ERROR

#define REXCPU_ERROR	(		fmt,
			... )

Value:

REXLOG_CAT_ERROR(::rex::log::cpu, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXCPU_FAIL

#define REXCPU_FAIL	(	value,
		fmt,
		... )

Value:

REX_CAT_FAIL(::rex::log::cpu, value, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXCPU_FATAL

#define REXCPU_FATAL	(		fmt,
			... )

Value:

REX_CAT_FATAL(::rex::log::cpu, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXCPU_INFO

#define REXCPU_INFO	(		fmt,
			... )

Value:

REXLOG_CAT_INFO(::rex::log::cpu, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXCPU_TRACE

#define REXCPU_TRACE	(		fmt,
			... )

Value:

REXLOG_CAT_TRACE(::rex::log::cpu, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXCPU_WARN

#define REXCPU_WARN	(		fmt,
			... )

Value:

REXLOG_CAT_WARN(::rex::log::cpu, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXCPU_WARN_ONCE

#define REXCPU_WARN_ONCE	(	once,
		key,
		fmt,
		... )

Value:

REXLOG_CAT_ONCE(::rex::log::cpu, ::rex::log::Level::kWarn, once, key, \

fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXFS_CHECK

#define REXFS_CHECK	(	cond,
		fmt,
		... )

Value:

do {                                                                         \
  if (!(cond)) {                                                             \
    REXFS_FATAL("check failed: " #cond ". " fmt __VA_OPT__(, ) __VA_ARGS__); \
  }                                                                          \
} while (0)

◆ REXFS_CRITICAL

#define REXFS_CRITICAL	(		fmt,
			... )

Value:

REXLOG_CAT_CRITICAL(::rex::log::filesystem, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXFS_DEBUG

#define REXFS_DEBUG	(		fmt,
			... )

Value:

REXLOG_CAT_DEBUG(::rex::log::filesystem, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXFS_DEV

#define REXFS_DEV	(		fmt,
			... )

Value:

REXLOG_CAT_DEV(::rex::log::filesystem, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXFS_ERROR

#define REXFS_ERROR	(		fmt,
			... )

Value:

REXLOG_CAT_ERROR(::rex::log::filesystem, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXFS_FAIL

#define REXFS_FAIL	(	value,
		fmt,
		... )

Value:

REX_CAT_FAIL(::rex::log::filesystem, value, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXFS_FATAL

#define REXFS_FATAL	(		fmt,
			... )

Value:

REX_CAT_FATAL(::rex::log::filesystem, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXFS_INFO

#define REXFS_INFO	(		fmt,
			... )

Value:

REXLOG_CAT_INFO(::rex::log::filesystem, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXFS_TRACE

#define REXFS_TRACE	(		fmt,
			... )

Value:

REXLOG_CAT_TRACE(::rex::log::filesystem, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXFS_WARN

#define REXFS_WARN	(		fmt,
			... )

Value:

REXLOG_CAT_WARN(::rex::log::filesystem, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXFS_WARN_ONCE

#define REXFS_WARN_ONCE	(	once,
		key,
		fmt,
		... )

Value:

REXLOG_CAT_ONCE(::rex::log::filesystem, ::rex::log::Level::kWarn, once, key, \

fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXGPU_CHECK

#define REXGPU_CHECK	(	cond,
		fmt,
		... )

Value:

do {                                                                          \
  if (!(cond)) {                                                              \
    REXGPU_FATAL("check failed: " #cond ". " fmt __VA_OPT__(, ) __VA_ARGS__); \
  }                                                                           \
} while (0)

◆ REXGPU_CRITICAL

#define REXGPU_CRITICAL	(		fmt,
			... )

Value:

REXLOG_CAT_CRITICAL(::rex::log::gpu, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXGPU_DEBUG

#define REXGPU_DEBUG	(		fmt,
			... )

Value:

REXLOG_CAT_DEBUG(::rex::log::gpu, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXGPU_DEV

#define REXGPU_DEV	(		fmt,
			... )

Value:

REXLOG_CAT_DEV(::rex::log::gpu, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXGPU_ERROR

#define REXGPU_ERROR	(		fmt,
			... )

Value:

REXLOG_CAT_ERROR(::rex::log::gpu, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXGPU_FAIL

#define REXGPU_FAIL	(	value,
		fmt,
		... )

Value:

REX_CAT_FAIL(::rex::log::gpu, value, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXGPU_FATAL

#define REXGPU_FATAL	(		fmt,
			... )

Value:

REX_CAT_FATAL(::rex::log::gpu, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXGPU_INFO

#define REXGPU_INFO	(		fmt,
			... )

Value:

REXLOG_CAT_INFO(::rex::log::gpu, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXGPU_TRACE

#define REXGPU_TRACE	(		fmt,
			... )

Value:

REXLOG_CAT_TRACE(::rex::log::gpu, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXGPU_WARN

#define REXGPU_WARN	(		fmt,
			... )

Value:

REXLOG_CAT_WARN(::rex::log::gpu, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXGPU_WARN_ONCE

#define REXGPU_WARN_ONCE	(	once,
		key,
		fmt,
		... )

Value:

REXLOG_CAT_ONCE(::rex::log::gpu, ::rex::log::Level::kWarn, once, key, \

fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXHID_CHECK

#define REXHID_CHECK	(	cond,
		fmt,
		... )

Value:

do {                                                                          \
  if (!(cond)) {                                                              \
    REXHID_FATAL("check failed: " #cond ". " fmt __VA_OPT__(, ) __VA_ARGS__); \
  }                                                                           \
} while (0)

◆ REXHID_CRITICAL

#define REXHID_CRITICAL	(		fmt,
			... )

Value:

REXLOG_CAT_CRITICAL(::rex::log::hid, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXHID_DEBUG

#define REXHID_DEBUG	(		fmt,
			... )

Value:

REXLOG_CAT_DEBUG(::rex::log::hid, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXHID_DEV

#define REXHID_DEV	(		fmt,
			... )

Value:

REXLOG_CAT_DEV(::rex::log::hid, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXHID_ERROR

#define REXHID_ERROR	(		fmt,
			... )

Value:

REXLOG_CAT_ERROR(::rex::log::hid, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXHID_FAIL

#define REXHID_FAIL	(	value,
		fmt,
		... )

Value:

REX_CAT_FAIL(::rex::log::hid, value, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXHID_FATAL

#define REXHID_FATAL	(		fmt,
			... )

Value:

REX_CAT_FATAL(::rex::log::hid, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXHID_INFO

#define REXHID_INFO	(		fmt,
			... )

Value:

REXLOG_CAT_INFO(::rex::log::hid, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXHID_TRACE

#define REXHID_TRACE	(		fmt,
			... )

Value:

REXLOG_CAT_TRACE(::rex::log::hid, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXHID_WARN

#define REXHID_WARN	(		fmt,
			... )

Value:

REXLOG_CAT_WARN(::rex::log::hid, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXHID_WARN_ONCE

#define REXHID_WARN_ONCE	(	once,
		key,
		fmt,
		... )

Value:

REXLOG_CAT_ONCE(::rex::log::hid, ::rex::log::Level::kWarn, once, key, \

fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXLOG_CAT_CRITICAL

#define REXLOG_CAT_CRITICAL	(	cat,
		fmt,
		... )

Value:

REXLOG_DETAIL_WRITE(cat, ::rex::log::Level::kCritical, fmt __VA_OPT__(, ) __VA_ARGS__)

REXLOG_DETAIL_WRITE

#define REXLOG_DETAIL_WRITE(cat, level, fmt,...)

Definition log_category.h:241

rex::log::Level::kCritical

@ kCritical

Definition log_category.h:39

Writes a Critical message.

Parameters

cat	A rex::log::LogCategory lvalue.
fmt	std::format string literal.
...	Format arguments.

REXLOG_CAT_CRITICAL(category, "{}", text);

◆ REXLOG_CAT_DEBUG

#define REXLOG_CAT_DEBUG	(	cat,
		fmt,
		... )

Value:

REXLOG_DETAIL_WRITE(cat, ::rex::log::Level::kDebug, fmt __VA_OPT__(, ) __VA_ARGS__)

rex::log::Level::kDebug

@ kDebug

Definition log_category.h:35

Writes a Debug message.

Parameters

cat	A rex::log::LogCategory lvalue.
fmt	std::format string literal.
...	Format arguments.

REXLOG_CAT_DEBUG(category, "{}", text);

◆ REXLOG_CAT_DEV

#define REXLOG_CAT_DEV	(	cat,
		fmt,
		... )

Value:

REXLOG_DETAIL_WRITE(cat, ::rex::log::Level::kDev, fmt __VA_OPT__(, ) __VA_ARGS__)

rex::log::Level::kDev

@ kDev

Definition log_category.h:34

Writes a Dev message.

Parameters

cat	A rex::log::LogCategory lvalue.
fmt	std::format string literal.
...	Format arguments.

REXLOG_CAT_DEV(category, "{}", text);

◆ REXLOG_CAT_ERROR

#define REXLOG_CAT_ERROR	(	cat,
		fmt,
		... )

Value:

REXLOG_DETAIL_WRITE(cat, ::rex::log::Level::kError, fmt __VA_OPT__(, ) __VA_ARGS__)

rex::log::Level::kError

@ kError

Definition log_category.h:38

Writes an Error message.

Parameters

cat	A rex::log::LogCategory lvalue.
fmt	std::format string literal.
...	Format arguments.

REXLOG_CAT_ERROR(category, "{}", text);

◆ REXLOG_CAT_INFO

#define REXLOG_CAT_INFO	(	cat,
		fmt,
		... )

Value:

REXLOG_DETAIL_WRITE(cat, ::rex::log::Level::kInfo, fmt __VA_OPT__(, ) __VA_ARGS__)

rex::log::Level::kInfo

@ kInfo

Definition log_category.h:36

Writes an Info message.

Parameters

cat	A rex::log::LogCategory lvalue.
fmt	std::format string literal.
...	Format arguments.

REXLOG_CAT_INFO(category, "{}", text);

◆ REXLOG_CAT_ONCE

#define REXLOG_CAT_ONCE	(	cat,
		level,
		once,
		key,
		fmt,
		... )

Value:

do {                                                                                  \
  if ((cat).IsEnabled(level) && (once).IsFirst(key)) {                                \
    ::rex::log::detail::WriteFormatted((cat), level, fmt __VA_OPT__(, ) __VA_ARGS__); \
  }                                                                                   \
} while (0)

Writes a message when the category is enabled and the key has not written yet.

Parameters

cat	A rex::log::LogCategory lvalue.
level	A rex::log::Level.
once	A rex::log::OncePerKey lvalue.
key	The key, written once per distinct value.
fmt	std::format string literal.
...	Format arguments.

REXLOG_CAT_ONCE(category, ::rex::log::Level::kWarn, seen_, index, "register {:04X}", index);

◆ REXLOG_CAT_TRACE

#define REXLOG_CAT_TRACE	(	cat,
		fmt,
		... )

Value:

REXLOG_DETAIL_WRITE(cat, ::rex::log::Level::kTrace, fmt __VA_OPT__(, ) __VA_ARGS__)

rex::log::Level::kTrace

@ kTrace

Definition log_category.h:33

Writes a Trace message.

Parameters

cat	A rex::log::LogCategory lvalue.
fmt	std::format string literal.
...	Format arguments.

REXLOG_CAT_TRACE(category, "{}", text);

◆ REXLOG_CAT_WARN

#define REXLOG_CAT_WARN	(	cat,
		fmt,
		... )

Value:

REXLOG_DETAIL_WRITE(cat, ::rex::log::Level::kWarn, fmt __VA_OPT__(, ) __VA_ARGS__)

Writes a Warn message.

Parameters

cat	A rex::log::LogCategory lvalue.
fmt	std::format string literal.
...	Format arguments.

REXLOG_CAT_WARN(category, "{}", text);

◆ REXLOG_CATEGORY

#define REXLOG_CATEGORY	(		name,
			description )

Value:

namespace rex::log {                                               \
inline constinit ::rex::log::LogCategory name{#name, description}; \
}

Declares the log category rex::log::name. Used at global scope in a header that every writer of the category includes.

Parameters

name	Category name, a lowercase identifier.
description	Shown by the console.

REXLOG_CATEGORY(gpu, "GPU emulation")

REXLOG_CATEGORY

#define REXLOG_CATEGORY(name, description)

Definition log_category.h:162

◆ REXLOG_CRITICAL

#define REXLOG_CRITICAL	(		fmt,
			... )

Value:

REXLOG_CAT_CRITICAL(::rex::log::core, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXLOG_DEBUG

#define REXLOG_DEBUG	(		fmt,
			... )

Value:

REXLOG_CAT_DEBUG(::rex::log::core, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXLOG_DETAIL_WRITE

#define REXLOG_DETAIL_WRITE	(	cat,
		level,
		fmt,
		... )

Value:

do {                                                                                  \
  if ((cat).IsEnabled(level)) {                                                       \
    ::rex::log::detail::WriteFormatted((cat), level, fmt __VA_OPT__(, ) __VA_ARGS__); \
  }                                                                                   \
} while (0)

Writes a message when the category is enabled at the level, else evaluates no arguments.

Parameters

cat	A rex::log::LogCategory lvalue.
level	A rex::log::Level.
fmt	std::format string literal.
...	Format arguments.

REXLOG_DETAIL_WRITE(::rex::log::gpu, ::rex::log::Level::kInfo, "{} pipelines", count);

◆ REXLOG_DEV

#define REXLOG_DEV	(		fmt,
			... )

Value:

REXLOG_CAT_DEV(::rex::log::core, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXLOG_ERROR

#define REXLOG_ERROR	(		fmt,
			... )

Value:

REXLOG_CAT_ERROR(::rex::log::core, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXLOG_INFO

#define REXLOG_INFO	(		fmt,
			... )

Value:

REXLOG_CAT_INFO(::rex::log::core, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXLOG_TABLE

#define REXLOG_TABLE	(		table,
			... )

Value:

namespace rex::log {                                                       \
inline constexpr auto table = ::rex::log::detail::BuildTable(__VA_ARGS__); \
}

Declares rex::log::table, the category addresses a module passes to Logger::AddCategories. Used at global scope.

Parameters

table	The identifier of the generated table, such as kGPULog.
...	Category names.

REXLOG_TABLE(kGPULog, gpu)

rex::GetLogger().AddCategories(rex::log::kGPULog);

rex::Logger::AddCategories

Result< void > AddCategories(std::span< const log::LogCategory *const > categories) override

REXLOG_TABLE

#define REXLOG_TABLE(table,...)

Definition log_category.h:179

rex::GetLogger

Logger & GetLogger()

◆ REXLOG_TRACE

#define REXLOG_TRACE	(		fmt,
			... )

Value:

REXLOG_CAT_TRACE(::rex::log::core, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXLOG_WARN

#define REXLOG_WARN	(		fmt,
			... )

Value:

REXLOG_CAT_WARN(::rex::log::core, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXLOG_WARN_ONCE

#define REXLOG_WARN_ONCE	(	once,
		key,
		fmt,
		... )

Value:

REXLOG_CAT_ONCE(::rex::log::core, ::rex::log::Level::kWarn, once, key, \

fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXSYS_CHECK

#define REXSYS_CHECK	(	cond,
		fmt,
		... )

Value:

do {                                                                          \
  if (!(cond)) {                                                              \
    REXSYS_FATAL("check failed: " #cond ". " fmt __VA_OPT__(, ) __VA_ARGS__); \
  }                                                                           \
} while (0)

◆ REXSYS_CRITICAL

#define REXSYS_CRITICAL	(		fmt,
			... )

Value:

REXLOG_CAT_CRITICAL(::rex::log::system, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXSYS_DEBUG

#define REXSYS_DEBUG	(		fmt,
			... )

Value:

REXLOG_CAT_DEBUG(::rex::log::system, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXSYS_DEV

#define REXSYS_DEV	(		fmt,
			... )

Value:

REXLOG_CAT_DEV(::rex::log::system, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXSYS_ERROR

#define REXSYS_ERROR	(		fmt,
			... )

Value:

REXLOG_CAT_ERROR(::rex::log::system, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXSYS_FAIL

#define REXSYS_FAIL	(	value,
		fmt,
		... )

Value:

REX_CAT_FAIL(::rex::log::system, value, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXSYS_FATAL

#define REXSYS_FATAL	(		fmt,
			... )

Value:

REX_CAT_FATAL(::rex::log::system, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXSYS_INFO

#define REXSYS_INFO	(		fmt,
			... )

Value:

REXLOG_CAT_INFO(::rex::log::system, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXSYS_TRACE

#define REXSYS_TRACE	(		fmt,
			... )

Value:

REXLOG_CAT_TRACE(::rex::log::system, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXSYS_WARN

#define REXSYS_WARN	(		fmt,
			... )

Value:

REXLOG_CAT_WARN(::rex::log::system, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXSYS_WARN_ONCE

#define REXSYS_WARN_ONCE	(	once,
		key,
		fmt,
		... )

Value:

REXLOG_CAT_ONCE(::rex::log::system, ::rex::log::Level::kWarn, once, key, \

fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXUI_CHECK

#define REXUI_CHECK	(	cond,
		fmt,
		... )

Value:

do {                                                                         \
  if (!(cond)) {                                                             \
    REXUI_FATAL("check failed: " #cond ". " fmt __VA_OPT__(, ) __VA_ARGS__); \
  }                                                                          \
} while (0)

◆ REXUI_CRITICAL

#define REXUI_CRITICAL	(		fmt,
			... )

Value:

REXLOG_CAT_CRITICAL(::rex::log::ui, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXUI_DEBUG

#define REXUI_DEBUG	(		fmt,
			... )

Value:

REXLOG_CAT_DEBUG(::rex::log::ui, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXUI_DEV

#define REXUI_DEV	(		fmt,
			... )

Value:

REXLOG_CAT_DEV(::rex::log::ui, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXUI_ERROR

#define REXUI_ERROR	(		fmt,
			... )

Value:

REXLOG_CAT_ERROR(::rex::log::ui, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXUI_FAIL

#define REXUI_FAIL	(	value,
		fmt,
		... )

Value:

REX_CAT_FAIL(::rex::log::ui, value, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXUI_FATAL

#define REXUI_FATAL	(		fmt,
			... )

Value:

REX_CAT_FATAL(::rex::log::ui, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXUI_INFO

#define REXUI_INFO	(		fmt,
			... )

Value:

REXLOG_CAT_INFO(::rex::log::ui, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXUI_TRACE

#define REXUI_TRACE	(		fmt,
			... )

Value:

REXLOG_CAT_TRACE(::rex::log::ui, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXUI_WARN

#define REXUI_WARN	(		fmt,
			... )

Value:

REXLOG_CAT_WARN(::rex::log::ui, fmt __VA_OPT__(, ) __VA_ARGS__)

◆ REXUI_WARN_ONCE

#define REXUI_WARN_ONCE	(	once,
		key,
		fmt,
		... )

Value:

REXLOG_CAT_ONCE(::rex::log::ui, ::rex::log::Level::kWarn, once, key, \

fmt __VA_OPT__(, ) __VA_ARGS__)

Classes

Namespaces

Macros

Enumerations

Functions

Variables

Detailed Description

Macro Definition Documentation

◆ REX_CAT_CHECK

◆ REX_CAT_FAIL

◆ REX_CAT_FATAL

◆ REX_CHECK

◆ REX_FAIL

◆ REX_FATAL

◆ REXAPU_CHECK

◆ REXAPU_CRITICAL

◆ REXAPU_DEBUG

◆ REXAPU_DEV

◆ REXAPU_ERROR

◆ REXAPU_FAIL

◆ REXAPU_FATAL

◆ REXAPU_INFO

◆ REXAPU_TRACE

◆ REXAPU_WARN

◆ REXAPU_WARN_ONCE

◆ REXCON_CHECK

◆ REXCON_CRITICAL

◆ REXCON_DEBUG

◆ REXCON_DEV

◆ REXCON_ERROR

◆ REXCON_FAIL

◆ REXCON_FATAL

◆ REXCON_INFO

◆ REXCON_TRACE

◆ REXCON_WARN

◆ REXCON_WARN_ONCE

◆ REXCPU_CHECK

◆ REXCPU_CRITICAL

◆ REXCPU_DEBUG

◆ REXCPU_DEV

◆ REXCPU_ERROR

◆ REXCPU_FAIL

◆ REXCPU_FATAL

◆ REXCPU_INFO

◆ REXCPU_TRACE

◆ REXCPU_WARN

◆ REXCPU_WARN_ONCE

◆ REXFS_CHECK

◆ REXFS_CRITICAL

◆ REXFS_DEBUG

◆ REXFS_DEV

◆ REXFS_ERROR

◆ REXFS_FAIL

◆ REXFS_FATAL

◆ REXFS_INFO

◆ REXFS_TRACE

◆ REXFS_WARN

◆ REXFS_WARN_ONCE

◆ REXGPU_CHECK

◆ REXGPU_CRITICAL

◆ REXGPU_DEBUG

◆ REXGPU_DEV

◆ REXGPU_ERROR

◆ REXGPU_FAIL

◆ REXGPU_FATAL

◆ REXGPU_INFO

◆ REXGPU_TRACE

◆ REXGPU_WARN

◆ REXGPU_WARN_ONCE

◆ REXHID_CHECK

◆ REXHID_CRITICAL

◆ REXHID_DEBUG

◆ REXHID_DEV

◆ REXHID_ERROR

◆ REXHID_FAIL

◆ REXHID_FATAL

◆ REXHID_INFO

◆ REXHID_TRACE

◆ REXHID_WARN

◆ REXHID_WARN_ONCE