formatter_macros.h File Reference

Provides macros for generating std::formatter specializations. More...

#include "formatter.h"
#include "convert_string.h"
#include <format>

Include dependency graph for formatter_macros.h:

Go to the source code of this file.

Macros
#define	DECLARE_FORMATTER(CLASS_NAME)
	Generates std::formatter specializations for narrow and wide characters.

Detailed Description

Provides macros for generating std::formatter specializations.

This file contains macros that generate std::formatter specializations for custom types to work with C++20 std::format. The macros eliminate code duplication by generating the necessary boilerplate code for formatter specializations.

Usage example:

// In your header file after class definition:
DECLARE_FORMATTER(my_namespace::my_class)

Note

This project requires C++20 std::format support. The fmt library fallback has been removed as of issue #219.

Definition in file formatter_macros.h.

Macro Definition Documentation

DECLARE_FORMATTER

#define DECLARE_FORMATTER

(

CLASS_NAME

)

Value:

template <> struct std::formatter<CLASS_NAME> : std::formatter<std::string_view>                   \
{                                                                                                  \
    template <typename FormatContext>                                                              \
    auto format(const CLASS_NAME& item, FormatContext& ctx) const                                  \
    {                                                                                              \
        return std::formatter<std::string_view>::format(item.to_string(), ctx);                    \
    }                                                                                              \
};                                                                                                 \
                                                                                                   \
template <>                                                                                        \
struct std::formatter<CLASS_NAME, wchar_t> : std::formatter<std::wstring_view, wchar_t>            \
{                                                                                                  \
    template <typename FormatContext>                                                              \
    auto format(const CLASS_NAME& item, FormatContext& ctx) const                                  \
    {                                                                                              \
        auto str = item.to_string();                                                               \
        auto wstr = utility_module::convert_string::to_wstring(str);                               \
        return std::formatter<std::wstring_view, wchar_t>::format(wstr, ctx);                      \
    }                                                                                              \
};

Generates std::formatter specializations for narrow and wide characters.

This macro creates two formatter specializations:

1. std::formatter<CLASS_NAME> for narrow character formatting
2. std::formatter<CLASS_NAME, wchar_t> for wide character formatting

Requirements:

• The class must have a to_string() method that returns std::string
• The convert_string::to_wstring function must be available

Parameters

CLASS_NAME

The fully qualified class name (including namespace if any)

Definition at line 43 of file formatter_macros.h.

#define DECLARE_FORMATTER(CLASS_NAME)                                                              \
template <> struct std::formatter<CLASS_NAME> : std::formatter<std::string_view>                   \
{                                                                                                  \
    template <typename FormatContext>                                                              \
    auto format(const CLASS_NAME& item, FormatContext& ctx) const                                  \
    {                                                                                              \
        return std::formatter<std::string_view>::format(item.to_string(), ctx);                    \
    }                                                                                              \
};                                                                                                 \
                                                                                                   \
template <>                                                                                        \
struct std::formatter<CLASS_NAME, wchar_t> : std::formatter<std::wstring_view, wchar_t>            \
{                                                                                                  \
    template <typename FormatContext>                                                              \
    auto format(const CLASS_NAME& item, FormatContext& ctx) const                                  \
    {                                                                                              \
        auto str = item.to_string();                                                               \
        auto wstr = utility_module::convert_string::to_wstring(str);                               \
        return std::formatter<std::wstring_view, wchar_t>::format(wstr, ctx);                      \
    }                                                                                              \
};