fmt
Loading...
Searching...
No Matches
fmt Module Reference

Classes

class  fmt::BasicStringView< Char >
class  fmt::BasicAppender< T >
class  fmt::GenericContext< OutputIt, Char >
class  fmt::ParseContext< Char >
struct  fmt::IsContiguous< T >
class  fmt::BasicFormatArg< Context >
class  fmt::BasicFormatArgs< Context >
struct  fmt::Formatter< T, Char, Enable >
struct  fmt::Locking< T, Enable >
class  fmt::BasicSpecs
struct  fmt::FormatSpecs
class  fmt::LocaleRef
struct  fmt::detail::IsCodeUnit< T >
struct  fmt::detail::IsCodeUnit< char >
struct  fmt::detail::IsCodeUnit< wchar_t >
struct  fmt::detail::IsCodeUnit< char16_t >
struct  fmt::detail::IsCodeUnit< char32_t >
struct  fmt::detail::HasToStringView< T, Enable >
struct  fmt::detail::HasToStringView< T, void_t< decltype(detail::toStringView(std::declval< T >()))> >
struct  fmt::detail::TypeConstant< T, Char >
struct  fmt::detail::View
struct  fmt::detail::IsView< T, Enable >
struct  fmt::detail::IsView< T, bool_constant< sizeof(T) !=0 > >
struct  fmt::detail::NamedArg< T, Char >
struct  fmt::detail::IsNamedArg< T >
struct  fmt::detail::IsStaticNamedArg< T >
struct  fmt::detail::IsNamedArg< NamedArg< T, Char > >
struct  fmt::detail::NamedArgInfo< Char >
struct  fmt::detail::UseFormatAs< T, Enable >
struct  fmt::detail::UseFormatAsMember< T, Enable >
struct  fmt::detail::UseFormatAs< T, bool_constant< std::is_arithmetic< FormatAsResult< T > >::value > >
struct  fmt::detail::UseFormatAsMember< T, bool_constant< std::is_arithmetic< FormatAsMemberResult< T > >::value > >
struct  fmt::detail::TypeMapper< Char >
class  fmt::detail::CompileParseContext< Char >
union  fmt::detail::arg_ref< Char >
struct  fmt::detail::DynamicFormatSpecs< Char >
struct  fmt::detail::DynamicSpecHandler< Char >
struct  fmt::detail::ParseDynamicSpecResult< Char >
struct  fmt::detail::CompileString
struct  fmt::detail::ArgPack< T >
class  fmt::detail::FormatStringChecker< Char, NUM_ARGS, NUM_NAMED_ARGS, DYNAMIC_NAMES >
class  fmt::detail::Buffer< T >
struct  fmt::detail::BufferTraits
class  fmt::detail::FixedBufferTraits
struct  fmt::detail::HasAppend< OutputIt, InputIt, typename >
struct  fmt::detail::HasAppend< OutputIt, InputIt, void_t< decltype(getContainer(std::declval< OutputIt >()) .append(std::declval< InputIt >(), std::declval< InputIt >()))> >
struct  fmt::detail::HasInsert< OutputIt, T, typename >
struct  fmt::detail::HasInsert< OutputIt, T, void_t< decltype(getContainer(std::declval< OutputIt >()) .insert({}, std::declval< T >(), std::declval< T >()))> >
class  fmt::detail::IteratorBuffer< OutputIt, T, Traits >
class  fmt::detail::IteratorBuffer< T *, T, FixedBufferTraits >
class  fmt::detail::IteratorBuffer< T *, T >
class  fmt::detail::ContainerBuffer< Container >
class  fmt::detail::IteratorBuffer< OutputIt, enable_if_t< IsBackInsertIterator< OutputIt >::value &&IsContiguous< typename OutputIt::container_type >::value, typename OutputIt::container_type::value_type > >
class  fmt::detail::CountingBuffer< T >
struct  fmt::detail::IsBackInsertIterator< BasicAppender< T > >
struct  fmt::detail::IsBufferAppender< It, Enable >
struct  fmt::detail::IsBufferAppender< It, bool_constant< IsBackInsertIterator< It >::value &&std::is_base_of< Buffer< typename It::container_type::value_type >, typename It::container_type >::value > >
struct  fmt::detail::TypeIsUnformattableFor< T, Char >
struct  fmt::detail::StringValue< Char >
struct  fmt::detail::CustomValue< Context >
struct  fmt::detail::NamedArgValue< Char >
struct  fmt::detail::CustomTag
class  fmt::detail::Value< Context >
struct  fmt::detail::IsOutputIterator< It, T, Enable >
struct  fmt::detail::IsOutputIterator< Appender, char >
struct  fmt::detail::IsOutputIterator< It, T, enable_if_t< std::is_assignable< decltype(*std::declval< decay_t< It > & >()++), T >::value > >
struct  fmt::detail::NamedArgStore< Context, NUM_ARGS, NUM_NAMED_ARGS, DESC >
struct  fmt::detail::FormatArgStore< Context, NUM_ARGS, NUM_NAMED_ARGS, DESC >
struct  fmt::detail::NativeFormatter< T, Char, TYPE >
class  fmt::Context
struct  fmt::RuntimeFormatString< Char >
struct  fmt::Fstring< T >
struct  fmt::Formatter< T, Char, enable_if_t< detail::TypeConstant< T, Char >::value !=detail::Type::kCustomType > >
struct  fmt::FormatToNResult< OutputIt >
struct  fmt::FormatToResult
struct  fmt::detail::NullChronoSpecHandler< Derived >
class  fmt::detail::TmFormatChecker
struct  fmt::detail::HasTmGmtoff< T, typename >
struct  fmt::detail::HasTmGmtoff< T, void_t< decltype(T::tm_gmtoff)> >
struct  fmt::detail::HasTmZone< T, typename >
struct  fmt::detail::HasTmZone< T, void_t< decltype(T::tm_zone)> >
struct  fmt::detail::CountFractionalDigits< Num, Den, N, Enabled >
struct  fmt::detail::CountFractionalDigits< Num, Den, N, false >
class  fmt::detail::TmWriter< OutputIt, Char, Duration >
struct  fmt::detail::ChronoFormatChecker
struct  fmt::detail::MakeUnsignedOrUnchanged< T, INTEGRAL >
struct  fmt::detail::MakeUnsignedOrUnchanged< T, true >
class  fmt::detail::GetLocale
struct  fmt::detail::DurationFormatter< Char, Rep, Period >
class  fmt::Weekday
class  fmt::Day
class  fmt::Month
class  fmt::Year
class  fmt::YearMonthDay
struct  fmt::Formatter< Weekday, Char >
struct  fmt::Formatter< Day, Char >
struct  fmt::Formatter< Month, Char >
struct  fmt::Formatter< Year, Char >
struct  fmt::Formatter< YearMonthDay, Char >
struct  fmt::Formatter< std::chrono::duration< Rep, Period >, Char >
struct  fmt::Formatter< std::tm, Char >
struct  fmt::Formatter< SysTime< Duration >, Char >
struct  fmt::Formatter< UtcTime< Duration >, Char >
struct  fmt::Formatter< LocalTime< Duration >, Char >
struct  fmt::Rgb
struct  fmt::detail::ColorType
class  fmt::TextStyle
struct  fmt::detail::AnsiColorEscape< Char >
struct  fmt::detail::StyledArg< T >
struct  fmt::Formatter< detail::StyledArg< T >, Char >
class  fmt::CompiledString
struct  fmt::IsCompiledString< S >
struct  fmt::CompiledFormatString< Str >
class  fmt::StaticFormatResult< N >
class  fmt::BasicMemoryBuffer< T, SIZE, Allocator >
class  fmt::Writer
class  fmt::StringBuffer
struct  fmt::IsContiguous< BasicMemoryBuffer< T, SIZE, Allocator > >
class  fmt::FormatError
class  fmt::LocValue
class  fmt::FormatFacet< Locale >
struct  fmt::Formatter< Char[N], Char >
class  fmt::Formatter< std::basic_string< Char, Traits, Allocator >, Char >
struct  fmt::Formatter< detail::Float128, Char >
struct  fmt::Formatter< T, Char, void_t< detail::FormatAsResult< T > > >
struct  fmt::Bytes
struct  fmt::Formatter< Bytes >
struct  fmt::GroupDigitsView< T >
struct  fmt::Formatter< GroupDigitsView< T > >
struct  fmt::NestedView< T, Char >
struct  fmt::Formatter< NestedView< T, Char >, Char >
struct  fmt::NestedFormatter< T, Char >
class  fmt::FormatInt
class  fmt::BasicPrintfContext< Char >
struct  fmt::detail::IntChecker< IS_SIGNED >
struct  fmt::detail::IntChecker< true >
struct  fmt::detail::PrintfPrecisionHandler
struct  fmt::detail::IsZeroInt
struct  fmt::detail::MakeUnsignedOrBool< T >
struct  fmt::detail::MakeUnsignedOrBool< bool >
class  fmt::detail::ArgConverter< T, Context >
class  fmt::detail::CharConverter< Context >
struct  fmt::detail::GetCstring< Char >
class  fmt::detail::PrintfWidthHandler
class  fmt::detail::PrintfArgFormatter< Char >
struct  fmt::VprintfArgs< Char >
class  fmt::DynamicFormatArgStore< Context >
struct  fmt::BasicFstring< Char, T >
struct  fmt::IsTupleLike< T >
struct  fmt::IsTupleFormattable< T, C >
struct  fmt::IsRange< T, Char >
struct  fmt::RangeFormatter< T, Char, Enable >
struct  fmt::RangeFormatKind< T, Char, Enable >
struct  fmt::TupleJoinView< Tuple, Char >
struct  fmt::IsContainerAdaptor< T >

Enumerations

enum class  fmt::PresentationType : unsigned char {
  kNone = 0 , kDebug = 1 , kString = 2 , kDec = 3 ,
  kHex = 4 , kOct = 5 , kBin = 6 , kChr = 7 ,
  kPointer = 3 , kExp = 1 , kFixed = 2 , kGeneral = 3 ,
  kHexfloat = 4
}
enum class  fmt::Align : int {
  kNone = 0 , kLeft = 1 , kRight = 2 , kCenter = 3 ,
  kNumeric = 4
}
enum class  fmt::Sign : int { kNone = 0 , kMinus = 1 , kPlus = 2 , kSpace = 3 }
enum class  fmt::ArgIdKind : int { kNone = 0 , kIndex = 1 , kName = 2 }
enum class  Type : int {
  kNoneType = 0 , kIntType = 1 , kUintType = 2 , kLongLongType = 3 ,
  kUlongLongType = 4 , kInt128Type = 5 , kUint128Type = 6 , kBoolType = 7 ,
  kCharType = 8 , kLastIntegerType = kCharType , kFloatType = 9 , kDoubleType = 10 ,
  kLongDoubleType = 11 , kLastNumericType = kLongDoubleType , kCstringType = 12 , kStringType = 13 ,
  kPointerType = 14 , kCustomType = 15
}
enum class  State : int {
  kStart = 0 , kAlign = 1 , kSign = 2 , kHash = 3 ,
  kZero = 4 , kWidth = 5 , kPrecision = 6 , kLocale = 7
}
enum class  NumericSystem : int { kStandard = 0 , kAlternative = 1 }
enum class  PadType : int { kZero = 0 , kNone = 1 , kSpace = 2 }
enum class  fmt::Color : uint32_t {
  kAliceBlue = 0xF0'F8FF , kAntiqueWhite = 0xFA'EBD7 , kAqua = 0x00'FFFF , kAquamarine = 0x7F'FFD4 ,
  kAzure = 0xF0'FFFF , kBeige = 0xF5'F5DC , kBisque = 0xFF'E4C4 , kBlack = 0x00'0000 ,
  kBlanchedAlmond = 0xFF'EBCD , kBlue = 0x00'00FF , kBlueViolet = 0x8A'2BE2 , kBrown = 0xA5'2A2A ,
  kBurlyWood = 0xDE'B887 , kCadetBlue = 0x5F'9EA0 , kChartreuse = 0x7F'FF00 , kChocolate = 0xD2'691E ,
  kCoral = 0xFF'7F50 , kCornflowerBlue = 0x64'95ED , kCornsilk = 0xFF'F8DC , kCrimson = 0xDC'143C ,
  kCyan = 0x00'FFFF , kDarkBlue = 0x00'008B , kDarkCyan = 0x00'8B8B , kDarkGoldenRod = 0xB8'860B ,
  kDarkGray = 0xA9'A9A9 , kDarkGreen = 0x00'6400 , kDarkKhaki = 0xBD'B76B , kDarkMagenta = 0x8B'008B ,
  kDarkOliveGreen = 0x55'6B2F , kDarkOrange = 0xFF'8C00 , kDarkOrchid = 0x99'32CC , kDarkRed = 0x8B'0000 ,
  kDarkSalmon = 0xE9'967A , kDarkSeaGreen = 0x8F'BC8F , kDarkSlateBlue = 0x48'3D8B , kDarkSlateGray = 0x2F'4F4F ,
  kDarkTurquoise = 0x00'CED1 , kDarkViolet = 0x94'00D3 , kDeepPink = 0xFF'1493 , kDeepSkyBlue = 0x00'BFFF ,
  kDimGray = 0x69'6969 , kDodgerBlue = 0x1E'90FF , kFireBrick = 0xB2'2222 , kFloralWhite = 0xFF'FAF0 ,
  kForestGreen = 0x22'8B22 , kFuchsia = 0xFF'00FF , kGainsboro = 0xDC'DCDC , kGhostWhite = 0xF8'F8FF ,
  kGold = 0xFF'D700 , kGoldenRod = 0xDA'A520 , kGray = 0x80'8080 , kGreen = 0x00'8000 ,
  kGreenYellow = 0xAD'FF2F , kHoneyDew = 0xF0'FFF0 , kHotPink = 0xFF'69B4 , kIndianRed = 0xCD'5C5C ,
  kIndigo = 0x4B'0082 , kIvory = 0xFF'FFF0 , kKhaki = 0xF0'E68C , kLavender = 0xE6'E6FA ,
  kLavenderBlush = 0xFF'F0F5 , kLawnGreen = 0x7C'FC00 , kLemonChiffon = 0xFF'FACD , kLightBlue = 0xAD'D8E6 ,
  kLightCoral = 0xF0'8080 , kLightCyan = 0xE0'FFFF , kLightGoldenRodYellow = 0xFA'FAD2 , kLightGray = 0xD3'D3D3 ,
  kLightGreen = 0x90'EE90 , kLightPink = 0xFF'B6C1 , kLightSalmon = 0xFF'A07A , kLightSeaGreen = 0x20'B2AA ,
  kLightSkyBlue = 0x87'CEFA , kLightSlateGray = 0x77'8899 , kLightSteelBlue = 0xB0'C4DE , kLightYellow = 0xFF'FFE0 ,
  kLime = 0x00'FF00 , kLimeGreen = 0x32'CD32 , kLinen = 0xFA'F0E6 , kMagenta = 0xFF'00FF ,
  kMaroon = 0x80'0000 , kMediumAquamarine = 0x66'CDAA , kMediumBlue = 0x00'00CD , kMediumOrchid = 0xBA'55D3 ,
  kMediumPurple = 0x93'70DB , kMediumSeaGreen = 0x3C'B371 , kMediumSlateBlue = 0x7B'68EE , kMediumSpringGreen = 0x00'FA9A ,
  kMediumTurquoise = 0x48'D1CC , kMediumVioletRed = 0xC7'1585 , kMidnightBlue = 0x19'1970 , kMintCream = 0xF5'FFFA ,
  kMistyRose = 0xFF'E4E1 , kMoccasin = 0xFF'E4B5 , kNavajoWhite = 0xFF'DEAD , kNavy = 0x00'0080 ,
  kOldLace = 0xFD'F5E6 , kOlive = 0x80'8000 , kOliveDrab = 0x6B'8E23 , kOrange = 0xFF'A500 ,
  kOrangeRed = 0xFF'4500 , kOrchid = 0xDA'70D6 , kPaleGoldenRod = 0xEE'E8AA , kPaleGreen = 0x98'FB98 ,
  kPaleTurquoise = 0xAF'EEEE , kPaleVioletRed = 0xDB'7093 , kPapayaWhip = 0xFF'EFD5 , kPeachPuff = 0xFF'DAB9 ,
  kPeru = 0xCD'853F , kPink = 0xFF'C0CB , kPlum = 0xDD'A0DD , kPowderBlue = 0xB0'E0E6 ,
  kPurple = 0x80'0080 , kRebeccaPurple = 0x66'3399 , kRed = 0xFF'0000 , kRosyBrown = 0xBC'8F8F ,
  kRoyalBlue = 0x41'69E1 , kSaddleBrown = 0x8B'4513 , kSalmon = 0xFA'8072 , kSandyBrown = 0xF4'A460 ,
  kSeaGreen = 0x2E'8B57 , kSeaShell = 0xFF'F5EE , kSienna = 0xA0'522D , kSilver = 0xC0'C0C0 ,
  kSkyBlue = 0x87'CEEB , kSlateBlue = 0x6A'5ACD , kSlateGray = 0x70'8090 , kSnow = 0xFF'FAFA ,
  kSpringGreen = 0x00'FF7F , kSteelBlue = 0x46'82B4 , kTan = 0xD2'B48C , kTeal = 0x00'8080 ,
  kThistle = 0xD8'BFD8 , kTomato = 0xFF'6347 , kTurquoise = 0x40'E0D0 , kViolet = 0xEE'82EE ,
  kWheat = 0xF5'DEB3 , kWhite = 0xFF'FFFF , kWhiteSmoke = 0xF5'F5F5 , kYellow = 0xFF'FF00 ,
  kYellowGreen = 0x9A'CD32
}
enum class  fmt::TerminalColor : uint8_t {
  kBlack = 30 , kRed = 31 , kGreen = 32 , kYellow = 33 ,
  kBlue = 34 , kMagenta = 35 , kCyan = 36 , kWhite = 37 ,
  kBrightBlack = 90 , kBrightRed = 91 , kBrightGreen = 92 , kBrightYellow = 93 ,
  kBrightBlue = 94 , kBrightMagenta = 95 , kBrightCyan = 96 , kBrightWhite = 97
}
enum class  fmt::Emphasis : uint8_t {
  kBold = 1 , kFaint = 1 << 1 , kItalic = 1 << 2 , kUnderline = 1 << 3 ,
  kBlink = 1 << 4 , kReverse = 1 << 5 , kConceal = 1 << 6 , kStrikethrough = 1 << 7
}
enum class  fmt::RangeFormat : int {
  disabled = 0 , map = 1 , set = 2 , sequence = 3 ,
  string = 4 , debug_string = 5
}

Typedefs

using fmt::StringView = BasicStringView<char>
using fmt::Appender = BasicAppender<char>
template<typename Char>
using fmt::BasicFormatParseContext = ParseContext<Char>
using fmt::FormatParseContext = ParseContext<char>
template<typename OutputIt, typename Char>
using fmt::BasicFormatContext
using fmt::FormatContext = Context
template<typename Char>
using fmt::BufferedContext
using fmt::FormatArgs = BasicFormatArgs<Context>
template<typename S, typename V = decltype(detail::toStringView(std::declval<S>()))>
using fmt::detail::char_t = typename V::value_type
using fmt::detail::LongType = conditional_t<kLongShort, int, long long>
using fmt::detail::UlongType = conditional_t<kLongShort, unsigned, Ullong>
template<typename T>
using fmt::detail::FormatAsResult
template<typename T>
using fmt::detail::FormatAsMemberResult
template<typename T, typename U = remove_const_t<T>>
using fmt::detail::UseFormatter
template<typename T, typename Char>
using fmt::detail::mapped_t
template<typename T, typename Char = char>
using fmt::detail::MappedTypeConstant = TypeConstant<mapped_t<T, Char>, Char>
template<typename T, typename Context, Type TYPE = MappedTypeConstant<T, typename Context::char_type>::value>
using fmt::detail::StoredTypeConstant
template<typename Context, int NUM_ARGS>
using fmt::detail::arg_t
template<typename... T>
using fmt::FormatString = typename Fstring<T...>::t
template<typename T, typename Char = char>
using fmt::IsFormattable
template<typename... T>
using fmt::Vargs
using fmt::MemoryBuffer = BasicMemoryBuffer<char>
using fmt::PrintfContext = BasicPrintfContext<char>
using fmt::WprintfContext = BasicPrintfContext<wchar_t>
using fmt::PrintfArgs = BasicFormatArgs<PrintfContext>
using fmt::WprintfArgs = BasicFormatArgs<WprintfContext>
using fmt::WstringView = BasicStringView<wchar_t>
using fmt::WformatParseContext = ParseContext<wchar_t>
using fmt::WformatContext = BufferedContext<wchar_t>
using fmt::WformatArgs = BasicFormatArgs<WformatContext>
using fmt::WmemoryBuffer = BasicMemoryBuffer<wchar_t>
template<typename Char, typename... T>
using fmt::BasicFormatString = BasicFstring<Char, T...>
template<typename... T>
using fmt::WformatString = typename BasicFormatString<wchar_t, T...>::t

Functions

void fmt::reportError (const char *message)
template<typename Char>
requires (IsCodeUnit<Char>::value)
constexpr auto fmt::detail::toStringView (const Char *s) -> BasicStringView< Char >
template<typename T>
requires (IsStdStringLike<T>::value)
constexpr auto fmt::detail::toStringView (const T &s) -> BasicStringView< typename T::value_type >
template<typename Char>
constexpr auto fmt::detail::toStringView (BasicStringView< Char > s) -> BasicStringView< Char >
template<typename T, typename Char>
constexpr auto fmt::detail::typeOf () -> Type
constexpr auto fmt::detail::isIntegralType (Type t) -> bool
constexpr auto fmt::detail::isArithmeticType (Type t) -> bool
constexpr auto fmt::detail::set (Type rhs) -> int
constexpr auto fmt::detail::in (Type t, int set) -> bool
template<bool B = false>
constexpr auto fmt::detail::count () -> int
template<bool B1, bool B2, bool... Tail>
constexpr auto fmt::detail::count () -> int
template<typename... T>
constexpr auto fmt::detail::countNamedArgs () -> int
template<typename... T>
constexpr auto fmt::detail::countStaticNamedArgs () -> int
template<typename Char>
constexpr auto fmt::detail::checkForDuplicate (NamedArgInfo< Char > *named_args, int named_arg_index, BasicStringView< Char > arg_name) -> void
template<typename Char, typename T>
requires (!IsNamedArg<T>::value)
auto fmt::detail::initNamedArg (NamedArgInfo< Char > *, int &arg_index, int &, const T &) -> void
template<typename Char, typename T>
requires (IsNamedArg<T>::value)
auto fmt::detail::initNamedArg (NamedArgInfo< Char > *named_args, int &arg_index, int &named_arg_index, const T &arg) -> void
template<typename T, typename Char>
requires (!IsStaticNamedArg<T>::value)
constexpr auto fmt::detail::initStaticNamedArg (NamedArgInfo< Char > *, int &arg_index, int &) -> void
template<typename T, typename Char>
requires (IsStaticNamedArg<T>::value)
constexpr auto fmt::detail::initStaticNamedArg (NamedArgInfo< Char > *named_args, int &arg_index, int &named_arg_index) -> void
template<typename Char, typename T, typename U = remove_const_t<T>>
auto fmt::detail::hasFormatterImpl (T *p, BufferedContext< Char > *ctx=nullptr) -> decltype(Formatter< U, Char >().format(*p, *ctx), std::true_type())
template<typename Char>
auto fmt::detail::hasFormatterImpl (...) -> std::false_type
template<typename T, typename Char>
constexpr auto fmt::detail::hasFormatter () -> bool
template<typename Char>
requires (std::is_integral<Char>::value)
constexpr auto fmt::detail::toAscii (Char c) -> char
template<typename Char>
constexpr auto fmt::detail::codePointLength (const Char *begin) -> int
template<typename Char>
constexpr auto fmt::detail::parseNonnegativeInt (const Char *&begin, const Char *end, int error_value) noexcept -> int
constexpr auto fmt::detail::parseAlign (char c) -> Align
template<typename Char>
constexpr auto fmt::detail::isNameStart (Char c) -> bool
template<typename Char, typename Handler>
constexpr auto fmt::detail::parseArgId (const Char *begin, const Char *end, Handler &&handler) -> const Char *
template<typename Char>
constexpr auto fmt::detail::parseDynamicSpec (const Char *begin, const Char *end, int &value, arg_ref< Char > &ref, ParseContext< Char > &ctx) -> ParseDynamicSpecResult< Char >
template<typename Char>
constexpr auto fmt::detail::parseWidth (const Char *begin, const Char *end, FormatSpecs &specs, arg_ref< Char > &width_ref, ParseContext< Char > &ctx) -> const Char *
template<typename Char>
constexpr auto fmt::detail::parsePrecision (const Char *begin, const Char *end, FormatSpecs &specs, arg_ref< Char > &precision_ref, ParseContext< Char > &ctx) -> const Char *
template<typename Char>
constexpr auto fmt::detail::parseFormatSpecs (const Char *begin, const Char *end, DynamicFormatSpecs< Char > &specs, ParseContext< Char > &ctx, Type arg_type) -> const Char *
template<typename Char, typename Handler>
constexpr auto fmt::detail::parseReplacementField (const Char *begin, const Char *end, Handler &&handler) -> const Char *
template<typename Char, typename Handler>
constexpr auto fmt::detail::parseFormatString (BasicStringView< Char > fmt, Handler &&handler) -> void
constexpr auto fmt::detail::checkCharSpecs (const FormatSpecs &specs) -> bool
template<typename T, typename Char>
constexpr auto fmt::detail::invokeParse (ParseContext< Char > &ctx) -> const Char *
template<typename T, typename InputIt, typename OutputIt>
requires (IsBackInsertIterator<OutputIt>::value && HasAppend<OutputIt, InputIt>::value)
constexpr auto fmt::detail::copy (InputIt begin, InputIt end, OutputIt out) -> OutputIt
template<typename T, typename InputIt, typename OutputIt>
requires (IsBackInsertIterator<OutputIt>::value && !HasAppend<OutputIt, InputIt>::value && HasInsert<OutputIt, InputIt>::value)
constexpr auto fmt::detail::copy (InputIt begin, InputIt end, OutputIt out) -> OutputIt
template<typename T, typename InputIt, typename OutputIt>
requires (!IsBackInsertIterator<OutputIt>::value || !(HasAppend<OutputIt, InputIt>::value || HasInsert<OutputIt, InputIt>::value))
constexpr auto fmt::detail::copy (InputIt begin, InputIt end, OutputIt out) -> OutputIt
template<typename T, typename OutputIt>
requires (!IsBufferAppender<OutputIt>::value)
auto fmt::detail::getBuffer (OutputIt out) -> IteratorBuffer< OutputIt, T >
template<typename T, typename OutputIt>
requires (IsBufferAppender<OutputIt>::value)
auto fmt::detail::getBuffer (OutputIt out) -> Buffer< T > &
template<typename Buf, typename OutputIt>
auto fmt::detail::getIterator (Buf &buf, OutputIt) -> decltype(buf.out())
template<typename T, typename OutputIt>
auto fmt::detail::getIterator (Buffer< T > &, OutputIt out) -> OutputIt
template<typename>
constexpr auto fmt::detail::encodeTypes () -> Ullong
template<typename Context, typename First, typename... T>
constexpr auto fmt::detail::encodeTypes () -> Ullong
template<typename Context, typename... T, size_t NUM_ARGS = sizeof...(T)>
constexpr auto fmt::detail::makeDescriptor () -> Ullong
template<bool B>
constexpr auto fmt::detail::enforceCompileChecks () -> bool
template<typename T = int>
constexpr auto fmt::detail::isLocking () -> bool
template<typename T1, typename T2, typename... Tail>
constexpr auto fmt::detail::isLocking () -> bool
auto fmt::detail::vformatTo (Buffer< char > &buf, StringView fmt, FormatArgs args, LocaleRef loc={}) -> void
auto fmt::detail::vprintMojibake (FILE *, StringView, const FormatArgs &, bool) -> void
auto fmt::runtime (StringView s) -> RuntimeFormatString<>
template<typename Context = Context, typename... T, int NUM_ARGS = int(sizeof...(T)), int NUM_NAMED_ARGS = detail::countNamedArgs<T...>(), Ullong DESC = detail::makeDescriptor<Context, T...>()>
constexpr auto fmt::makeFormatArgs (T &... args) -> detail::FormatArgStore< Context, NUM_ARGS, NUM_NAMED_ARGS, DESC >
template<typename T>
auto fmt::arg (const char *name, const T &arg) -> NamedArg< T >
template<typename OutputIt>
requires ( detail::IsOutputIterator<remove_cvref_t<OutputIt>, char>::value)
auto fmt::vformatTo (OutputIt &&out, StringView fmt, FormatArgs args) -> remove_cvref_t< OutputIt >
template<typename OutputIt, typename... T>
requires ( detail::IsOutputIterator<remove_cvref_t<OutputIt>, char>::value)
auto fmt::formatTo (OutputIt &&out, FormatString< T... > fmt, T &&... args) -> remove_cvref_t< OutputIt >
template<typename OutputIt, typename... T>
requires (detail::IsOutputIterator<OutputIt, char>::value)
auto fmt::vformatToN (OutputIt out, size_t n, StringView fmt, FormatArgs args) -> FormatToNResult< OutputIt >
template<typename OutputIt, typename... T>
requires (detail::IsOutputIterator<OutputIt, char>::value)
auto fmt::formatToN (OutputIt out, size_t n, FormatString< T... > fmt, T &&... args) -> FormatToNResult< OutputIt >
template<size_t N>
auto fmt::vformatTo (char(&out)[N], StringView fmt, FormatArgs args) -> FormatToResult
template<size_t N, typename... T>
auto fmt::formatTo (char(&out)[N], FormatString< T... > fmt, T &&... args) -> FormatToResult
template<typename... T>
auto fmt::formattedSize (FormatString< T... > fmt, T &&... args) -> size_t
auto fmt::vprint (StringView fmt, FormatArgs args) -> void
auto fmt::vprint (FILE *f, StringView fmt, FormatArgs args) -> void
auto fmt::vprintln (FILE *f, StringView fmt, FormatArgs args) -> void
auto fmt::vprintBuffered (FILE *f, StringView fmt, FormatArgs args) -> void
template<typename... T>
auto fmt::print (FormatString< T... > fmt, T &&... args) -> void
template<typename... T>
auto fmt::print (FILE *f, FormatString< T... > fmt, T &&... args) -> void
template<typename... T>
auto fmt::println (FILE *f, FormatString< T... > fmt, T &&... args) -> void
template<typename... T>
auto fmt::println (FormatString< T... > fmt, T &&... args) -> void
auto fmt::gmtime (std::time_t time) -> std::tm
template<typename Duration>
auto fmt::gmtime (SysTime< Duration > time_point) -> std::tm
auto fmt::detail::writeDigit2Separated (char *buf, unsigned a, unsigned b, unsigned c, char sep) -> void
template<typename Period>
constexpr auto fmt::detail::getUnits () -> const char *
template<typename OutputIt>
auto fmt::detail::writePadding (OutputIt out, PadType pad, int width) -> OutputIt
template<typename OutputIt>
auto fmt::detail::writePadding (OutputIt out, PadType pad) -> OutputIt
template<typename Char, typename Handler>
constexpr auto fmt::detail::parseChronoFormat (const Char *begin, const Char *end, Handler &&handler) -> const Char *
auto fmt::detail::tmWdayFullName (int wday) -> const char *
auto fmt::detail::tmWdayShortName (int wday) -> const char *
auto fmt::detail::tmMonFullName (int mon) -> const char *
auto fmt::detail::tmMonShortName (int mon) -> const char *
template<typename T>
requires (HasTmZone<T>::value)
auto fmt::detail::setTmZone (T &time, char *tz) -> bool
template<typename T>
requires (!HasTmZone<T>::value)
auto fmt::detail::setTmZone (T &, char *) -> bool
auto fmt::detail::utc () -> char *
template<typename T, typename Int>
requires (std::is_integral<T>::value)
auto fmt::detail::toNonnegativeInt (T value, Int upper) -> Int
template<typename T, typename Int>
requires (!std::is_integral<T>::value)
auto fmt::detail::toNonnegativeInt (T value, Int upper) -> Int
constexpr auto fmt::detail::pow10 (std::uint32_t n) -> long long
template<typename Char, typename OutputIt, typename Duration>
auto fmt::detail::writeFractionalSeconds (OutputIt &out, Duration d, int precision=-1) -> void
template<typename Duration>
auto fmt::detail::writeFloatingSeconds (MemoryBuffer &buf, Duration duration, int num_fractional_digits=-1) -> void
template<typename T>
requires (std::is_integral<T>::value && HasIsfinite<T>::value)
auto fmt::detail::isfinite (T) -> bool
template<typename T>
requires (std::is_integral<T>::value)
auto fmt::detail::mod (T x, int y) -> T
template<typename T>
requires (std::is_floating_point<T>::value)
auto fmt::detail::mod (T x, int y) -> T
template<typename Rep, typename Period>
requires (std::is_integral<Rep>::value)
auto fmt::detail::getMilliseconds (std::chrono::duration< Rep, Period > d) -> std::chrono::duration< Rep, std::milli >
template<typename Char, typename Rep, typename OutputIt>
requires (std::is_integral<Rep>::value)
auto fmt::detail::formatDurationValue (OutputIt out, Rep val, int) -> OutputIt
template<typename Char, typename Rep, typename OutputIt>
requires (std::is_floating_point<Rep>::value)
auto fmt::detail::formatDurationValue (OutputIt out, Rep val, int precision) -> OutputIt
template<typename Char, typename OutputIt>
auto fmt::detail::copyUnit (StringView unit, OutputIt out, Char) -> OutputIt
template<typename OutputIt>
auto fmt::detail::copyUnit (StringView unit, OutputIt out, wchar_t) -> OutputIt
template<typename Char, typename Period, typename OutputIt>
auto fmt::detail::formatDurationUnit (OutputIt out) -> OutputIt
constexpr auto fmt::fg (detail::ColorType foreground) -> TextStyle
constexpr auto fmt::bg (detail::ColorType background) -> TextStyle
constexpr auto fmt::operator| (Emphasis lhs, Emphasis rhs) noexcept -> TextStyle
template<typename Char>
constexpr auto fmt::detail::makeForegroundColor (ColorType foreground) noexcept -> AnsiColorEscape< Char >
template<typename Char>
constexpr auto fmt::detail::makeBackgroundColor (ColorType background) noexcept -> AnsiColorEscape< Char >
template<typename Char>
constexpr auto fmt::detail::makeEmphasis (Emphasis em) noexcept -> AnsiColorEscape< Char >
template<typename Char>
auto fmt::detail::resetColor (Buffer< Char > &buffer) -> void
template<typename Char>
auto fmt::detail::vformatTo (Buffer< Char > &buf, TextStyle ts, BasicStringView< Char > fmt, BasicFormatArgs< BufferedContext< Char > > args) -> void
auto fmt::vprint (FILE *f, TextStyle ts, StringView fmt, FormatArgs args) -> void
template<typename... T>
auto fmt::print (FILE *f, TextStyle ts, FormatString< T... > fmt, T &&... args) -> void
template<typename... T>
auto fmt::print (TextStyle ts, FormatString< T... > fmt, T &&... args) -> void
auto fmt::vprintln (FILE *f, TextStyle ts, StringView fmt, FormatArgs args) -> void
template<typename... T>
auto fmt::println (FILE *f, TextStyle ts, FormatString< T... > fmt, T &&... args) -> void
template<typename... T>
auto fmt::println (TextStyle ts, FormatString< T... > fmt, T &&... args) -> void
auto fmt::vformat (TextStyle ts, StringView fmt, FormatArgs args) -> std::string
template<typename... T>
auto fmt::format (TextStyle ts, FormatString< T... > fmt, T &&... args) -> std::string
template<typename OutputIt>
requires (detail::IsOutputIterator<OutputIt, char>::value)
auto fmt::vformatTo (OutputIt out, TextStyle ts, StringView fmt, FormatArgs args) -> OutputIt
template<typename OutputIt, typename... T>
requires (detail::IsOutputIterator<OutputIt, char>::value)
auto fmt::formatTo (OutputIt out, TextStyle ts, FormatString< T... > fmt, T &&... args) -> OutputIt
template<typename T>
constexpr auto fmt::styled (const T &value, TextStyle ts) -> detail::StyledArg< remove_cvref_t< T > >
template<detail::FixedString Str>
constexpr auto fmt::literals::operator""_cf () -> CompiledFormatString< Str >
template<typename T, typename... Tail>
constexpr auto fmt::detail::first (const T &value, const Tail &...) -> const T &
template<typename OutputIt, typename S, typename... T>
requires (IsCompiledString<S>::value)
auto fmt::formatToN (OutputIt out, size_t n, const S &fmt, T &&... args) -> FormatToNResult< OutputIt >
template<typename S, typename... T>
requires (IsCompiledString<S>::value)
constexpr auto fmt::formattedSize (const S &fmt, T &&... args) -> size_t
template<typename S, typename... T>
requires (IsCompiledString<S>::value)
auto fmt::print (std::FILE *f, const S &fmt, T &&... args) -> void
template<typename S, typename... T>
requires (IsCompiledString<S>::value)
auto fmt::print (const S &fmt, T &&... args) -> void
template<detail::FixedString Str, auto... Args>
constexpr auto fmt::staticFormat ()
template<size_t SIZE>
auto fmt::to_string (const BasicMemoryBuffer< char, SIZE > &buf) -> std::string
auto fmt::detail::writeConsole (int fd, StringView text) -> bool
auto fmt::detail::print (FILE *, StringView) -> void
template<typename Char, size_t N>
constexpr auto fmt::detail::compileStringToView (const Char(&s)[N]) -> BasicStringView< Char >
template<typename Char>
constexpr auto fmt::detail::compileStringToView (BasicStringView< Char > s) -> BasicStringView< Char >
template auto fmt::detail::thousandsSepImpl< char > (LocaleRef) -> ThousandsSepResult< char >
template auto fmt::detail::thousandsSepImpl< wchar_t > (LocaleRef) -> ThousandsSepResult< wchar_t >
template auto fmt::detail::decimalPointImpl (LocaleRef) -> char
template<typename Char>
auto fmt::detail::equal2 (const Char *lhs, const char *rhs) -> bool
 fmt::FMT_FORMAT_AS (signed char, int)
 fmt::FMT_FORMAT_AS (unsigned char, unsigned)
 fmt::FMT_FORMAT_AS (short, int)
 fmt::FMT_FORMAT_AS (unsigned short, unsigned)
 fmt::FMT_FORMAT_AS (long, detail::LongType)
 fmt::FMT_FORMAT_AS (unsigned long, detail::UlongType)
 fmt::FMT_FORMAT_AS (Char *, const Char *)
 fmt::FMT_FORMAT_AS (detail::StdStringView< Char >, BasicStringView< Char >)
 fmt::FMT_FORMAT_AS (std::nullptr_t, const void *)
 fmt::FMT_FORMAT_AS (void *, const void *)
template<typename T>
auto fmt::ptr (T p) -> const void *
template<typename Enum>
constexpr auto fmt::underlying (Enum e) noexcept -> underlying_t< Enum >
template<typename Enum>
requires (std::is_enum<Enum>::value)
constexpr auto fmt::enums::formatAs (Enum e) noexcept -> underlying_t< Enum >
template<typename T>
auto fmt::groupDigits (T value) -> GroupDigitsView< T >
template<detail::FixedString S>
constexpr auto fmt::literals::operator""_a ()
auto fmt::vsystemError (int error_code, StringView fmt, FormatArgs args) -> std::system_error
template<typename... T>
auto fmt::systemError (int error_code, FormatString< T... > fmt, T &&... args) -> std::system_error
auto fmt::formatSystemError (detail::Buffer< char > &out, int error_code, const char *message) noexcept -> void
auto fmt::reportSystemError (int error_code, const char *message) noexcept -> void
auto fmt::vformat (LocaleRef loc, StringView fmt, FormatArgs args) -> std::string
template<typename... T>
auto fmt::format (LocaleRef loc, FormatString< T... > fmt, T &&... args) -> std::string
template<typename OutputIt>
requires (detail::IsOutputIterator<OutputIt, char>::value)
auto fmt::vformatTo (OutputIt out, LocaleRef loc, StringView fmt, FormatArgs args) -> OutputIt
template<typename OutputIt, typename... T>
requires (detail::IsOutputIterator<OutputIt, char>::value)
auto fmt::formatTo (OutputIt out, LocaleRef loc, FormatString< T... > fmt, T &&... args) -> OutputIt
template<typename... T>
auto fmt::formattedSize (LocaleRef loc, FormatString< T... > fmt, T &&... args) -> size_t
auto fmt::vformat (StringView fmt, FormatArgs args) -> std::string
template<typename... T>
auto fmt::format (FormatString< T... > fmt, T &&... args) -> std::string
template<typename T>
requires (std::is_integral<T>::value)
constexpr auto fmt::to_string (T value) -> std::string
template<typename T>
requires (detail::UseFormatAs<T>::value)
constexpr auto fmt::to_string (const T &value) -> std::string
template<typename T>
requires (!std::is_integral<T>::value && !detail::UseFormatAs<T>::value)
constexpr auto fmt::to_string (const T &value) -> std::string
template<typename Char>
auto fmt::detail::decimalPointImpl (LocaleRef loc) -> Char
template<bool IS_CONSTEXPR, typename T, typename Ptr = const T*>
constexpr auto fmt::detail::find (Ptr first, Ptr last, T value, Ptr &out) -> bool
template<>
auto fmt::detail::find< false, char > (const char *first, const char *last, char value, const char *&out) -> bool
template<typename T, typename Context, typename Char>
auto fmt::detail::convertArg (BasicFormatArg< Context > &arg, Char type) -> void
template<typename Char>
auto fmt::detail::makeArgFormatter (BasicAppender< Char > iter, FormatSpecs &s) -> ArgFormatter< Char >
template<typename Char>
auto fmt::detail::parseFlags (FormatSpecs &specs, const Char *&it, const Char *end) -> void
template<typename Char, typename GetArg>
auto fmt::detail::parseHeader (const Char *&it, const Char *end, FormatSpecs &specs, GetArg get_arg) -> int
auto fmt::detail::parsePrintfPresentationType (char c, Type t, bool &upper) -> PresentationType
template<typename Char, typename Context>
auto fmt::detail::vprintf (Buffer< Char > &buf, BasicStringView< Char > format, BasicFormatArgs< Context > args) -> void
template<typename Char = char, typename... T>
auto fmt::makePrintfArgs (T &... args) -> decltype(fmt::makeFormatArgs< BasicPrintfContext< Char > >(args...))
template<typename Char>
auto fmt::vsprintf (BasicStringView< Char > fmt, typename VprintfArgs< Char >::type args) -> std::basic_string< Char >
template<typename... T>
auto fmt::sprintf (StringView fmt, const T &... args) -> std::string
template<typename... T>
auto fmt::sprintf (BasicStringView< wchar_t > fmt, const T &... args) -> std::wstring
template<typename Char>
auto fmt::vfprintf (std::FILE *f, BasicStringView< Char > fmt, typename VprintfArgs< Char >::type args) -> int
template<typename... T>
auto fmt::fprintf (std::FILE *f, StringView fmt, const T &... args) -> int
template<typename... T>
auto fmt::fprintf (std::FILE *f, BasicStringView< wchar_t > fmt, const T &... args) -> int
template<typename... T>
auto fmt::printf (StringView fmt, const T &... args) -> int
template<typename... T>
auto fmt::print (std::ostream &os, FormatString< T... > fmt, T &&... args) -> void
template<typename... T>
auto fmt::println (std::ostream &os, FormatString< T... > fmt, T &&... args) -> void
auto fmt::runtime (WstringView s) -> RuntimeFormatString< wchar_t >
template<typename... T>
constexpr auto fmt::makeWformatArgs (T &... args) -> decltype(fmt::makeFormatArgs< WformatContext >(args...))
template<typename T>
auto fmt::arg (const wchar_t *name, const T &arg) -> NamedArg< T, wchar_t >
template<typename It, typename Sentinel, typename S, typename Char = typename decltype(detail::toStringView( std::declval<S>()))::value_type>
requires (detail::IsExoticChar<Char>::value)
auto fmt::join (It begin, Sentinel end, S &&sep) -> JoinView< It, Sentinel, Char >
template<typename Range, typename S, typename Char = typename decltype(detail::toStringView( std::declval<S>()))::value_type>
requires (detail::IsExoticChar<Char>::value && !IsTupleLike<Range>::value)
auto fmt::join (Range &&range, S &&sep) -> JoinView< decltype(std::begin(range)), decltype(std::end(range)), Char >
template<typename T>
auto fmt::join (std::initializer_list< T > list, WstringView sep) -> JoinView< const T *, const T *, wchar_t >
template<typename Tuple, typename S, typename Char = typename decltype(detail::toStringView( std::declval<S>()))::value_type>
requires (detail::IsExoticChar<Char>::value && IsTupleLike<Tuple>::value)
auto fmt::join (const Tuple &tuple, S &&sep) -> TupleJoinView< Tuple, Char >
template<typename Char>
requires (!std::is_same<Char, char>::value)
auto fmt::vformat (BasicStringView< Char > fmt, BasicFormatArgs< BufferedContext< Char > > args) -> std::basic_string< Char >
template<typename... T>
auto fmt::format (WformatString< T... > fmt, T &&... args) -> std::wstring
template<typename OutputIt, typename... T>
auto fmt::formatTo (OutputIt out, WformatString< T... > fmt, T &&... args) -> OutputIt
template<typename S, typename... T, typename Char = detail::format_string_char_t<S>>
requires (!std::is_same<Char, char>::value && !std::is_same<Char, wchar_t>::value)
auto fmt::format (const S &fmt, T &&... args) -> std::basic_string< Char >
template<typename S, typename Char = detail::format_string_char_t<S>>
requires (detail::IsExoticChar<Char>::value)
auto fmt::vformat (LocaleRef loc, const S &fmt, BasicFormatArgs< BufferedContext< Char > > args) -> std::basic_string< Char >
template<typename S, typename... T, typename Char = detail::format_string_char_t<S>>
requires (detail::IsExoticChar<Char>::value)
auto fmt::format (LocaleRef loc, const S &fmt, T &&... args) -> std::basic_string< Char >
template<typename OutputIt, typename S, typename Char = detail::format_string_char_t<S>>
requires (detail::IsOutputIterator<OutputIt, Char>::value && detail::IsExoticChar<Char>::value)
auto fmt::vformatTo (OutputIt out, const S &fmt, BasicFormatArgs< BufferedContext< Char > > args) -> OutputIt
template<typename OutputIt, typename S, typename... T, typename Char = detail::format_string_char_t<S>>
requires (detail::IsOutputIterator<OutputIt, Char>::value && !std::is_same<Char, char>::value && !std::is_same<Char, wchar_t>::value)
auto fmt::formatTo (OutputIt out, const S &fmt, T &&... args) -> OutputIt
template<typename S, typename OutputIt, typename... Args, typename Char = detail::format_string_char_t<S>>
requires (detail::IsOutputIterator<OutputIt, Char>::value && detail::IsExoticChar<Char>::value)
auto fmt::vformatTo (OutputIt out, LocaleRef loc, const S &fmt, BasicFormatArgs< BufferedContext< Char > > args) -> OutputIt
template<typename OutputIt, typename S, typename... T, typename Char = detail::format_string_char_t<S>, bool enable = detail::IsOutputIterator<OutputIt, Char>::value && detail::IsExoticChar<Char>::value>
auto fmt::formatTo (OutputIt out, LocaleRef loc, const S &fmt, T &&... args) -> typename std::enable_if< enable, OutputIt >::type
template<typename OutputIt, typename Char, typename... Args>
requires (detail::IsOutputIterator<OutputIt, Char>::value && detail::IsExoticChar<Char>::value)
auto fmt::vformatToN (OutputIt out, size_t n, BasicStringView< Char > fmt, BasicFormatArgs< BufferedContext< Char > > args) -> FormatToNResult< OutputIt >
template<typename OutputIt, typename... T>
requires (detail::IsOutputIterator<OutputIt, wchar_t>::value)
auto fmt::formatToN (OutputIt out, size_t n, WformatString< T... > fmt, T &&... args) -> FormatToNResult< OutputIt >
template<typename OutputIt, typename S, typename... T, typename Char = detail::format_string_char_t<S>>
requires (detail::IsOutputIterator<OutputIt, Char>::value && !std::is_same<Char, char>::value && !std::is_same<Char, wchar_t>::value)
auto fmt::formatToN (OutputIt out, size_t n, const S &fmt, T &&... args) -> FormatToNResult< OutputIt >
template<typename S, typename... T, typename Char = detail::format_string_char_t<S>>
requires (detail::IsExoticChar<Char>::value)
auto fmt::formattedSize (const S &fmt, T &&... args) -> size_t
auto fmt::vprint (std::FILE *f, WstringView fmt, WformatArgs args) -> void
auto fmt::vprint (WstringView fmt, WformatArgs args) -> void
template<typename... T>
auto fmt::print (std::FILE *f, WformatString< T... > fmt, T &&... args) -> void
template<typename... T>
auto fmt::print (WformatString< T... > fmt, T &&... args) -> void
template<typename... T>
auto fmt::println (std::FILE *f, WformatString< T... > fmt, T &&... args) -> void
template<typename... T>
auto fmt::println (WformatString< T... > fmt, T &&... args) -> void
auto fmt::vformat (TextStyle ts, WstringView fmt, WformatArgs args) -> std::wstring
template<typename... T>
auto fmt::format (TextStyle ts, WformatString< T... > fmt, T &&... args) -> std::wstring
auto fmt::vprint (std::wostream &os, WstringView fmt, WformatArgs args) -> void
template<typename... T>
auto fmt::print (std::wostream &os, WformatString< T... > fmt, T &&... args) -> void
template<typename... T>
auto fmt::println (std::wostream &os, WformatString< T... > fmt, T &&... args) -> void
template<typename T>
auto fmt::to_wstring (const T &value) -> std::wstring
template<typename It, typename Sentinel>
auto fmt::join (It begin, Sentinel end, StringView sep) -> JoinView< It, Sentinel >
template<typename Range>
requires (!IsTupleLike<Range>::value)
constexpr auto fmt::join (Range &&r, StringView sep) -> JoinView< decltype(detail::rangeBegin(r)), decltype(detail::rangeEnd(r))>
template<typename Tuple>
requires (IsTupleLike<Tuple>::value)
constexpr auto fmt::join (const Tuple &tuple FMT_LIFETIMEBOUND, StringView sep) -> TupleJoinView< Tuple, char >
template<typename T>
auto fmt::join (std::initializer_list< T > list, StringView sep) -> JoinView< const T *, const T * >

Variables

constexpr int fmt::kVersion = 120'200
constexpr int fmt::detail::kSintSet
constexpr int fmt::detail::kUintSet
constexpr int fmt::detail::kBoolSet = set(Type::kBoolType)
constexpr int fmt::detail::kCharSet = set(Type::kCharType)
constexpr int fmt::detail::kFloatSet
constexpr int fmt::detail::kStringSet = set(Type::kStringType)
constexpr int fmt::detail::kCstringSet = set(Type::kCstringType)
constexpr int fmt::detail::kPointerSet = set(Type::kPointerType)
constexpr bool fmt::detail::kLongShort
constexpr int fmt::detail::kPackedArgBits = 4
constexpr int fmt::detail::kMaxPackedArgs = 62 / kPackedArgBits
constexpr Ullong fmt::detail::kIsUnpackedBit = 1ULL << 63
constexpr Ullong fmt::detail::kHasNamedArgsBit = 1ULL << 62
constexpr int fmt::kInlineBufferSize = 500

Files

file  /home/mccakit/desktop/mccakit-fmt/fmt/src/fmt/iface/fmt.cppm
 The fmt module.
file  /home/mccakit/desktop/mccakit-fmt/fmt/src/fmt/iface/args.cppm
 Dynamic argument stores, for building an argument list at run time.
file  /home/mccakit/desktop/mccakit-fmt/fmt/src/fmt/iface/base.cppm
 Core formatting API: format strings, argument storage and the type-erased formatting entry points.
file  /home/mccakit/desktop/mccakit-fmt/fmt/src/fmt/iface/chrono.cppm
 Formatters for std::chrono durations, time points and calendar types.
file  /home/mccakit/desktop/mccakit-fmt/fmt/src/fmt/iface/color.cppm
 Terminal colour and text style support.
file  /home/mccakit/desktop/mccakit-fmt/fmt/src/fmt/iface/compile.cppm
 Compile-time format string parsing.
file  /home/mccakit/desktop/mccakit-fmt/fmt/src/fmt/iface/format.cppm
 Formatting of built-in types: integers, floating point, strings and pointers, with the buffer and presentation-spec machinery behind them.
file  /home/mccakit/desktop/mccakit-fmt/fmt/src/fmt/iface/os.cppm
 Optional OS-specific functionality: file descriptors, files and pipes.
file  /home/mccakit/desktop/mccakit-fmt/fmt/src/fmt/iface/ostream.cppm
 Support for formatting into and from std::ostream.
file  /home/mccakit/desktop/mccakit-fmt/fmt/src/fmt/iface/printf.cppm
 printf-style formatting.
file  /home/mccakit/desktop/mccakit-fmt/fmt/src/fmt/iface/ranges.cppm
 Formatters for ranges, tuples and maps.
file  /home/mccakit/desktop/mccakit-fmt/fmt/src/fmt/iface/std.cppm
 Formatters for standard library types not covered elsewhere.
file  /home/mccakit/desktop/mccakit-fmt/fmt/src/fmt/iface/xchar.cppm
 Support for character types other than char, chiefly wchar_t.
file  /home/mccakit/desktop/mccakit-fmt/fmt/src/fmt/impl/format.cpp
 Implementation unit for the core formatting code.
file  /home/mccakit/desktop/mccakit-fmt/fmt/src/fmt/impl/os.cpp
 Implementation unit for the OS-specific functionality.