Formatting

The C++ Standard Library introduces std::formatter to define custom formatting rules for specific types. In chesscxx, most types provide their own std::formatter specializations. This allows you to use these types directly with standard formatting functions such as std::format, std::print, and related utilities.

std::formatter Specializations

Specialization	Supported format specifiers
std::formatter<chesscxx::CastlingRights>	{}(default)
std::formatter<chesscxx::CastlingSide>	{}(default)
std::formatter<chesscxx::CheckIndicator>	{}(default), {:v}, {:c}
std::formatter<chesscxx::Color>	{}(default), {:v}, {:c}
std::formatter<chesscxx::DrawReason>	{}(default)
std::formatter<chesscxx::File>	{}(default)
std::formatter<chesscxx::Game>	{}(default), {:pgn}, {:fen}, {:ascii}, {:lists}, {:rep}
std::formatter<chesscxx::GameResult>	{}(default), {:v}, {:c}
std::formatter<chesscxx::MoveError>	{}(default)
std::formatter<chesscxx::ParseError>	{}(default)
std::formatter<chesscxx::PartialSquare>	{}(default)
std::formatter<chesscxx::Piece>	{}(default), {:v}, {:c}
std::formatter<chesscxx::PiecePlacementError>	{}(default)
std::formatter<chesscxx::PiecePlacement>	{}(default), {:fen}, {:ascii}, {:lists}
std::formatter<chesscxx::PieceType>	{}(default), {:v}, {:u}, {:l}
std::formatter<chesscxx::PromotablePieceType>	{}(default), {:v}, {:u}, {:l}
std::formatter<chesscxx::PositionError>	{}(default)
std::formatter<chesscxx::Position>	{}(default), {:fen}, {:ascii}, {:lists}, {:rep}
std::formatter<chesscxx::Rank>	{}(default)
std::formatter<chesscxx::SanCastlingMove>	{}(default)
std::formatter<chesscxx::SanNormalMove>	{}(default)
std::formatter<chesscxx::SanMove>	{}(default)
std::formatter<chesscxx::Square>	{}(default)
std::formatter<chesscxx::UciMove>	{}(default)
std::formatter<std::optional<T>>	{:prefix[underlying_specs]suffix?default_value}

std::formatter<std::optional<T>>

template<typename T>
struct formatter

#include <base_formatter.h>

Formatter for std::optional<T> where T is a chesscxx type that supports formatting.

The format string can optionally include a prefix, suffix, underlying formatting specifications for the contained type, and a default value to display when the optional does not contain a value.

Format string syntax:

prefix[underlying_specs]suffix?default_value

• prefix: Text inserted before the value

• [underlying_specs]: Format specs passed to the formatter of the underlying T

• suffix: Text inserted after the value

• ?default_value: Fallback value if the optional is empty

Template Parameters:

T – A chesscxx type with std::formatter<T> defined.

Examples

#include <chesscxx/piece_type.h>

#include <optional>
#include <print>

auto main() -> int {
  std::optional<chesscxx::PieceType> empty;
  std::optional<chesscxx::PieceType> rook = chesscxx::PieceType::kRook;

  std::println(R"("{}" "{}")", empty, rook);
  std::println(R"("{:?foo}" "{:?foo}")", empty, rook);
  std::println(R"("{:[u]}" "{:[u]}")", empty, rook);
  std::println(R"("{:[l]}" "{:[l]}")", empty, rook);
  std::println(R"("{:[l]?foo}" "{:[l]?foo}")", empty, rook);
  std::println(R"("{:bar[]}" "{:bar[]}")", empty, rook);
  std::println(R"("{:[]baz}" "{:[]baz}")", empty, rook);
  std::println(R"("{:bar[]baz}" "{:bar[]baz}")", empty, rook);
  std::println(R"("{:bar[]baz?foo}" "{:bar[]baz?foo}")", empty, rook);
  std::println(R"("{:bar[u]baz?foo}" "{:bar[u]baz?foo}")", empty, rook);

  std::println("e7xd8{:=[u]}", empty);
  std::println("e7xd8{:=[u]}", rook);
}

Output:

"" "rook"
"foo" "rook"
"" "R"
"" "r"
"foo" "r"
"" "barrook"
"" "rookbaz"
"" "barrookbaz"
"foo" "barrookbaz"
"foo" "barRbaz"
e7xd8
e7xd8=R