Fabcoin Core  0.16.2
P2P Digital Currency
tinyformat.h
Go to the documentation of this file.
1 // tinyformat.h
2 // Copyright (C) 2011, Chris Foster [chris42f (at) gmail (d0t) com]
3 //
4 // Boost Software License - Version 1.0
5 //
6 // Permission is hereby granted, free of charge, to any person or organization
7 // obtaining a copy of the software and accompanying documentation covered by
8 // this license (the "Software") to use, reproduce, display, distribute,
9 // execute, and transmit the Software, and to prepare derivative works of the
10 // Software, and to permit third-parties to whom the Software is furnished to
11 // do so, all subject to the following:
12 //
13 // The copyright notices in the Software and this entire statement, including
14 // the above license grant, this restriction and the following disclaimer,
15 // must be included in all copies of the Software, in whole or in part, and
16 // all derivative works of the Software, unless such copies or derivative
17 // works are solely in the form of machine-executable object code generated by
18 // a source language processor.
19 //
20 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
21 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
22 // FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
23 // SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
24 // FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
25 // ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
26 // DEALINGS IN THE SOFTWARE.
27 
28 //------------------------------------------------------------------------------
29 // Tinyformat: A minimal type safe printf replacement
30 //
31 // tinyformat.h is a type safe printf replacement library in a single C++
32 // header file. Design goals include:
33 //
34 // * Type safety and extensibility for user defined types.
35 // * C99 printf() compatibility, to the extent possible using std::ostream
36 // * Simplicity and minimalism. A single header file to include and distribute
37 // with your projects.
38 // * Augment rather than replace the standard stream formatting mechanism
39 // * C++98 support, with optional C++11 niceties
40 //
41 //
42 // Main interface example usage
43 // ----------------------------
44 //
45 // To print a date to std::cout:
46 //
47 // std::string weekday = "Wednesday";
48 // const char* month = "July";
49 // size_t day = 27;
50 // long hour = 14;
51 // int min = 44;
52 //
53 // tfm::printf("%s, %s %d, %.2d:%.2d\n", weekday, month, day, hour, min);
54 //
55 // The strange types here emphasize the type safety of the interface; it is
56 // possible to print a std::string using the "%s" conversion, and a
57 // size_t using the "%d" conversion. A similar result could be achieved
58 // using either of the tfm::format() functions. One prints on a user provided
59 // stream:
60 //
61 // tfm::format(std::cerr, "%s, %s %d, %.2d:%.2d\n",
62 // weekday, month, day, hour, min);
63 //
64 // The other returns a std::string:
65 //
66 // std::string date = tfm::format("%s, %s %d, %.2d:%.2d\n",
67 // weekday, month, day, hour, min);
68 // std::cout << date;
69 //
70 // These are the three primary interface functions. There is also a
71 // convenience function printfln() which appends a newline to the usual result
72 // of printf() for super simple logging.
73 //
74 //
75 // User defined format functions
76 // -----------------------------
77 //
78 // Simulating variadic templates in C++98 is pretty painful since it requires
79 // writing out the same function for each desired number of arguments. To make
80 // this bearable tinyformat comes with a set of macros which are used
81 // internally to generate the API, but which may also be used in user code.
82 //
83 // The three macros TINYFORMAT_ARGTYPES(n), TINYFORMAT_VARARGS(n) and
84 // TINYFORMAT_PASSARGS(n) will generate a list of n argument types,
85 // type/name pairs and argument names respectively when called with an integer
86 // n between 1 and 16. We can use these to define a macro which generates the
87 // desired user defined function with n arguments. To generate all 16 user
88 // defined function bodies, use the macro TINYFORMAT_FOREACH_ARGNUM. For an
89 // example, see the implementation of printf() at the end of the source file.
90 //
91 // Sometimes it's useful to be able to pass a list of format arguments through
92 // to a non-template function. The FormatList class is provided as a way to do
93 // this by storing the argument list in a type-opaque way. Continuing the
94 // example from above, we construct a FormatList using makeFormatList():
95 //
96 // FormatListRef formatList = tfm::makeFormatList(weekday, month, day, hour, min);
97 //
98 // The format list can now be passed into any non-template function and used
99 // via a call to the vformat() function:
100 //
101 // tfm::vformat(std::cout, "%s, %s %d, %.2d:%.2d\n", formatList);
102 //
103 //
104 // Additional API information
105 // --------------------------
106 //
107 // Error handling: Define TINYFORMAT_ERROR to customize the error handling for
108 // format strings which are unsupported or have the wrong number of format
109 // specifiers (calls assert() by default).
110 //
111 // User defined types: Uses operator<< for user defined types by default.
112 // Overload formatValue() for more control.
113 
114 
115 #ifndef TINYFORMAT_H_INCLUDED
116 #define TINYFORMAT_H_INCLUDED
117 
118 namespace tinyformat {}
119 //------------------------------------------------------------------------------
120 // Config section. Customize to your liking!
121 
122 // Namespace alias to encourage brevity
123 namespace tfm = tinyformat;
124 
125 // Error handling; calls assert() by default.
126 #define TINYFORMAT_ERROR(reasonString) throw tinyformat::format_error(reasonString)
127 
128 // Define for C++11 variadic templates which make the code shorter & more
129 // general. If you don't define this, C++11 support is autodetected below.
130 #define TINYFORMAT_USE_VARIADIC_TEMPLATES
131 
132 
133 //------------------------------------------------------------------------------
134 // Implementation details.
135 #include <algorithm>
136 #include <cassert>
137 #include <iostream>
138 #include <sstream>
139 #include <stdexcept>
140 
141 #ifndef TINYFORMAT_ERROR
142 # define TINYFORMAT_ERROR(reason) assert(0 && reason)
143 #endif
144 
145 #if !defined(TINYFORMAT_USE_VARIADIC_TEMPLATES) && !defined(TINYFORMAT_NO_VARIADIC_TEMPLATES)
146 # ifdef __GXX_EXPERIMENTAL_CXX0X__
147 # define TINYFORMAT_USE_VARIADIC_TEMPLATES
148 # endif
149 #endif
150 
151 #if defined(__GLIBCXX__) && __GLIBCXX__ < 20080201
152 // std::showpos is broken on old libstdc++ as provided with OSX. See
153 // http://gcc.gnu.org/ml/libstdc++/2007-11/msg00075.html
154 # define TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND
155 #endif
156 
157 #ifdef __APPLE__
158 // Workaround OSX linker warning: xcode uses different default symbol
159 // visibilities for static libs vs executables (see issue #25)
160 # define TINYFORMAT_HIDDEN __attribute__((visibility("hidden")))
161 #else
162 # define TINYFORMAT_HIDDEN
163 #endif
164 
165 namespace tinyformat {
166 
167 class format_error: public std::runtime_error
168 {
169 public:
170  format_error(const std::string &what): std::runtime_error(what) {
171  }
172 };
173 
174 //------------------------------------------------------------------------------
175 namespace detail {
176 
177 // Test whether type T1 is convertible to type T2
178 template <typename T1, typename T2>
180 {
181  private:
182  // two types of different size
183  struct fail { char dummy[2]; };
184  struct succeed { char dummy; };
185  // Try to convert a T1 to a T2 by plugging into tryConvert
186  static fail tryConvert(...);
187  static succeed tryConvert(const T2&);
188  static const T1& makeT1();
189  public:
190 # ifdef _MSC_VER
191  // Disable spurious loss of precision warnings in tryConvert(makeT1())
192 # pragma warning(push)
193 # pragma warning(disable:4244)
194 # pragma warning(disable:4267)
195 # endif
196  // Standard trick: the (...) version of tryConvert will be chosen from
197  // the overload set only if the version taking a T2 doesn't match.
198  // Then we compare the sizes of the return types to check which
199  // function matched. Very neat, in a disgusting kind of way :)
200  static const bool value =
201  sizeof(tryConvert(makeT1())) == sizeof(succeed);
202 # ifdef _MSC_VER
203 # pragma warning(pop)
204 # endif
205 };
206 
207 
208 // Detect when a type is not a wchar_t string
209 template<typename T> struct is_wchar { typedef int tinyformat_wchar_is_not_supported; };
210 template<> struct is_wchar<wchar_t*> {};
211 template<> struct is_wchar<const wchar_t*> {};
212 template<int n> struct is_wchar<const wchar_t[n]> {};
213 template<int n> struct is_wchar<wchar_t[n]> {};
214 
215 
216 // Format the value by casting to type fmtT. This default implementation
217 // should never be called.
218 template<typename T, typename fmtT, bool convertible = is_convertible<T, fmtT>::value>
220 {
221  static void invoke(std::ostream& /*out*/, const T& /*value*/) { assert(0); }
222 };
223 // Specialized version for types that can actually be converted to fmtT, as
224 // indicated by the "convertible" template parameter.
225 template<typename T, typename fmtT>
226 struct formatValueAsType<T,fmtT,true>
227 {
228  static void invoke(std::ostream& out, const T& value)
229  { out << static_cast<fmtT>(value); }
230 };
231 
232 #ifdef TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND
233 template<typename T, bool convertible = is_convertible<T, int>::value>
234 struct formatZeroIntegerWorkaround
235 {
236  static bool invoke(std::ostream& , const T& ) { return false; }
237 };
238 template<typename T>
239 struct formatZeroIntegerWorkaround<T,true>
240 {
241  static bool invoke(std::ostream& out, const T& value)
242  {
243  if (static_cast<int>(value) == 0 && out.flags() & std::ios::showpos)
244  {
245  out << "+0";
246  return true;
247  }
248  return false;
249  }
250 };
251 #endif // TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND
252 
253 // Convert an arbitrary type to integer. The version with convertible=false
254 // throws an error.
255 template<typename T, bool convertible = is_convertible<T,int>::value>
257 {
258  static int invoke(const T& /*value*/)
259  {
260  TINYFORMAT_ERROR("tinyformat: Cannot convert from argument type to "
261  "integer for use as variable width or precision");
262  return 0;
263  }
264 };
265 // Specialization for convertToInt when conversion is possible
266 template<typename T>
267 struct convertToInt<T,true>
268 {
269  static int invoke(const T& value) { return static_cast<int>(value); }
270 };
271 
272 // Format at most ntrunc characters to the given stream.
273 template<typename T>
274 inline void formatTruncated(std::ostream& out, const T& value, int ntrunc)
275 {
276  std::ostringstream tmp;
277  tmp << value;
278  std::string result = tmp.str();
279  out.write(result.c_str(), (std::min)(ntrunc, static_cast<int>(result.size())));
280 }
281 #define TINYFORMAT_DEFINE_FORMAT_TRUNCATED_CSTR(type) \
282 inline void formatTruncated(std::ostream& out, type* value, int ntrunc) \
283 { \
284  std::streamsize len = 0; \
285  while(len < ntrunc && value[len] != 0) \
286  ++len; \
287  out.write(value, len); \
288 }
289 // Overload for const char* and char*. Could overload for signed & unsigned
290 // char too, but these are technically unneeded for printf compatibility.
293 #undef TINYFORMAT_DEFINE_FORMAT_TRUNCATED_CSTR
294 
295 } // namespace detail
296 
297 
298 //------------------------------------------------------------------------------
299 // Variable formatting functions. May be overridden for user-defined types if
300 // desired.
301 
302 
314 template<typename T>
315 inline void formatValue(std::ostream& out, const char* /*fmtBegin*/,
316  const char* fmtEnd, int ntrunc, const T& value)
317 {
318 #ifndef TINYFORMAT_ALLOW_WCHAR_STRINGS
319  // Since we don't support printing of wchar_t using "%ls", make it fail at
320  // compile time in preference to printing as a void* at runtime.
322  (void) DummyType(); // avoid unused type warning with gcc-4.8
323 #endif
324  // The mess here is to support the %c and %p conversions: if these
325  // conversions are active we try to convert the type to a char or const
326  // void* respectively and format that instead of the value itself. For the
327  // %p conversion it's important to avoid dereferencing the pointer, which
328  // could otherwise lead to a crash when printing a dangling (const char*).
329  const bool canConvertToChar = detail::is_convertible<T,char>::value;
330  const bool canConvertToVoidPtr = detail::is_convertible<T, const void*>::value;
331  if(canConvertToChar && *(fmtEnd-1) == 'c')
333  else if(canConvertToVoidPtr && *(fmtEnd-1) == 'p')
335 #ifdef TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND
336  else if(detail::formatZeroIntegerWorkaround<T>::invoke(out, value)) ;
337 #endif
338  else if(ntrunc >= 0)
339  {
340  // Take care not to overread C strings in truncating conversions like
341  // "%.4s" where at most 4 characters may be read.
342  detail::formatTruncated(out, value, ntrunc);
343  }
344  else
345  out << value;
346 }
347 
348 
349 // Overloaded version for char types to support printing as an integer
350 #define TINYFORMAT_DEFINE_FORMATVALUE_CHAR(charType) \
351 inline void formatValue(std::ostream& out, const char* /*fmtBegin*/, \
352  const char* fmtEnd, int , charType value) \
353 { \
354  switch(*(fmtEnd-1)) \
355  { \
356  case 'u': case 'd': case 'i': case 'o': case 'X': case 'x': \
357  out << static_cast<int>(value); break; \
358  default: \
359  out << value; break; \
360  } \
361 }
362 // per 3.9.1: char, signed char and unsigned char are all distinct types
366 #undef TINYFORMAT_DEFINE_FORMATVALUE_CHAR
367 
368 
369 //------------------------------------------------------------------------------
370 // Tools for emulating variadic templates in C++98. The basic idea here is
371 // stolen from the boost preprocessor metaprogramming library and cut down to
372 // be just general enough for what we need.
373 
374 #define TINYFORMAT_ARGTYPES(n) TINYFORMAT_ARGTYPES_ ## n
375 #define TINYFORMAT_VARARGS(n) TINYFORMAT_VARARGS_ ## n
376 #define TINYFORMAT_PASSARGS(n) TINYFORMAT_PASSARGS_ ## n
377 #define TINYFORMAT_PASSARGS_TAIL(n) TINYFORMAT_PASSARGS_TAIL_ ## n
378 
379 // To keep it as transparent as possible, the macros below have been generated
380 // using python via the excellent cog.py code generation script. This avoids
381 // the need for a bunch of complex (but more general) preprocessor tricks as
382 // used in boost.preprocessor.
383 //
384 // To rerun the code generation in place, use `cog.py -r tinyformat.h`
385 // (see http://nedbatchelder.com/code/cog). Alternatively you can just create
386 // extra versions by hand.
387 
388 /*[[[cog
389 maxParams = 16
390 
391 def makeCommaSepLists(lineTemplate, elemTemplate, startInd=1):
392  for j in range(startInd,maxParams+1):
393  list = ', '.join([elemTemplate % {'i':i} for i in range(startInd,j+1)])
394  cog.outl(lineTemplate % {'j':j, 'list':list})
395 
396 makeCommaSepLists('#define TINYFORMAT_ARGTYPES_%(j)d %(list)s',
397  'class T%(i)d')
398 
399 cog.outl()
400 makeCommaSepLists('#define TINYFORMAT_VARARGS_%(j)d %(list)s',
401  'const T%(i)d& v%(i)d')
402 
403 cog.outl()
404 makeCommaSepLists('#define TINYFORMAT_PASSARGS_%(j)d %(list)s', 'v%(i)d')
405 
406 cog.outl()
407 cog.outl('#define TINYFORMAT_PASSARGS_TAIL_1')
408 makeCommaSepLists('#define TINYFORMAT_PASSARGS_TAIL_%(j)d , %(list)s',
409  'v%(i)d', startInd = 2)
410 
411 cog.outl()
412 cog.outl('#define TINYFORMAT_FOREACH_ARGNUM(m) \\\n ' +
413  ' '.join(['m(%d)' % (j,) for j in range(1,maxParams+1)]))
414 ]]]*/
415 #define TINYFORMAT_ARGTYPES_1 class T1
416 #define TINYFORMAT_ARGTYPES_2 class T1, class T2
417 #define TINYFORMAT_ARGTYPES_3 class T1, class T2, class T3
418 #define TINYFORMAT_ARGTYPES_4 class T1, class T2, class T3, class T4
419 #define TINYFORMAT_ARGTYPES_5 class T1, class T2, class T3, class T4, class T5
420 #define TINYFORMAT_ARGTYPES_6 class T1, class T2, class T3, class T4, class T5, class T6
421 #define TINYFORMAT_ARGTYPES_7 class T1, class T2, class T3, class T4, class T5, class T6, class T7
422 #define TINYFORMAT_ARGTYPES_8 class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8
423 #define TINYFORMAT_ARGTYPES_9 class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9
424 #define TINYFORMAT_ARGTYPES_10 class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10
425 #define TINYFORMAT_ARGTYPES_11 class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11
426 #define TINYFORMAT_ARGTYPES_12 class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12
427 #define TINYFORMAT_ARGTYPES_13 class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13
428 #define TINYFORMAT_ARGTYPES_14 class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14
429 #define TINYFORMAT_ARGTYPES_15 class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15
430 #define TINYFORMAT_ARGTYPES_16 class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16
431 
432 #define TINYFORMAT_VARARGS_1 const T1& v1
433 #define TINYFORMAT_VARARGS_2 const T1& v1, const T2& v2
434 #define TINYFORMAT_VARARGS_3 const T1& v1, const T2& v2, const T3& v3
435 #define TINYFORMAT_VARARGS_4 const T1& v1, const T2& v2, const T3& v3, const T4& v4
436 #define TINYFORMAT_VARARGS_5 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5
437 #define TINYFORMAT_VARARGS_6 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6
438 #define TINYFORMAT_VARARGS_7 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7
439 #define TINYFORMAT_VARARGS_8 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8
440 #define TINYFORMAT_VARARGS_9 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8, const T9& v9
441 #define TINYFORMAT_VARARGS_10 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8, const T9& v9, const T10& v10
442 #define TINYFORMAT_VARARGS_11 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8, const T9& v9, const T10& v10, const T11& v11
443 #define TINYFORMAT_VARARGS_12 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8, const T9& v9, const T10& v10, const T11& v11, const T12& v12
444 #define TINYFORMAT_VARARGS_13 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8, const T9& v9, const T10& v10, const T11& v11, const T12& v12, const T13& v13
445 #define TINYFORMAT_VARARGS_14 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8, const T9& v9, const T10& v10, const T11& v11, const T12& v12, const T13& v13, const T14& v14
446 #define TINYFORMAT_VARARGS_15 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8, const T9& v9, const T10& v10, const T11& v11, const T12& v12, const T13& v13, const T14& v14, const T15& v15
447 #define TINYFORMAT_VARARGS_16 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8, const T9& v9, const T10& v10, const T11& v11, const T12& v12, const T13& v13, const T14& v14, const T15& v15, const T16& v16
448 
449 #define TINYFORMAT_PASSARGS_1 v1
450 #define TINYFORMAT_PASSARGS_2 v1, v2
451 #define TINYFORMAT_PASSARGS_3 v1, v2, v3
452 #define TINYFORMAT_PASSARGS_4 v1, v2, v3, v4
453 #define TINYFORMAT_PASSARGS_5 v1, v2, v3, v4, v5
454 #define TINYFORMAT_PASSARGS_6 v1, v2, v3, v4, v5, v6
455 #define TINYFORMAT_PASSARGS_7 v1, v2, v3, v4, v5, v6, v7
456 #define TINYFORMAT_PASSARGS_8 v1, v2, v3, v4, v5, v6, v7, v8
457 #define TINYFORMAT_PASSARGS_9 v1, v2, v3, v4, v5, v6, v7, v8, v9
458 #define TINYFORMAT_PASSARGS_10 v1, v2, v3, v4, v5, v6, v7, v8, v9, v10
459 #define TINYFORMAT_PASSARGS_11 v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11
460 #define TINYFORMAT_PASSARGS_12 v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12
461 #define TINYFORMAT_PASSARGS_13 v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13
462 #define TINYFORMAT_PASSARGS_14 v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14
463 #define TINYFORMAT_PASSARGS_15 v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15
464 #define TINYFORMAT_PASSARGS_16 v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16
465 
466 #define TINYFORMAT_PASSARGS_TAIL_1
467 #define TINYFORMAT_PASSARGS_TAIL_2 , v2
468 #define TINYFORMAT_PASSARGS_TAIL_3 , v2, v3
469 #define TINYFORMAT_PASSARGS_TAIL_4 , v2, v3, v4
470 #define TINYFORMAT_PASSARGS_TAIL_5 , v2, v3, v4, v5
471 #define TINYFORMAT_PASSARGS_TAIL_6 , v2, v3, v4, v5, v6
472 #define TINYFORMAT_PASSARGS_TAIL_7 , v2, v3, v4, v5, v6, v7
473 #define TINYFORMAT_PASSARGS_TAIL_8 , v2, v3, v4, v5, v6, v7, v8
474 #define TINYFORMAT_PASSARGS_TAIL_9 , v2, v3, v4, v5, v6, v7, v8, v9
475 #define TINYFORMAT_PASSARGS_TAIL_10 , v2, v3, v4, v5, v6, v7, v8, v9, v10
476 #define TINYFORMAT_PASSARGS_TAIL_11 , v2, v3, v4, v5, v6, v7, v8, v9, v10, v11
477 #define TINYFORMAT_PASSARGS_TAIL_12 , v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12
478 #define TINYFORMAT_PASSARGS_TAIL_13 , v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13
479 #define TINYFORMAT_PASSARGS_TAIL_14 , v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14
480 #define TINYFORMAT_PASSARGS_TAIL_15 , v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15
481 #define TINYFORMAT_PASSARGS_TAIL_16 , v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16
482 
483 #define TINYFORMAT_FOREACH_ARGNUM(m) \
484  m(1) m(2) m(3) m(4) m(5) m(6) m(7) m(8) m(9) m(10) m(11) m(12) m(13) m(14) m(15) m(16)
485 //[[[end]]]
486 
487 
488 
489 namespace detail {
490 
491 // Type-opaque holder for an argument to format(), with associated actions on
492 // the type held as explicit function pointers. This allows FormatArg's for
493 // each argument to be allocated as a homogenous array inside FormatList
494 // whereas a naive implementation based on inheritance does not.
496 {
497  public:
499 
500  template<typename T>
501  FormatArg(const T& value)
502  : m_value(static_cast<const void*>(&value)),
503  m_formatImpl(&formatImpl<T>),
504  m_toIntImpl(&toIntImpl<T>)
505  { }
506 
507  void format(std::ostream& out, const char* fmtBegin,
508  const char* fmtEnd, int ntrunc) const
509  {
510  m_formatImpl(out, fmtBegin, fmtEnd, ntrunc, m_value);
511  }
512 
513  int toInt() const
514  {
515  return m_toIntImpl(m_value);
516  }
517 
518  private:
519  template<typename T>
520  TINYFORMAT_HIDDEN static void formatImpl(std::ostream& out, const char* fmtBegin,
521  const char* fmtEnd, int ntrunc, const void* value)
522  {
523  formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast<const T*>(value));
524  }
525 
526  template<typename T>
527  TINYFORMAT_HIDDEN static int toIntImpl(const void* value)
528  {
529  return convertToInt<T>::invoke(*static_cast<const T*>(value));
530  }
531 
532  const void* m_value;
533  void (*m_formatImpl)(std::ostream& out, const char* fmtBegin,
534  const char* fmtEnd, int ntrunc, const void* value);
535  int (*m_toIntImpl)(const void* value);
536 };
537 
538 
539 // Parse and return an integer from the string c, as atoi()
540 // On return, c is set to one past the end of the integer.
541 inline int parseIntAndAdvance(const char*& c)
542 {
543  int i = 0;
544  for(;*c >= '0' && *c <= '9'; ++c)
545  i = 10*i + (*c - '0');
546  return i;
547 }
548 
549 // Print literal part of format string and return next format spec
550 // position.
551 //
552 // Skips over any occurrences of '%%', printing a literal '%' to the
553 // output. The position of the first % character of the next
554 // nontrivial format spec is returned, or the end of string.
555 inline const char* printFormatStringLiteral(std::ostream& out, const char* fmt)
556 {
557  const char* c = fmt;
558  for(;; ++c)
559  {
560  switch(*c)
561  {
562  case '\0':
563  out.write(fmt, c - fmt);
564  return c;
565  case '%':
566  out.write(fmt, c - fmt);
567  if(*(c+1) != '%')
568  return c;
569  // for "%%", tack trailing % onto next literal section.
570  fmt = ++c;
571  break;
572  default:
573  break;
574  }
575  }
576 }
577 
578 
579 // Parse a format string and set the stream state accordingly.
580 //
581 // The format mini-language recognized here is meant to be the one from C99,
582 // with the form "%[flags][width][.precision][length]type".
583 //
584 // Formatting options which can't be natively represented using the ostream
585 // state are returned in spacePadPositive (for space padded positive numbers)
586 // and ntrunc (for truncating conversions). argIndex is incremented if
587 // necessary to pull out variable width and precision . The function returns a
588 // pointer to the character after the end of the current format spec.
589 inline const char* streamStateFromFormat(std::ostream& out, bool& spacePadPositive,
590  int& ntrunc, const char* fmtStart,
591  const detail::FormatArg* formatters,
592  int& argIndex, int numFormatters)
593 {
594  if(*fmtStart != '%')
595  {
596  TINYFORMAT_ERROR("tinyformat: Not enough conversion specifiers in format string");
597  return fmtStart;
598  }
599  // Reset stream state to defaults.
600  out.width(0);
601  out.precision(6);
602  out.fill(' ');
603  // Reset most flags; ignore irrelevant unitbuf & skipws.
604  out.unsetf(std::ios::adjustfield | std::ios::basefield |
605  std::ios::floatfield | std::ios::showbase | std::ios::boolalpha |
606  std::ios::showpoint | std::ios::showpos | std::ios::uppercase);
607  bool precisionSet = false;
608  bool widthSet = false;
609  int widthExtra = 0;
610  const char* c = fmtStart + 1;
611  // 1) Parse flags
612  for(;; ++c)
613  {
614  switch(*c)
615  {
616  case '#':
617  out.setf(std::ios::showpoint | std::ios::showbase);
618  continue;
619  case '0':
620  // overridden by left alignment ('-' flag)
621  if(!(out.flags() & std::ios::left))
622  {
623  // Use internal padding so that numeric values are
624  // formatted correctly, eg -00010 rather than 000-10
625  out.fill('0');
626  out.setf(std::ios::internal, std::ios::adjustfield);
627  }
628  continue;
629  case '-':
630  out.fill(' ');
631  out.setf(std::ios::left, std::ios::adjustfield);
632  continue;
633  case ' ':
634  // overridden by show positive sign, '+' flag.
635  if(!(out.flags() & std::ios::showpos))
636  spacePadPositive = true;
637  continue;
638  case '+':
639  out.setf(std::ios::showpos);
640  spacePadPositive = false;
641  widthExtra = 1;
642  continue;
643  default:
644  break;
645  }
646  break;
647  }
648  // 2) Parse width
649  if(*c >= '0' && *c <= '9')
650  {
651  widthSet = true;
652  out.width(parseIntAndAdvance(c));
653  }
654  if(*c == '*')
655  {
656  widthSet = true;
657  int width = 0;
658  if(argIndex < numFormatters)
659  width = formatters[argIndex++].toInt();
660  else
661  TINYFORMAT_ERROR("tinyformat: Not enough arguments to read variable width");
662  if(width < 0)
663  {
664  // negative widths correspond to '-' flag set
665  out.fill(' ');
666  out.setf(std::ios::left, std::ios::adjustfield);
667  width = -width;
668  }
669  out.width(width);
670  ++c;
671  }
672  // 3) Parse precision
673  if(*c == '.')
674  {
675  ++c;
676  int precision = 0;
677  if(*c == '*')
678  {
679  ++c;
680  if(argIndex < numFormatters)
681  precision = formatters[argIndex++].toInt();
682  else
683  TINYFORMAT_ERROR("tinyformat: Not enough arguments to read variable precision");
684  }
685  else
686  {
687  if(*c >= '0' && *c <= '9')
688  precision = parseIntAndAdvance(c);
689  else if(*c == '-') // negative precisions ignored, treated as zero.
690  parseIntAndAdvance(++c);
691  }
692  out.precision(precision);
693  precisionSet = true;
694  }
695  // 4) Ignore any C99 length modifier
696  while(*c == 'l' || *c == 'h' || *c == 'L' ||
697  *c == 'j' || *c == 'z' || *c == 't')
698  ++c;
699  // 5) We're up to the conversion specifier character.
700  // Set stream flags based on conversion specifier (thanks to the
701  // boost::format class for forging the way here).
702  bool intConversion = false;
703  switch(*c)
704  {
705  case 'u': case 'd': case 'i':
706  out.setf(std::ios::dec, std::ios::basefield);
707  intConversion = true;
708  break;
709  case 'o':
710  out.setf(std::ios::oct, std::ios::basefield);
711  intConversion = true;
712  break;
713  case 'X':
714  out.setf(std::ios::uppercase);
715  case 'x': case 'p':
716  out.setf(std::ios::hex, std::ios::basefield);
717  intConversion = true;
718  break;
719  case 'E':
720  out.setf(std::ios::uppercase);
721  case 'e':
722  out.setf(std::ios::scientific, std::ios::floatfield);
723  out.setf(std::ios::dec, std::ios::basefield);
724  break;
725  case 'F':
726  out.setf(std::ios::uppercase);
727  case 'f':
728  out.setf(std::ios::fixed, std::ios::floatfield);
729  break;
730  case 'G':
731  out.setf(std::ios::uppercase);
732  case 'g':
733  out.setf(std::ios::dec, std::ios::basefield);
734  // As in boost::format, let stream decide float format.
735  out.flags(out.flags() & ~std::ios::floatfield);
736  break;
737  case 'a': case 'A':
738  TINYFORMAT_ERROR("tinyformat: the %a and %A conversion specs "
739  "are not supported");
740  break;
741  case 'c':
742  // Handled as special case inside formatValue()
743  break;
744  case 's':
745  if(precisionSet)
746  ntrunc = static_cast<int>(out.precision());
747  // Make %s print booleans as "true" and "false"
748  out.setf(std::ios::boolalpha);
749  break;
750  case 'n':
751  // Not supported - will cause problems!
752  TINYFORMAT_ERROR("tinyformat: %n conversion spec not supported");
753  break;
754  case '\0':
755  TINYFORMAT_ERROR("tinyformat: Conversion spec incorrectly "
756  "terminated by end of string");
757  return c;
758  default:
759  break;
760  }
761  if(intConversion && precisionSet && !widthSet)
762  {
763  // "precision" for integers gives the minimum number of digits (to be
764  // padded with zeros on the left). This isn't really supported by the
765  // iostreams, but we can approximately simulate it with the width if
766  // the width isn't otherwise used.
767  out.width(out.precision() + widthExtra);
768  out.setf(std::ios::internal, std::ios::adjustfield);
769  out.fill('0');
770  }
771  return c+1;
772 }
773 
774 
775 //------------------------------------------------------------------------------
776 inline void formatImpl(std::ostream& out, const char* fmt,
777  const detail::FormatArg* formatters,
778  int numFormatters)
779 {
780  // Saved stream state
781  std::streamsize origWidth = out.width();
782  std::streamsize origPrecision = out.precision();
783  std::ios::fmtflags origFlags = out.flags();
784  char origFill = out.fill();
785 
786  for (int argIndex = 0; argIndex < numFormatters; ++argIndex)
787  {
788  // Parse the format string
789  fmt = printFormatStringLiteral(out, fmt);
790  bool spacePadPositive = false;
791  int ntrunc = -1;
792  const char* fmtEnd = streamStateFromFormat(out, spacePadPositive, ntrunc, fmt,
793  formatters, argIndex, numFormatters);
794  if (argIndex >= numFormatters)
795  {
796  // Check args remain after reading any variable width/precision
797  TINYFORMAT_ERROR("tinyformat: Not enough format arguments");
798  return;
799  }
800  const FormatArg& arg = formatters[argIndex];
801  // Format the arg into the stream.
802  if(!spacePadPositive)
803  arg.format(out, fmt, fmtEnd, ntrunc);
804  else
805  {
806  // The following is a special case with no direct correspondence
807  // between stream formatting and the printf() behaviour. Simulate
808  // it crudely by formatting into a temporary string stream and
809  // munging the resulting string.
810  std::ostringstream tmpStream;
811  tmpStream.copyfmt(out);
812  tmpStream.setf(std::ios::showpos);
813  arg.format(tmpStream, fmt, fmtEnd, ntrunc);
814  std::string result = tmpStream.str(); // allocates... yuck.
815  for(size_t i = 0, iend = result.size(); i < iend; ++i)
816  if(result[i] == '+') result[i] = ' ';
817  out << result;
818  }
819  fmt = fmtEnd;
820  }
821 
822  // Print remaining part of format string.
823  fmt = printFormatStringLiteral(out, fmt);
824  if(*fmt != '\0')
825  TINYFORMAT_ERROR("tinyformat: Too many conversion specifiers in format string");
826 
827  // Restore stream state
828  out.width(origWidth);
829  out.precision(origPrecision);
830  out.flags(origFlags);
831  out.fill(origFill);
832 }
833 
834 } // namespace detail
835 
836 
844 {
845  public:
846  FormatList(detail::FormatArg* formatters, int N)
847  : m_formatters(formatters), m_N(N) { }
848 
849  friend void vformat(std::ostream& out, const char* fmt,
850  const FormatList& list);
851 
852  private:
854  int m_N;
855 };
856 
858 typedef const FormatList& FormatListRef;
859 
860 
861 namespace detail {
862 
863 // Format list subclass with fixed storage to avoid dynamic allocation
864 template<int N>
865 class FormatListN : public FormatList
866 {
867  public:
868 #ifdef TINYFORMAT_USE_VARIADIC_TEMPLATES
869  template<typename... Args>
870  FormatListN(const Args&... args)
871  : FormatList(&m_formatterStore[0], N),
872  m_formatterStore { FormatArg(args)... }
873  { static_assert(sizeof...(args) == N, "Number of args must be N"); }
874 #else // C++98 version
875  void init(int) {}
876 # define TINYFORMAT_MAKE_FORMATLIST_CONSTRUCTOR(n) \
877  \
878  template<TINYFORMAT_ARGTYPES(n)> \
879  FormatListN(TINYFORMAT_VARARGS(n)) \
880  : FormatList(&m_formatterStore[0], n) \
881  { assert(n == N); init(0, TINYFORMAT_PASSARGS(n)); } \
882  \
883  template<TINYFORMAT_ARGTYPES(n)> \
884  void init(int i, TINYFORMAT_VARARGS(n)) \
885  { \
886  m_formatterStore[i] = FormatArg(v1); \
887  init(i+1 TINYFORMAT_PASSARGS_TAIL(n)); \
888  }
889 
890  TINYFORMAT_FOREACH_ARGNUM(TINYFORMAT_MAKE_FORMATLIST_CONSTRUCTOR)
891 # undef TINYFORMAT_MAKE_FORMATLIST_CONSTRUCTOR
892 #endif
893 
894  private:
895  FormatArg m_formatterStore[N];
896 };
897 
898 // Special 0-arg version - MSVC says zero-sized C array in struct is nonstandard
899 template<> class FormatListN<0> : public FormatList
900 {
901  public: FormatListN() : FormatList(0, 0) {}
902 };
903 
904 } // namespace detail
905 
906 
907 //------------------------------------------------------------------------------
908 // Primary API functions
909 
910 #ifdef TINYFORMAT_USE_VARIADIC_TEMPLATES
911 
918 template<typename... Args>
919 detail::FormatListN<sizeof...(Args)> makeFormatList(const Args&... args)
920 {
921  return detail::FormatListN<sizeof...(args)>(args...);
922 }
923 
924 #else // C++98 version
925 
927 {
928  return detail::FormatListN<0>();
929 }
930 #define TINYFORMAT_MAKE_MAKEFORMATLIST(n) \
931 template<TINYFORMAT_ARGTYPES(n)> \
932 detail::FormatListN<n> makeFormatList(TINYFORMAT_VARARGS(n)) \
933 { \
934  return detail::FormatListN<n>(TINYFORMAT_PASSARGS(n)); \
935 }
936 TINYFORMAT_FOREACH_ARGNUM(TINYFORMAT_MAKE_MAKEFORMATLIST)
937 #undef TINYFORMAT_MAKE_MAKEFORMATLIST
938 
939 #endif
940 
945 inline void vformat(std::ostream& out, const char* fmt, FormatListRef list)
946 {
947  detail::formatImpl(out, fmt, list.m_formatters, list.m_N);
948 }
949 
950 
951 #ifdef TINYFORMAT_USE_VARIADIC_TEMPLATES
952 
954 template<typename... Args>
955 void format(std::ostream& out, const char* fmt, const Args&... args)
956 {
957  vformat(out, fmt, makeFormatList(args...));
958 }
959 
962 template<typename... Args>
963 std::string format(const char* fmt, const Args&... args)
964 {
965  std::ostringstream oss;
966  format(oss, fmt, args...);
967  return oss.str();
968 }
969 
971 template<typename... Args>
972 void printf(const char* fmt, const Args&... args)
973 {
974  format(std::cout, fmt, args...);
975 }
976 
977 template<typename... Args>
978 void printfln(const char* fmt, const Args&... args)
979 {
980  format(std::cout, fmt, args...);
981  std::cout << '\n';
982 }
983 
984 #else // C++98 version
985 
986 inline void format(std::ostream& out, const char* fmt)
987 {
988  vformat(out, fmt, makeFormatList());
989 }
990 
991 inline std::string format(const char* fmt)
992 {
993  std::ostringstream oss;
994  format(oss, fmt);
995  return oss.str();
996 }
997 
998 inline void printf(const char* fmt)
999 {
1000  format(std::cout, fmt);
1001 }
1002 
1003 inline void printfln(const char* fmt)
1004 {
1005  format(std::cout, fmt);
1006  std::cout << '\n';
1007 }
1008 
1009 #define TINYFORMAT_MAKE_FORMAT_FUNCS(n) \
1010  \
1011 template<TINYFORMAT_ARGTYPES(n)> \
1012 void format(std::ostream& out, const char* fmt, TINYFORMAT_VARARGS(n)) \
1013 { \
1014  vformat(out, fmt, makeFormatList(TINYFORMAT_PASSARGS(n))); \
1015 } \
1016  \
1017 template<TINYFORMAT_ARGTYPES(n)> \
1018 std::string format(const char* fmt, TINYFORMAT_VARARGS(n)) \
1019 { \
1020  std::ostringstream oss; \
1021  format(oss, fmt, TINYFORMAT_PASSARGS(n)); \
1022  return oss.str(); \
1023 } \
1024  \
1025 template<TINYFORMAT_ARGTYPES(n)> \
1026 void printf(const char* fmt, TINYFORMAT_VARARGS(n)) \
1027 { \
1028  format(std::cout, fmt, TINYFORMAT_PASSARGS(n)); \
1029 } \
1030  \
1031 template<TINYFORMAT_ARGTYPES(n)> \
1032 void printfln(const char* fmt, TINYFORMAT_VARARGS(n)) \
1033 { \
1034  format(std::cout, fmt, TINYFORMAT_PASSARGS(n)); \
1035  std::cout << '\n'; \
1036 }
1037 
1038 TINYFORMAT_FOREACH_ARGNUM(TINYFORMAT_MAKE_FORMAT_FUNCS)
1039 #undef TINYFORMAT_MAKE_FORMAT_FUNCS
1040 
1041 #endif
1042 
1043 // Added for Fabcoin Core
1044 template<typename... Args>
1045 std::string format(const std::string &fmt, const Args&... args)
1046 {
1047  std::ostringstream oss;
1048  format(oss, fmt.c_str(), args...);
1049  return oss.str();
1050 }
1051 
1052 } // namespace tinyformat
1053 
1054 #define strprintf tfm::format
1055 
1056 #endif // TINYFORMAT_H_INCLUDED
#define T1
Definition: integer.cpp:2170
static int invoke(const T &)
Definition: tinyformat.h:258
const FormatList & FormatListRef
Reference to type-opaque format list for passing to vformat()
Definition: tinyformat.h:858
#define T2
Definition: integer.cpp:2171
void printf(const char *fmt, const Args &...args)
Format list of arguments to std::cout, according to the given format string.
Definition: tinyformat.h:972
#define TINYFORMAT_HIDDEN
Definition: tinyformat.h:162
#define T(i, x)
void formatTruncated(std::ostream &out, const T &value, int ntrunc)
Definition: tinyformat.h:274
#define TINYFORMAT_DEFINE_FORMAT_TRUNCATED_CSTR(type)
Definition: tinyformat.h:281
#define c(i)
void format(std::ostream &out, const char *fmt, const Args &...args)
Format list of arguments to the stream according to given format string.
Definition: tinyformat.h:955
std::hash for asio::adress
Definition: Common.h:323
assert(len-trim+(2 *lenIndices)<=WIDTH)
int parseIntAndAdvance(const char *&c)
Definition: tinyformat.h:541
void printfln(const char *fmt, const Args &...args)
Definition: tinyformat.h:978
ExecStats::duration min
Definition: ExecStats.cpp:35
#define TINYFORMAT_DEFINE_FORMATVALUE_CHAR(charType)
Definition: tinyformat.h:350
FormatList(detail::FormatArg *formatters, int N)
Definition: tinyformat.h:846
static TINYFORMAT_HIDDEN void formatImpl(std::ostream &out, const char *fmtBegin, const char *fmtEnd, int ntrunc, const void *value)
Definition: tinyformat.h:520
void formatImpl(std::ostream &out, const char *fmt, const detail::FormatArg *formatters, int numFormatters)
Definition: tinyformat.h:776
const char * printFormatStringLiteral(std::ostream &out, const char *fmt)
Definition: tinyformat.h:555
List of template arguments format(), held in a type-opaque way.
Definition: tinyformat.h:843
static void invoke(std::ostream &out, const T &value)
Definition: tinyformat.h:228
FormatListN(const Args &...args)
Definition: tinyformat.h:870
void format(std::ostream &out, const char *fmtBegin, const char *fmtEnd, int ntrunc) const
Definition: tinyformat.h:507
format_error(const std::string &what)
Definition: tinyformat.h:170
const char * streamStateFromFormat(std::ostream &out, bool &spacePadPositive, int &ntrunc, const char *fmtStart, const detail::FormatArg *formatters, int &argIndex, int numFormatters)
Definition: tinyformat.h:589
static void invoke(std::ostream &, const T &)
Definition: tinyformat.h:221
void vformat(std::ostream &out, const char *fmt, FormatListRef list)
Format list of arguments to the stream according to the given format string.
Definition: tinyformat.h:945
#define TINYFORMAT_ERROR(reasonString)
Definition: tinyformat.h:126
static int invoke(const T &value)
Definition: tinyformat.h:269
*detail::FormatListN< sizeof...(Args)> makeFormatList(const Args &...args)
Make type-agnostic format list from list of template arguments.
Definition: tinyformat.h:919
void formatValue(std::ostream &out, const char *, const char *fmtEnd, int ntrunc, const T &value)
Format a value into a stream, delegating to operator<< by default.
Definition: tinyformat.h:315
#define TINYFORMAT_FOREACH_ARGNUM(m)
Definition: tinyformat.h:483
static TINYFORMAT_HIDDEN int toIntImpl(const void *value)
Definition: tinyformat.h:527
const detail::FormatArg * m_formatters
Definition: tinyformat.h:853