Stroika Library 3.0d24
 
Loading...
Searching...
No Matches
ToString.h
Go to the documentation of this file.
1/*
2 * Copyright(c) Sophist Solutions, Inc. 1990-2026. All rights reserved
3 */
4#ifndef _Stroika_Foundation_Characters_ToString_h_
5#define _Stroika_Foundation_Characters_ToString_h_ 1
6
7#include "Stroika/Foundation/StroikaPreComp.h"
8
9#include <chrono>
10#include <ios>
11#include <optional>
12#include <queue>
13#include <sstream>
14#include <stack>
15#include <thread>
16#include <tuple>
17#include <typeindex>
18#include <typeinfo>
19#include <utility>
20
21#include "Stroika/Foundation/Characters/String.h"
22#include "Stroika/Foundation/Common/Concepts.h"
23#include "Stroika/Foundation/Common/CountedValue.h"
24#include "Stroika/Foundation/Common/KeyValuePair.h"
25#include "Stroika/Foundation/Common/StdCompat.h"
26
27#if __cpp_lib_stacktrace >= 202011 && !qCompiler_clangNotCompatibleWithLibStdCPPStackTrace_Buggy
28#include <stacktrace>
29#endif
30
31/**
32 * \file
33 * Convert arbitrary objects to String form, for the purpose of debugging (not reversible).
34 *
35 * \note Code-Status: <a href="Code-Status.md#Alpha">Alpha</a>
36 *
37 * TODO:
38 * @todo ToString(tuple) should use variadic templates and support multiple (past 3) args
39 */
40
41#if qStroika_HasComponent_fmtlib && (FMT_VERSION >= 110000)
42namespace Stroika::Foundation::Common {
43 struct GUID;
44}
45namespace Stroika::Foundation::DataExchange {
46 class VariantValue;
47}
48namespace Stroika::Foundation::Memory {
49 class BLOB;
50}
51#endif
52
53namespace Stroika::Foundation::Characters {
54
55 /**
56 * \brief Return a debug-friendly, display version of the argument: not guaranteed parsable or usable except for debugging
57 *
58 * Convert an instance of the given object to a printable string representation. This representation
59 * is not guaranteed, pretty, or parsable. This feature is generally for debugging purposes, but can be used
60 * to render/emit objects in any informal setting where you just need a rough sense of the object (again,
61 * the only case I can think of here would be for debugging).
62 *
63 * \note *AKA*
64 * o DUMP
65 * o PrettyPrint
66 *
67 * Patterned after:
68 * Java:
69 * From the Object.toString() docs:
70 * Returns a string representation of the object. In general, the toString method
71 * returns a string that "textually represents" this object.
72 * Javascript:
73 * The toString() method returns a string representing object.
74 * Every object has a toString() method that is automatically called when the object is
75 * to be represented as a text value or when an object is referred to in a manner in which
76 * a string is expected.
77 *
78 * \note Built-in or std types intrinsically supported:
79 * o type_index, type_traits, or anything with a .name () which returns a const SDKChar* string.
80 * o is_array<T>
81 * o is_enum<T>
82 * o atomic<T> where T is a ToStringable type
83 * o shared_ptr<T> (but not unique_ptr<> because its not regular, which std::format requires)
84 * o std::exception
85 * o std::tuple
86 * o std::variant
87 * o std::pair
88 * o std::optional
89 * o std::wstring
90 * o std::filesystem::path
91 * o exception_ptr
92 * o POD types (int, bool, double, etc)
93 * o anything with .begin (), .end () - so any container/iterable
94 * o anything class(or struct) with a ToString () method
95 *
96 * \note Other types automatically supported
97 * o KeyValuePair
98 * o CountedValue
99 * o String -- printed as 'the-string' (possibly length limited)
100 *
101 * \note Extra arguments/overloads
102 * o ToString (float, FloatConversion::ToStringOptions) // any floating point argument
103 * o ToString (float, FloatConversion::SignificantFigures) // ''
104 * o ToString (integral T, ios_base::fmtflags flags); // flags may be std::dec, std::oct, or std::hex
105 * // @see https://en.cppreference.com/w/cpp/io/ios_base/fmtflags
106 * o ToString (Duration, FloatConversion::SignificantFigures) // forwards to Duration::As<String> (SignificantFigures)
107 *
108 * \note *Implementation Note*
109 * This implementation defaults to calling T{}.ToString ().
110 *
111 * \note @see IToString to check if Characters::ToString () well defined.
112 */
113 template <typename T, typename... ARGS>
114 String ToString (T&& t, ARGS... args);
115
116 /**
117 * \brief Check if legal to call Characters::ToString(T)...
118 */
119 template <typename T>
120 concept IToString = requires (T t) {
121 { ToString (t) } -> convertible_to<Characters::String>;
122 };
123
124 /**
125 * \brief same as ToString()/1 - but without the potentially confusing multi-arg overloads (confused some template expansions).
126 */
127 template <typename T>
128 String UnoverloadedToString (const T& t);
129
130 //// @todo read https://stackoverflow.com/questions/59909102/stdformat-of-user-defined-types
131 // I THINK I want to SUBCLASS from std::formatter<std::string> - or something close to that...
132 /**
133 * define a 'std::formatter' for Stroika (and other types) for which formatter not already predefined - which use
134 * Characters::ToString (T)
135 */
136 template <IToString T>
137 struct ToStringFormatter /* : std::formatter<std::wstring>*/ {
138 qStroika_Foundation_Characters_FMT_PREFIX_::formatter<String, wchar_t> fDelegate2_;
139
140 template <class ParseContext>
141 constexpr typename ParseContext::iterator parse (ParseContext& ctx)
142 {
143 return fDelegate2_.parse (ctx);
144 }
145
146 template <class FmtContext>
147 typename FmtContext::iterator format (T s, FmtContext& ctx) const
148 {
149 return fDelegate2_.format (UnoverloadedToString (s), ctx);
150#if 0
151
152 std::wstringstream out;
153 out << UnoverloadedToString (s);
154#if __cpp_lib_ranges >= 202207L
155 return std::ranges::copy (std::move (out).str (), ctx.out ()).out;
156#else
157 return Common::StdCompat::format_to (ctx.out (), L"{}", String{out.str ()});
158#endif
159#endif
160 }
161 };
162 template <IToString T>
163 struct ToStringFormatterASCII {
164
165 ToStringFormatter<T> fDelegate2_;
166 template <class ParseContext>
167 constexpr typename ParseContext::iterator parse (ParseContext& ctx)
168 {
169 // Not clear how to forward...
170 auto it = ctx.begin ();
171 while (it != ctx.end ()) {
172 ++it;
173#if 0
174 if (it == ctx.end ()) {
175 throw Common::StdCompat::format_error{"Invalid format args (missing }) for ToStringFormatterASCII."};
176 }
177#endif
178 if (*it == '}') {
179 return it;
180 }
181 }
182 return it;
183 }
184
185 template <class FmtContext>
186 typename FmtContext::iterator format (T s, FmtContext& ctx) const
187 {
188 using namespace Stroika::Foundation::Characters;
189 std::wstringstream out;
190 out << UnoverloadedToString (s);
191
192 // @todo delegate to string version so we can use its ignore errors code......
193#if __cpp_lib_ranges >= 202207L
194 return std::ranges::copy (String{out.str ()}.AsNarrowSDKString (eIgnoreErrors), ctx.out ()).out;
195#else
196 return Common::StdCompat::format_to (ctx.out (), "{}", String{out.str ()}.AsNarrowSDKString (eIgnoreErrors));
197#endif
198 }
199 };
200
201}
202
203namespace Stroika::Foundation::Characters::Private_ {
204
205 /**
206 * \brief IStdFormatterPredefinedFor_<T> = what formattable<T,wchar_t> WOULD have returned if it could be evaluated safely without its value being memoized.
207 *
208 * \see https://stackoverflow.com/questions/78774217/how-to-extend-stdformatter-without-sometimes-introducing-conflicts-can-concep
209 *
210 * \see https://en.cppreference.com/w/cpp/utility/format/formatter std::formatter predefined for
211 *
212 * template <typename T, typename TUnique = decltype ([] () -> void {})>
213 * concept IStdFormatterPredefinedFor_ = requires (T t) {
214 * typename TUnique;
215 * Stroika::Foundation::Common::StdCompat::formattable<T, wchar_t>;
216 * };
217 */
218 template <typename T>
219 concept IStdFormatterPredefinedFor_ =
220 // clang-format off
221
222#if __cplusplus == 202302L && _GLIBCXX_RELEASE == 15
223 not Common::IAnyOf<remove_cvref_t<T>, filesystem::path> and
224#endif
225 (
226
227 // C++-20
228 Common::IAnyOf<decay_t<T>, char, wchar_t> or Common::IAnyOf<T, char*, const char*, wchar_t*, const wchar_t*>
229 or requires { []<typename TRAITS, typename ALLOCATOR> (type_identity<std::basic_string<char, TRAITS, ALLOCATOR>>) {}(type_identity<T> ()); }
230 or requires { []<typename TRAITS, typename ALLOCATOR> (type_identity<std::basic_string<wchar_t, TRAITS, ALLOCATOR>>) {}(type_identity<T> ()); }
231 or requires { []<typename TRAITS> (type_identity<std::basic_string_view<char, TRAITS>>) {}(type_identity<T> ()); }
232 or requires { []<typename TRAITS> (type_identity<std::basic_string_view<wchar_t, TRAITS>>) {}(type_identity<T> ()); }
233 or requires { []<size_t N> (type_identity<wchar_t[N]>) {}(type_identity<T> ()); }
234 or std::is_arithmetic_v<T>
235#if defined(__GNUC__) && _GLIBCXX_RELEASE >= 15
236 or Common::IAnyOf<remove_cvref_t<T>, _Float32, _Float64>
237#endif
238 or Common::IAnyOf<decay_t<T>, nullptr_t, void*, const void*>
239 // chrono
240 or Common::IDuration<T>
241 or requires { []<typename DURATION> (type_identity<std::chrono::sys_time<DURATION>>) {}(type_identity<T> ()); }
242#if !defined(_LIBCPP_VERSION) or _LIBCPP_VERSION > 229999
243 or requires { []<typename DURATION> (type_identity<std::chrono::utc_time<DURATION>>) {}(type_identity<T> ()); }
244 or requires { []<typename DURATION> (type_identity<std::chrono::tai_time<DURATION>>) {}(type_identity<T> ()); }
245 or requires { []<typename DURATION> (type_identity<std::chrono::gps_time<DURATION>>) {}(type_identity<T> ()); }
246#endif
247 or requires { []<typename DURATION> (type_identity<std::chrono::file_time<DURATION>>) {}(type_identity<T> ()); }
248 or requires { []<typename DURATION> (type_identity<std::chrono::local_time<DURATION>>) {}(type_identity<T> ()); }
249 or Common::IAnyOf<decay_t<T>, chrono::day, chrono::month, chrono::year,
250 chrono::weekday, chrono::weekday_indexed, chrono::weekday_last,
251 chrono::month_day, chrono::month_day_last, chrono::month_weekday, chrono::month_weekday_last,
252 chrono::year_month, chrono::year_month_day, chrono::year_month_day_last, chrono::year_month_weekday,chrono::year_month_weekday_last
253#if (not defined (_GLIBCXX_RELEASE) or _GLIBCXX_RELEASE > 12) and (!defined(_LIBCPP_VERSION) or _LIBCPP_VERSION > 229999)
254 , chrono::sys_info, chrono::local_info
255#endif
256 >
257 or requires { []<typename DURATION> (type_identity<chrono::hh_mm_ss<DURATION>>) {}(type_identity<T> ()); }
258#if (not defined (_GLIBCXX_RELEASE) or _GLIBCXX_RELEASE > 12) and (!defined(_LIBCPP_VERSION) or _LIBCPP_VERSION > 229999)
259 or requires { []<typename DURATION, typename TimeZonePtr> (type_identity<chrono::zoned_time<DURATION, TimeZonePtr>>) {}(type_identity<T> ()); }
260#endif
261
262 // C++23
263 //
264 // sadly MSFT doesn't support __cplusplus with right value
265 // 202302L is right value (of __cplusplus) to check for C++ 23, but 202101L needed for clang++16 ;-(
266 // value with clang++16 was 202101L and cpp2b and libc++ (ubuntu 23.10 and 24.04) flag... and it had at least the pair<> code supported.
267 // this stuff needed for clang++-18-debug-libstdc++-c++23
268 //
269#if __cpp_lib_format_ranges
270 or ranges::range<decay_t<T>>
271#endif
272#if (__cplusplus > 202101L or _LIBCPP_STD_VER >= 23 or (_MSVC_LANG >= 202004 and _MSC_VER >= _MSC_VER_2k22_17Pt11_)) and not (defined (_GLIBCXX_RELEASE) and _GLIBCXX_RELEASE <= 14)
273 or Common::IPair<remove_cvref_t<T>> or Common::ITuple<remove_cvref_t<T>>
274#endif
275#if __cplusplus > 202101L or _LIBCPP_STD_VER >= 23 or _MSVC_LANG >= 202004
276 or Common::IAnyOf<remove_cvref_t<T>, thread::id>
277#endif
278#if __cpp_lib_stacktrace >= 202011 && !qCompiler_clangNotCompatibleWithLibStdCPPStackTrace_Buggy
279 or Common::IAnyOf<remove_cvref_t<T>, stacktrace_entry>
280 or requires { []<typename ALLOCATOR> (type_identity<basic_stacktrace<ALLOCATOR>>) {}(type_identity<T> ()); }
281#endif
282#if __cplusplus > 202101L or _LIBCPP_STD_VER >= 23 or _MSVC_LANG >= 202004
283 or requires { []<typename TT> (type_identity<stack<TT>>) {}(type_identity<T> ()); }
284 or requires { []<typename TT> (type_identity<queue<TT>>) {}(type_identity<T> ()); }
285#endif
286
287 // C++26
288#if __cplusplus > 202400L or _LIBCPP_STD_VER >= 26 or _MSVC_LANG >= 202400L
289 // unsure what to check - __cpp_lib_format - test c++26 __cpp_lib_formatters < 202601L -- 202302L is c++23
290 or Common::IAnyOf<remove_cvref_t<T>, std::filesystem::path>
291#endif
292
293
294
295 // AND throw in other libraries Stroika is built with (this is why the question in https://stackoverflow.com/questions/78774217/how-to-extend-stdformatter-without-sometimes-introducing-conflicts-can-concep
296 // is so important to better resolve!
297#if qStroika_HasComponent_fmtlib
298 or Common::IAnyOf<decay_t<T>, qStroika_Foundation_Characters_FMT_PREFIX_::string_view, qStroika_Foundation_Characters_FMT_PREFIX_::wstring_view>
299#if (FMT_VERSION >= 110000)
300 // Workaround issue with fmtlib 11 ranges support - it matches these
301 or Common::IAnyOf<decay_t<T>,Common::GUID, Memory::BLOB>
302 // FMT_VERSION has pair/tuple support after FMT version 11
303 or Common::IPair<remove_cvref_t<T>> or Common::ITuple<remove_cvref_t<T>>
304#endif
305#endif
306
307 );
308 // clang-format on
309
310// Debug hack to spot-check IStdFormatterPredefinedFor_
311#if _MSVC_LANG == 202004 && (_MSC_VER < _MSC_VER_2k22_17Pt11_)
312 static_assert (not IStdFormatterPredefinedFor_<std::pair<int, char>>);
313 static_assert (not IStdFormatterPredefinedFor_<std::tuple<int>>);
314 static_assert (IStdFormatterPredefinedFor_<std::thread::id>);
315 static_assert (not IStdFormatterPredefinedFor_<std::type_index>);
316 static_assert (not IStdFormatterPredefinedFor_<std::exception_ptr>);
317#endif
318#if _MSVC_LANG == 202004 && (_MSC_VER == _MSC_VER_2k22_17Pt11_)
319 static_assert (IStdFormatterPredefinedFor_<std::pair<int, char>>);
320 static_assert (IStdFormatterPredefinedFor_<std::tuple<int>>);
321 static_assert (IStdFormatterPredefinedFor_<std::thread::id>);
322 static_assert (not IStdFormatterPredefinedFor_<std::type_index>);
323 static_assert (not IStdFormatterPredefinedFor_<std::exception_ptr>);
324#endif
325#if __cplusplus == 202002L && _GLIBCXX_RELEASE == 13
326 static_assert (not IStdFormatterPredefinedFor_<std::pair<int, char>>);
327 static_assert (not IStdFormatterPredefinedFor_<std::tuple<int>>);
328 static_assert (not IStdFormatterPredefinedFor_<std::thread::id>);
329 static_assert (not IStdFormatterPredefinedFor_<std::type_index>);
330 static_assert (not IStdFormatterPredefinedFor_<std::exception_ptr>);
331#endif
332#if __cplusplus == 202002L && _GLIBCXX_RELEASE == 14
333 static_assert (not IStdFormatterPredefinedFor_<std::pair<int, char>>);
334 static_assert (not IStdFormatterPredefinedFor_<std::tuple<int>>);
335 static_assert (not IStdFormatterPredefinedFor_<std::thread::id>);
336 static_assert (not IStdFormatterPredefinedFor_<std::type_index>);
337 static_assert (not IStdFormatterPredefinedFor_<std::exception_ptr>);
338#endif
339#if __cplusplus == 202302L && _GLIBCXX_RELEASE == 14
340 static_assert (not IStdFormatterPredefinedFor_<std::pair<int, char>>);
341 static_assert (not IStdFormatterPredefinedFor_<std::tuple<int>>);
342 static_assert (IStdFormatterPredefinedFor_<std::thread::id>);
343 static_assert (not IStdFormatterPredefinedFor_<std::type_index>);
344 static_assert (not IStdFormatterPredefinedFor_<std::exception_ptr>);
345#endif
346#if __cplusplus == 202002L && _GLIBCXX_RELEASE == 15
347 static_assert (not IStdFormatterPredefinedFor_<std::filesystem::path>);
348 static_assert (not IStdFormatterPredefinedFor_<std::pair<int, char>>);
349 static_assert (not IStdFormatterPredefinedFor_<std::tuple<int>>);
350 static_assert (not IStdFormatterPredefinedFor_<std::thread::id>);
351 static_assert (not IStdFormatterPredefinedFor_<std::type_index>);
352 static_assert (not IStdFormatterPredefinedFor_<std::exception_ptr>);
353#endif
354#if __cplusplus == 202302L && _GLIBCXX_RELEASE == 15
355 static_assert (not IStdFormatterPredefinedFor_<std::filesystem::path>);
356 static_assert (IStdFormatterPredefinedFor_<std::pair<int, char>>);
357 static_assert (IStdFormatterPredefinedFor_<std::tuple<int>>);
358 static_assert (IStdFormatterPredefinedFor_<std::thread::id>);
359 static_assert (not IStdFormatterPredefinedFor_<std::type_index>);
360 static_assert (not IStdFormatterPredefinedFor_<std::exception_ptr>);
361#endif
362#if __cplusplus == 202002L && _GLIBCXX_RELEASE == 16
363 static_assert (not IStdFormatterPredefinedFor_<std::filesystem::path>);
364 static_assert (not IStdFormatterPredefinedFor_<std::pair<int, char>>);
365 static_assert (not IStdFormatterPredefinedFor_<std::tuple<int>>);
366 static_assert (not IStdFormatterPredefinedFor_<std::thread::id>);
367 static_assert (not IStdFormatterPredefinedFor_<std::type_index>);
368 static_assert (not IStdFormatterPredefinedFor_<std::exception_ptr>);
369#endif
370#if __cplusplus == 202302L && _GLIBCXX_RELEASE == 16
371 static_assert (IStdFormatterPredefinedFor_<std::filesystem::path>);
372 static_assert (IStdFormatterPredefinedFor_<std::pair<int, char>>);
373 static_assert (IStdFormatterPredefinedFor_<std::tuple<int>>);
374 static_assert (IStdFormatterPredefinedFor_<std::thread::id>);
375 static_assert (not IStdFormatterPredefinedFor_<std::type_index>);
376 static_assert (not IStdFormatterPredefinedFor_<std::exception_ptr>);
377#endif
378#if defined(__APPLE__) && __clang_major__ == 15
379 static_assert (not IStdFormatterPredefinedFor_<std::pair<int, char>>);
380 static_assert (not IStdFormatterPredefinedFor_<std::tuple<int>>);
381 static_assert (not IStdFormatterPredefinedFor_<std::thread::id>);
382 static_assert (not IStdFormatterPredefinedFor_<std::type_index>);
383 static_assert (not IStdFormatterPredefinedFor_<std::exception_ptr>);
384#endif
385
386// Debugging hacks to make sure IStdFormatterPredefinedFor_ defined properly
387//
388// CRAZY - but cannot check here: checking NOW causes
389// this to FAIL later (i guess compiler caches results cuz thinks its constant).
390// if this worked, I'd add more static_asserts to check...
391//
392// Just use briefly - to debug IStdFormatterPredefinedFor_ - to verify we fail AFTER this point;
393// To debug settings on IStdFormatterPredefinedFor_:
394// - enable #if below and just look if these static_asserts fail
395// - ignore any issues which come after (which is why this cannot be left #if 1)
396#if 0
397 static_assert (IStdFormatterPredefinedFor_<std::type_index> == Common::StdCompat::formattable<std::type_index, wchar_t>);
398 static_assert (IStdFormatterPredefinedFor_<std::pair<int, char>> == Common::StdCompat::formattable<std::pair<int, char>, wchar_t>);
399 static_assert (IStdFormatterPredefinedFor_<std::tuple<int>> == Common::StdCompat::formattable<std::tuple<int>, wchar_t>);
400 static_assert (IStdFormatterPredefinedFor_<std::thread::id> == Common::StdCompat::formattable<std::thread::id, wchar_t>);
401 static_assert (IStdFormatterPredefinedFor_<std::filesystem::path> == Common::StdCompat::formattable<std::filesystem::path, wchar_t>);
402 static_assert (IStdFormatterPredefinedFor_<std::exception_ptr> == Common::StdCompat::formattable<std::exception_ptr, wchar_t>);
403#endif
404
405 /**
406 * \brief roughly !formattable<T> and IToString<T> ; but cannot do this cuz then formattable<T> would change meaning. So really mean 'formattable so far'
407 *
408 * \see https://en.cppreference.com/w/cpp/utility/format/formatter
409 * \see https://stackoverflow.com/questions/78774217/how-to-extend-stdformatter-without-sometimes-introducing-conflicts-can-concep
410 */
411 template <typename T>
412 concept IUseToStringFormatterForFormatter_ =
413
414 // If Characters::ToString() would work
415 IToString<T>
416
417#if !qCompiler_IUseToStringFormatterForFormatter_Buggy
418 // But NOT anything std c++ defined to already support (else we get ambiguity error)
419 and not IStdFormatterPredefinedFor_<T>
420#else
421 and (requires (T t) {
422 { t.ToString () } -> convertible_to<Characters::String>;
423 } or Common::IKeyValuePair<remove_cvref_t<T>> or Common::ICountedValue<remove_cvref_t<T>>
424 //or Common::ISharedPtr<decay_t<T>>
425#if !__cpp_lib_format_ranges
426#if !qStroika_HasComponent_fmtlib or (FMT_VERSION < 110000)
427 or (ranges::range<decay_t<T>> and
428 not Common::IAnyOf<decay_t<T>, string, wstring, string_view, wstring_view, const char[], const wchar_t[],
429 qStroika_Foundation_Characters_FMT_PREFIX_::string_view, qStroika_Foundation_Characters_FMT_PREFIX_::wstring_view>)
430#endif
431#endif
432#if _MSC_VER || __cplusplus < 202101L /*202302L 202100L 202300L*/ || (__clang__ != 0 && __GLIBCXX__ != 0 && __GLIBCXX__ <= 20240908) || \
433 (!defined(__clang__) && __cplusplus == 202302L && __GLIBCXX__ <= 20240908) and (!defined(_LIBCPP_STD_VER) || _LIBCPP_STD_VER < 23)
434#if !qStroika_HasComponent_fmtlib or (FMT_VERSION < 110000)
435 // available in C++23
436 or Common::IPair<remove_cvref_t<T>> or
437 Common::ITuple<remove_cvref_t<T>>
438#endif
439#endif
440#if (!defined(__cpp_lib_formatters) || __cpp_lib_formatters < 202302L) and (!defined(_LIBCPP_STD_VER) || _LIBCPP_STD_VER < 23)
441 // available in C++23
442 or Common::IAnyOf<remove_cvref_t<T>, thread::id>
443#endif
444#if __cplusplus < 202400L || (defined(_GLIBCXX_RELEASE) && _GLIBCXX_RELEASE <= 14)
445 or Common::IAnyOf<remove_cvref_t<T>, std::filesystem::path>
446#endif
447 or is_enum_v<remove_cvref_t<T>> or Common::IOptional<remove_cvref_t<T>> or Common::IVariant<remove_cvref_t<T>> or
448 same_as<T, std::chrono::time_point<chrono::steady_clock, chrono::duration<double>>> or
449 Common::IAnyOf<remove_cvref_t<T>, exception_ptr, type_index> or derived_from<T, exception> or Common::ISharedPtr<T>);
450#endif /*qCompiler_IUseToStringFormatterForFormatter_Buggy*/
451 ;
452
453}
454
455/**
456 * add ToStringFormatter to the std::formatter object - so all std::format (and Stroika Format, and _f etc) format calls will
457 * apply ToString() as appropriate.
458 *
459 * And a few static_asserts to verify this is working as expected.
460 *
461 * This should allow all the formattable features of up to C++26 - to work on compilers with older settings (such as C++20, or c++23)
462 * where possible (like cannot format stacktrace if it its impl doesn't exist, but can always format filesystem::path - just using Stroika
463 * formatter instead of std-c++ formatter).
464 */
465template <Stroika::Foundation::Characters::Private_::IUseToStringFormatterForFormatter_ T>
466struct qStroika_Foundation_Characters_FMT_PREFIX_::formatter<T, wchar_t> : Stroika::Foundation::Characters::ToStringFormatter<T> {};
467template <Stroika::Foundation::Characters::Private_::IUseToStringFormatterForFormatter_ T>
468struct qStroika_Foundation_Characters_FMT_PREFIX_::formatter<T, char> : Stroika::Foundation::Characters::ToStringFormatterASCII<T> {};
469
470#if qCompilerAndStdLib_StdFmtOfPath_Buggy
471template <>
472struct qStroika_Foundation_Characters_FMT_PREFIX_::formatter<std::filesystem::path, wchar_t>
473 : Stroika::Foundation::Characters::ToStringFormatter<std::filesystem::path> {};
474template <>
475struct qStroika_Foundation_Characters_FMT_PREFIX_::formatter<std::filesystem::path, char>
476 : Stroika::Foundation::Characters::ToStringFormatterASCII<std::filesystem::path> {};
477#endif
478
479/*
480 * If any of these static_asserts trigger, it means you are using a newer compiler I don't have
481 * proper IUseToStringFormatterForFormatter_ or IStdFormatterPredefinedFor_ settings for. Adjust those settings above so these tests pass.
482 * (or if qCompiler_IUseToStringFormatterForFormatter_Buggy - clang++ - then see IUseToStringFormatterForFormatter_ directly)
483 */
484static_assert (Stroika::Foundation::Common::StdCompat::formattable<std::exception_ptr, wchar_t>);
485static_assert (Stroika::Foundation::Common::StdCompat::formattable<std::filesystem::path, wchar_t>);
486static_assert (Stroika::Foundation::Common::StdCompat::formattable<std::optional<int>, wchar_t>);
487static_assert (Stroika::Foundation::Common::StdCompat::formattable<std::shared_ptr<int>, wchar_t>); // but not unique_ptr cuz not regular, even though supported by ToString()
488static_assert (Stroika::Foundation::Common::StdCompat::formattable<std::pair<int, char>, wchar_t>);
489static_assert (Stroika::Foundation::Common::StdCompat::formattable<std::thread::id, wchar_t>);
490static_assert (Stroika::Foundation::Common::StdCompat::formattable<std::type_index, wchar_t>); // note not type_info (result of typeid) - because formattable requires copyable, and type_info not copyable
491#if !qCompilerAndStdLib_FormatThreadId_Buggy
492static_assert (Stroika::Foundation::Common::StdCompat::formattable<std::thread::id, wchar_t>);
493#endif
494#if qCompilerAndStdLib_formattable_of_tuple_Buggy
495static_assert (Stroika::Foundation::Common::ITuple<std::remove_cvref_t<std::tuple<int>>>);
496#else
497static_assert (Stroika::Foundation::Common::StdCompat::formattable<std::tuple<int>, wchar_t>);
498#endif
499// true, but don't #include just for this
500//static_assert (Stroika::Foundation::Common::StdCompat::formattable<Time::TimePointInSeconds, wchar_t>);
501//static_assert (Stroika::Foundation::Common<Stroika::Foundation::IO::Network::URI, wchar_t>);
502
503/*
504 ********************************************************************************
505 ***************************** Implementation Details ***************************
506 ********************************************************************************
507 */
508
509#include "ToString.inl"
510
511#endif /*_Stroika_Foundation_Characters_ToString_h_*/
Stroika::Foundation::Characters::String
String is like std::u32string, except it is much easier to use, often much more space efficient,...
Definition String.h:201
Stroika::Foundation::Characters::String::AsNarrowSDKString
nonvirtual string AsNarrowSDKString() const
Definition String.inl:836
Stroika::Foundation::Characters::IToString
Check if legal to call Characters::ToString(T)...
Definition ToString.h:120
Stroika::Foundation::Characters::Private_::IStdFormatterPredefinedFor_
IStdFormatterPredefinedFor_<T> = what formattable<T,wchar_t> WOULD have returned if it could be evalu...
Definition ToString.h:219
Stroika::Foundation::Characters::Private_::IUseToStringFormatterForFormatter_
roughly !formattable<T> and IToString<T> ; but cannot do this cuz then formattable<T> would change me...
Definition ToString.h:412
Stroika::Foundation::Common::IAnyOf
concept - trivial shorthand for variadic same_as A or same_as B, or ...
Definition Concepts.h:120
Stroika::Foundation::Common::IPair
return true iff argument type T, is std::pair<a,b> for some a/b types
Definition Concepts.h:180
Stroika::Foundation::Common::ISharedPtr
return true iff argument type T, is std::shared_ptr<A> for some A types
Definition Concepts.h:196
Stroika::Foundation::Common::ITuple
Concept ITuple<T> check if T is a tuple.
Definition Concepts.h:225
Stroika::Foundation::Common::IVariant
detect if T is a std::variant<> type.
Definition Concepts.h:234
Stroika::Foundation::Characters::UnoverloadedToString
String UnoverloadedToString(const T &t)
same as ToString()/1 - but without the potentially confusing multi-arg overloads (confused some templ...
Definition ToString.inl:476
Stroika::Foundation::Characters::ToString
String ToString(T &&t, ARGS... args)
Return a debug-friendly, display version of the argument: not guaranteed parsable or usable except fo...
Definition ToString.inl:465
std
STL namespace.