1 // Formatting library for C++ - formatters for standard library types
2 //
3 // Copyright (c) 2012 - present, Victor Zverovich
4 // All rights reserved.
5 //
6 // For the license information refer to format.h.
7
8 #ifndef FMT_STD_H_
9 #define FMT_STD_H_
10
11 #include <atomic>
12 #include <bitset>
13 #include <cstdlib>
14 #include <exception>
15 #include <memory>
16 #include <thread>
17 #include <type_traits>
18 #include <typeinfo>
19 #include <utility>
20 #include <vector>
21
22 #include "format.h"
23 #include "ostream.h"
24
25 #if FMT_HAS_INCLUDE(<version>)
26 # include <version>
27 #endif
28 // Checking FMT_CPLUSPLUS for warning suppression in MSVC.
29 #if FMT_CPLUSPLUS >= 201703L
30 # if FMT_HAS_INCLUDE(<filesystem>)
31 # include <filesystem>
32 # endif
33 # if FMT_HAS_INCLUDE(<variant>)
34 # include <variant>
35 # endif
36 # if FMT_HAS_INCLUDE(<optional>)
37 # include <optional>
38 # endif
39 #endif
40
41 #if FMT_CPLUSPLUS > 201703L && FMT_HAS_INCLUDE(<source_location>)
42 # include <source_location>
43 #endif
44
45 // GCC 4 does not support FMT_HAS_INCLUDE.
46 #if FMT_HAS_INCLUDE(<cxxabi.h>) || defined(__GLIBCXX__)
47 # include <cxxabi.h>
48 // Android NDK with gabi++ library on some architectures does not implement
49 // abi::__cxa_demangle().
50 # ifndef __GABIXX_CXXABI_H__
51 # define FMT_HAS_ABI_CXA_DEMANGLE
52 # endif
53 #endif
54
55 // Check if typeid is available.
56 #ifndef FMT_USE_TYPEID
57 // __RTTI is for EDG compilers. In MSVC typeid is available without RTTI.
58 # if defined(__GXX_RTTI) || FMT_HAS_FEATURE(cxx_rtti) || FMT_MSC_VERSION || \
59 defined(__INTEL_RTTI__) || defined(__RTTI)
60 # define FMT_USE_TYPEID 1
61 # else
62 # define FMT_USE_TYPEID 0
63 # endif
64 #endif
65
66 // For older Xcode versions, __cpp_lib_xxx flags are inaccurately defined.
67 #ifndef FMT_CPP_LIB_FILESYSTEM
68 # ifdef __cpp_lib_filesystem
69 # define FMT_CPP_LIB_FILESYSTEM __cpp_lib_filesystem
70 # else
71 # define FMT_CPP_LIB_FILESYSTEM 0
72 # endif
73 #endif
74
75 #ifndef FMT_CPP_LIB_VARIANT
76 # ifdef __cpp_lib_variant
77 # define FMT_CPP_LIB_VARIANT __cpp_lib_variant
78 # else
79 # define FMT_CPP_LIB_VARIANT 0
80 # endif
81 #endif
82
83 #if FMT_CPP_LIB_FILESYSTEM
84 FMT_BEGIN_NAMESPACE
85
86 namespace detail {
87
88 template <typename Char, typename PathChar>
get_path_string(const std::filesystem::path & p,const std::basic_string<PathChar> & native)89 auto get_path_string(const std::filesystem::path& p,
90 const std::basic_string<PathChar>& native) {
91 if constexpr (std::is_same_v<Char, char> && std::is_same_v<PathChar, wchar_t>)
92 return to_utf8<wchar_t>(native, to_utf8_error_policy::replace);
93 else
94 return p.string<Char>();
95 }
96
97 template <typename Char, typename PathChar>
write_escaped_path(basic_memory_buffer<Char> & quoted,const std::filesystem::path & p,const std::basic_string<PathChar> & native)98 void write_escaped_path(basic_memory_buffer<Char>& quoted,
99 const std::filesystem::path& p,
100 const std::basic_string<PathChar>& native) {
101 if constexpr (std::is_same_v<Char, char> &&
102 std::is_same_v<PathChar, wchar_t>) {
103 auto buf = basic_memory_buffer<wchar_t>();
104 write_escaped_string<wchar_t>(std::back_inserter(buf), native);
105 bool valid = to_utf8<wchar_t>::convert(quoted, {buf.data(), buf.size()});
106 FMT_ASSERT(valid, "invalid utf16");
107 } else if constexpr (std::is_same_v<Char, PathChar>) {
108 write_escaped_string<std::filesystem::path::value_type>(
109 std::back_inserter(quoted), native);
110 } else {
111 write_escaped_string<Char>(std::back_inserter(quoted), p.string<Char>());
112 }
113 }
114
115 } // namespace detail
116
117 FMT_EXPORT
118 template <typename Char> struct formatter<std::filesystem::path, Char> {
119 private:
120 format_specs<Char> specs_;
121 detail::arg_ref<Char> width_ref_;
122 bool debug_ = false;
123 char path_type_ = 0;
124
125 public:
126 FMT_CONSTEXPR void set_debug_format(bool set = true) { debug_ = set; }
127
128 template <typename ParseContext> FMT_CONSTEXPR auto parse(ParseContext& ctx) {
129 auto it = ctx.begin(), end = ctx.end();
130 if (it == end) return it;
131
132 it = detail::parse_align(it, end, specs_);
133 if (it == end) return it;
134
135 it = detail::parse_dynamic_spec(it, end, specs_.width, width_ref_, ctx);
136 if (it != end && *it == '?') {
137 debug_ = true;
138 ++it;
139 }
140 if (it != end && (*it == 'g')) path_type_ = *it++;
141 return it;
142 }
143
144 template <typename FormatContext>
145 auto format(const std::filesystem::path& p, FormatContext& ctx) const {
146 auto specs = specs_;
147 # ifdef _WIN32
148 auto path_string = !path_type_ ? p.native() : p.generic_wstring();
149 # else
150 auto path_string = !path_type_ ? p.native() : p.generic_string();
151 # endif
152
153 detail::handle_dynamic_spec<detail::width_checker>(specs.width, width_ref_,
154 ctx);
155 if (!debug_) {
156 auto s = detail::get_path_string<Char>(p, path_string);
157 return detail::write(ctx.out(), basic_string_view<Char>(s), specs);
158 }
159 auto quoted = basic_memory_buffer<Char>();
160 detail::write_escaped_path(quoted, p, path_string);
161 return detail::write(ctx.out(),
162 basic_string_view<Char>(quoted.data(), quoted.size()),
163 specs);
164 }
165 };
166 FMT_END_NAMESPACE
167 #endif // FMT_CPP_LIB_FILESYSTEM
168
169 FMT_BEGIN_NAMESPACE
170 FMT_EXPORT
171 template <std::size_t N, typename Char>
172 struct formatter<std::bitset<N>, Char> : nested_formatter<string_view> {
173 private:
174 // Functor because C++11 doesn't support generic lambdas.
175 struct writer {
176 const std::bitset<N>& bs;
177
178 template <typename OutputIt>
179 FMT_CONSTEXPR auto operator()(OutputIt out) -> OutputIt {
180 for (auto pos = N; pos > 0; --pos) {
181 out = detail::write<Char>(out, bs[pos - 1] ? Char('1') : Char('0'));
182 }
183
184 return out;
185 }
186 };
187
188 public:
189 template <typename FormatContext>
190 auto format(const std::bitset<N>& bs, FormatContext& ctx) const
191 -> decltype(ctx.out()) {
192 return write_padded(ctx, writer{bs});
193 }
194 };
195
196 FMT_EXPORT
197 template <typename Char>
198 struct formatter<std::thread::id, Char> : basic_ostream_formatter<Char> {};
199 FMT_END_NAMESPACE
200
201 #ifdef __cpp_lib_optional
202 FMT_BEGIN_NAMESPACE
203 FMT_EXPORT
204 template <typename T, typename Char>
205 struct formatter<std::optional<T>, Char,
206 std::enable_if_t<is_formattable<T, Char>::value>> {
207 private:
208 formatter<T, Char> underlying_;
209 static constexpr basic_string_view<Char> optional =
210 detail::string_literal<Char, 'o', 'p', 't', 'i', 'o', 'n', 'a', 'l',
211 '('>{};
212 static constexpr basic_string_view<Char> none =
213 detail::string_literal<Char, 'n', 'o', 'n', 'e'>{};
214
215 template <class U>
216 FMT_CONSTEXPR static auto maybe_set_debug_format(U& u, bool set)
217 -> decltype(u.set_debug_format(set)) {
218 u.set_debug_format(set);
219 }
220
221 template <class U>
222 FMT_CONSTEXPR static void maybe_set_debug_format(U&, ...) {}
223
224 public:
225 template <typename ParseContext> FMT_CONSTEXPR auto parse(ParseContext& ctx) {
226 maybe_set_debug_format(underlying_, true);
227 return underlying_.parse(ctx);
228 }
229
230 template <typename FormatContext>
231 auto format(const std::optional<T>& opt, FormatContext& ctx) const
232 -> decltype(ctx.out()) {
233 if (!opt) return detail::write<Char>(ctx.out(), none);
234
235 auto out = ctx.out();
236 out = detail::write<Char>(out, optional);
237 ctx.advance_to(out);
238 out = underlying_.format(*opt, ctx);
239 return detail::write(out, ')');
240 }
241 };
242 FMT_END_NAMESPACE
243 #endif // __cpp_lib_optional
244
245 #ifdef __cpp_lib_source_location
246 FMT_BEGIN_NAMESPACE
247 FMT_EXPORT
248 template <> struct formatter<std::source_location> {
249 template <typename ParseContext> FMT_CONSTEXPR auto parse(ParseContext& ctx) {
250 return ctx.begin();
251 }
252
253 template <typename FormatContext>
254 auto format(const std::source_location& loc, FormatContext& ctx) const
255 -> decltype(ctx.out()) {
256 auto out = ctx.out();
257 out = detail::write(out, loc.file_name());
258 out = detail::write(out, ':');
259 out = detail::write<char>(out, loc.line());
260 out = detail::write(out, ':');
261 out = detail::write<char>(out, loc.column());
262 out = detail::write(out, ": ");
263 out = detail::write(out, loc.function_name());
264 return out;
265 }
266 };
267 FMT_END_NAMESPACE
268 #endif
269
270 #if FMT_CPP_LIB_VARIANT
271 FMT_BEGIN_NAMESPACE
272 namespace detail {
273
274 template <typename T>
275 using variant_index_sequence =
276 std::make_index_sequence<std::variant_size<T>::value>;
277
278 template <typename> struct is_variant_like_ : std::false_type {};
279 template <typename... Types>
280 struct is_variant_like_<std::variant<Types...>> : std::true_type {};
281
282 // formattable element check.
283 template <typename T, typename C> class is_variant_formattable_ {
284 template <std::size_t... Is>
285 static std::conjunction<
286 is_formattable<std::variant_alternative_t<Is, T>, C>...>
287 check(std::index_sequence<Is...>);
288
289 public:
290 static constexpr const bool value =
291 decltype(check(variant_index_sequence<T>{}))::value;
292 };
293
294 template <typename Char, typename OutputIt, typename T>
295 auto write_variant_alternative(OutputIt out, const T& v) -> OutputIt {
296 if constexpr (is_string<T>::value)
297 return write_escaped_string<Char>(out, detail::to_string_view(v));
298 else if constexpr (std::is_same_v<T, Char>)
299 return write_escaped_char(out, v);
300 else
301 return write<Char>(out, v);
302 }
303
304 } // namespace detail
305
306 template <typename T> struct is_variant_like {
307 static constexpr const bool value = detail::is_variant_like_<T>::value;
308 };
309
310 template <typename T, typename C> struct is_variant_formattable {
311 static constexpr const bool value =
312 detail::is_variant_formattable_<T, C>::value;
313 };
314
315 FMT_EXPORT
316 template <typename Char> struct formatter<std::monostate, Char> {
317 template <typename ParseContext>
318 FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
319 return ctx.begin();
320 }
321
322 template <typename FormatContext>
323 auto format(const std::monostate&, FormatContext& ctx) const
324 -> decltype(ctx.out()) {
325 return detail::write<Char>(ctx.out(), "monostate");
326 }
327 };
328
329 FMT_EXPORT
330 template <typename Variant, typename Char>
331 struct formatter<
332 Variant, Char,
333 std::enable_if_t<std::conjunction_v<
334 is_variant_like<Variant>, is_variant_formattable<Variant, Char>>>> {
335 template <typename ParseContext>
336 FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
337 return ctx.begin();
338 }
339
340 template <typename FormatContext>
341 auto format(const Variant& value, FormatContext& ctx) const
342 -> decltype(ctx.out()) {
343 auto out = ctx.out();
344
345 out = detail::write<Char>(out, "variant(");
346 FMT_TRY {
347 std::visit(
348 [&](const auto& v) {
349 out = detail::write_variant_alternative<Char>(out, v);
350 },
351 value);
352 }
353 FMT_CATCH(const std::bad_variant_access&) {
354 detail::write<Char>(out, "valueless by exception");
355 }
356 *out++ = ')';
357 return out;
358 }
359 };
360 FMT_END_NAMESPACE
361 #endif // FMT_CPP_LIB_VARIANT
362
363 FMT_BEGIN_NAMESPACE
364 FMT_EXPORT
365 template <typename Char> struct formatter<std::error_code, Char> {
366 template <typename ParseContext>
367 FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
368 return ctx.begin();
369 }
370
371 template <typename FormatContext>
372 FMT_CONSTEXPR auto format(const std::error_code& ec, FormatContext& ctx) const
373 -> decltype(ctx.out()) {
374 auto out = ctx.out();
375 out = detail::write_bytes(out, ec.category().name(), format_specs<Char>());
376 out = detail::write<Char>(out, Char(':'));
377 out = detail::write<Char>(out, ec.value());
378 return out;
379 }
380 };
381
382 FMT_EXPORT
383 template <typename T, typename Char>
384 struct formatter<
385 T, Char, // DEPRECATED! Mixing code unit types.
386 typename std::enable_if<std::is_base_of<std::exception, T>::value>::type> {
387 private:
388 bool with_typename_ = false;
389
390 public:
391 FMT_CONSTEXPR auto parse(basic_format_parse_context<Char>& ctx)
392 -> decltype(ctx.begin()) {
393 auto it = ctx.begin();
394 auto end = ctx.end();
395 if (it == end || *it == '}') return it;
396 if (*it == 't') {
397 ++it;
398 with_typename_ = FMT_USE_TYPEID != 0;
399 }
400 return it;
401 }
402
403 template <typename OutputIt>
404 auto format(const std::exception& ex,
405 basic_format_context<OutputIt, Char>& ctx) const -> OutputIt {
406 format_specs<Char> spec;
407 auto out = ctx.out();
408 if (!with_typename_)
409 return detail::write_bytes(out, string_view(ex.what()), spec);
410
411 #if FMT_USE_TYPEID
412 const std::type_info& ti = typeid(ex);
413 # ifdef FMT_HAS_ABI_CXA_DEMANGLE
414 int status = 0;
415 std::size_t size = 0;
416 std::unique_ptr<char, void (*)(void*)> demangled_name_ptr(
417 abi::__cxa_demangle(ti.name(), nullptr, &size, &status), &std::free);
418
419 string_view demangled_name_view;
420 if (demangled_name_ptr) {
421 demangled_name_view = demangled_name_ptr.get();
422
423 // Normalization of stdlib inline namespace names.
424 // libc++ inline namespaces.
425 // std::__1::* -> std::*
426 // std::__1::__fs::* -> std::*
427 // libstdc++ inline namespaces.
428 // std::__cxx11::* -> std::*
429 // std::filesystem::__cxx11::* -> std::filesystem::*
430 if (demangled_name_view.starts_with("std::")) {
431 char* begin = demangled_name_ptr.get();
432 char* to = begin + 5; // std::
433 for (char *from = to, *end = begin + demangled_name_view.size();
434 from < end;) {
435 // This is safe, because demangled_name is NUL-terminated.
436 if (from[0] == '_' && from[1] == '_') {
437 char* next = from + 1;
438 while (next < end && *next != ':') next++;
439 if (next[0] == ':' && next[1] == ':') {
440 from = next + 2;
441 continue;
442 }
443 }
444 *to++ = *from++;
445 }
446 demangled_name_view = {begin, detail::to_unsigned(to - begin)};
447 }
448 } else {
449 demangled_name_view = string_view(ti.name());
450 }
451 out = detail::write_bytes(out, demangled_name_view, spec);
452 # elif FMT_MSC_VERSION
453 string_view demangled_name_view(ti.name());
454 if (demangled_name_view.starts_with("class "))
455 demangled_name_view.remove_prefix(6);
456 else if (demangled_name_view.starts_with("struct "))
457 demangled_name_view.remove_prefix(7);
458 out = detail::write_bytes(out, demangled_name_view, spec);
459 # else
460 out = detail::write_bytes(out, string_view(ti.name()), spec);
461 # endif
462 *out++ = ':';
463 *out++ = ' ';
464 return detail::write_bytes(out, string_view(ex.what()), spec);
465 #endif
466 }
467 };
468
469 namespace detail {
470
471 template <typename T, typename Enable = void>
472 struct has_flip : std::false_type {};
473
474 template <typename T>
475 struct has_flip<T, void_t<decltype(std::declval<T>().flip())>>
476 : std::true_type {};
477
478 template <typename T> struct is_bit_reference_like {
479 static constexpr const bool value =
480 std::is_convertible<T, bool>::value &&
481 std::is_nothrow_assignable<T, bool>::value && has_flip<T>::value;
482 };
483
484 #ifdef _LIBCPP_VERSION
485
486 // Workaround for libc++ incompatibility with C++ standard.
487 // According to the Standard, `bitset::operator[] const` returns bool.
488 template <typename C>
489 struct is_bit_reference_like<std::__bit_const_reference<C>> {
490 static constexpr const bool value = true;
491 };
492
493 #endif
494
495 } // namespace detail
496
497 // We can't use std::vector<bool, Allocator>::reference and
498 // std::bitset<N>::reference because the compiler can't deduce Allocator and N
499 // in partial specialization.
500 FMT_EXPORT
501 template <typename BitRef, typename Char>
502 struct formatter<BitRef, Char,
503 enable_if_t<detail::is_bit_reference_like<BitRef>::value>>
504 : formatter<bool, Char> {
505 template <typename FormatContext>
506 FMT_CONSTEXPR auto format(const BitRef& v, FormatContext& ctx) const
507 -> decltype(ctx.out()) {
508 return formatter<bool, Char>::format(v, ctx);
509 }
510 };
511
512 FMT_EXPORT
513 template <typename T, typename Char>
514 struct formatter<std::atomic<T>, Char,
515 enable_if_t<is_formattable<T, Char>::value>>
516 : formatter<T, Char> {
517 template <typename FormatContext>
518 auto format(const std::atomic<T>& v, FormatContext& ctx) const
519 -> decltype(ctx.out()) {
520 return formatter<T, Char>::format(v.load(), ctx);
521 }
522 };
523
524 #ifdef __cpp_lib_atomic_flag_test
525 FMT_EXPORT
526 template <typename Char>
527 struct formatter<std::atomic_flag, Char> : formatter<bool, Char> {
528 template <typename FormatContext>
529 auto format(const std::atomic_flag& v, FormatContext& ctx) const
530 -> decltype(ctx.out()) {
531 return formatter<bool, Char>::format(v.test(), ctx);
532 }
533 };
534 #endif // __cpp_lib_atomic_flag_test
535
536 FMT_END_NAMESPACE
537 #endif // FMT_STD_H_
538