BDE 4.39.x Production Release
Loading...
Searching...
No Matches
bslfmt_format_imp_cpp03.h
Go to the documentation of this file.
1/// @file bslfmt_format_imp_cpp03.h
2///
3/// The content of this file has been pre-processed for Doxygen.
4///
5
6
7// bslfmt_format_imp_cpp03.h -*-C++-*-
8
9// Automatically generated file. **DO NOT EDIT**
10
11#ifndef INCLUDED_BSLFMT_FORMAT_IMP_CPP03
12#define INCLUDED_BSLFMT_FORMAT_IMP_CPP03
13
14/// @defgroup bslfmt_format_imp_cpp03 bslfmt_format_imp_cpp03
15/// @brief Provide C++03 implementation for bslfmt_format_imp.h
16/// @addtogroup bsl
17/// @{
18/// @addtogroup bslfmt
19/// @{
20/// @addtogroup bslfmt_format_imp_cpp03
21/// @{
22///
23/// <h1> Outline </h1>
24/// * <a href="#bslfmt_format_imp_cpp03-purpose"> Purpose</a>
25/// * <a href="#bslfmt_format_imp_cpp03-classes"> Classes </a>
26/// * <a href="#bslfmt_format_imp_cpp03-description"> Description </a>
27///
28/// # Purpose {#bslfmt_format_imp_cpp03-purpose}
29/// Provide C++03 implementation for bslfmt_format_imp.h
30///
31/// # Classes {#bslfmt_format_imp_cpp03-classes}
32/// See bslfmt_format_imp.h for list of classes
33///
34/// @see bslfmt_format_imp
35///
36/// # Description {#bslfmt_format_imp_cpp03-description}
37/// This component is the C++03 translation of a C++11 component,
38/// generated by the 'sim_cpp11_features.pl' program. If the original header
39/// contains any specially delimited regions of C++11 code, then this generated
40/// file contains the C++03 equivalent, i.e., with variadic templates expanded
41/// and rvalue-references replaced by 'bslmf::MovableRef' objects. The header
42/// code in this file is designed to be '#include'd into the original header
43/// when compiling with a C++03 compiler. If there are no specially delimited
44/// regions of C++11 code, then this header contains no code and is not
45/// '#include'd in the original header.
46///
47/// Generated on Thu Apr 24 06:19:46 2025
48/// Command line: sim_cpp11_features.pl bslfmt_format_imp.h
49/// @}
50/** @} */
51/** @} */
52
53/** @addtogroup bsl
54 * @{
55 */
56/** @addtogroup bslfmt
57 * @{
58 */
59/** @addtogroup bslfmt_format_imp_cpp03
60 * @{
61 */
62
63#ifdef COMPILING_BSLFMT_FORMAT_IMP_H
64
65#if defined(BSLS_COMPILERFEATURES_SUPPORT_ALIAS_TEMPLATES) && \
66 defined(BSLS_COMPILERFEATURES_SUPPORT_VARIADIC_TEMPLATES)
67# define BSLFMT_FORMAT_STRING_PARAMETER bslfmt::format_string<t_ARGS...>
68# define BSLFMT_FORMAT_WSTRING_PARAMETER bslfmt::wformat_string<t_ARGS...>
69#else
70// We cannot define format_string<t_ARGS...> in a C++03 compliant manner, so
71// have to use non-template versions instead.
72# define BSLFMT_FORMAT_STRING_PARAMETER bslfmt::format_string
73# define BSLFMT_FORMAT_WSTRING_PARAMETER bslfmt::wformat_string
74#endif // BSLS_LIBRARYFEATURES_HAS_CPP11_BASELINE_LIBRARY
75
76
77namespace bslfmt {
78
79 // ===================================
80 // class Format_Imp_TruncatingIterator
81 // ===================================
82
83/// This component-private type provides a stateful output iterator whose
84/// purpose is to count the number of characters written for use by the
85/// @ref formatted_size free functions. It holds an underlying output iterator (to
86/// which writes are delegated), a maximum character count permitted and a
87/// current character count to keep track of how many characters would be
88/// written if there were no limit.
89///
90/// See @ref bslfmt_format_imp_cpp03
91template <class t_ITERATOR, class t_VALUE_TYPE, class t_DIFF_TYPE>
92class Format_Imp_TruncatingIterator {
93 private:
94 // TYPES
95 typedef typename bsl::iterator_traits<t_ITERATOR>::difference_type DT;
96
97 // DATA
98 t_ITERATOR d_iterator; // underlying iterator
99 t_DIFF_TYPE d_limit; // character limit
100 t_DIFF_TYPE d_count; // current character count
101
102 private:
103 // NOT IMPLEMENTED
104
105 /// The postfix operator must be deleted because, as a counting iterator,
106 /// return by value can cause data inconsistency.
107 Format_Imp_TruncatingIterator operator++(int) BSLS_KEYWORD_DELETED;
108
109 public:
110 // TYPES
111 typedef bsl::output_iterator_tag iterator_category;
112 typedef t_DIFF_TYPE difference_type;
113 typedef t_VALUE_TYPE value_type;
114 typedef void reference;
115 typedef void pointer;
116
117 // CREATORS
118
119 /// Create a instance containing a copy of the specified `iterator` as
120 /// underlying iterater with the maximum character count set to the
121 /// specified `limit` and the current character count set to zero.
122 Format_Imp_TruncatingIterator(t_ITERATOR iterator, t_DIFF_TYPE limit);
123
124 // MANIPULATORS
125
126 /// Do nothing and return a reference to this object. This is included to
127 /// ensure compliance with the C++ Standard's LegacyOutputIterator
128 /// requirements.
129 Format_Imp_TruncatingIterator& operator*();
130
131 /// Increment the current character count. If the current character count
132 /// is less than the maximum character count (set on construction), assign
133 /// the specified `x` to the stored underlying iterator and increment the
134 /// stored underlying iterator.
135 void operator=(t_VALUE_TYPE x);
136
137 /// Do nothing and return a reference to this object. This is included to
138 /// ensure compliance with the C++ Standard's LegacyOutputIterator
139 /// requirements.
140 Format_Imp_TruncatingIterator& operator++();
141
142 // ACCESSORS
143
144 /// Return the current character count.
145 /// \note Note that this is the number of
146 /// calls to `operator=` regardless of whether the limit has been breached.
147 t_DIFF_TYPE count() const;
148
149 /// Return the underlying iterator.
150 t_ITERATOR underlying() const;
151};
152
153
154 // -------------------------------
155 // class format_to_n_result<t_OUT>
156 // -------------------------------
157
158
159#if defined(BSLS_LIBRARYFEATURES_HAS_CPP20_FORMAT)
160// It is necessary to alias the standard library type where available, to
161// ensure clients of the @ref format_to_n can use the BSL and the Standard Library
162// implementations interchaneably without having to convert between return
163// types.
164using std::format_to_n_result;
165#else
166/// This type mirrors the @ref format_to_n_result type as specified in the
167/// standard. It exists to enable the @ref format_to_n function to return both an
168/// output iterator (the specified `t_OUT` template parameter) and the
169/// untrunctated size.
170///
171/// See @ref bslfmt_format_imp_cpp03
172template <class t_OUT>
173struct format_to_n_result {
174 public:
175 // PUBLIC DATA
176 t_OUT out; // Output iterator
177 typename bsl::iterator_traits<t_OUT>::difference_type
178 size; // Untruncated size
179};
180#endif
181
182 // ---------------------------------------------------
183 // class Format_Imp_Visitor<t_ITERATOR, t_OUT, t_CHAR>
184 // ---------------------------------------------------
185
186/// Component-private type acting as the visitor in a call to
187/// @ref visit_format_arg .
188///
189/// See @ref bslfmt_format_imp_cpp03
190template <class t_OUT, class t_CHAR>
191struct Format_Imp_Visitor {
192 private:
193 // DATA
194 basic_format_parse_context<t_CHAR> *d_parseContext_p; // context for
195 // format string.
196 basic_format_context<t_OUT, t_CHAR> *d_formatContext_p; // context for
197 // output iterator.
198
199 // PRIVATE TYPES
200 typedef
201 typename basic_format_arg<basic_format_context<t_OUT, t_CHAR> >::handle
202 handle;
203
204 public:
205 // CREATORS
206
207 /// Create an instance of this type referencing the specified `pc` and the
208 /// specified `fc` for format strings and output iterators respectively.
209 Format_Imp_Visitor(basic_format_parse_context<t_CHAR>& pc,
210 basic_format_context<t_OUT, t_CHAR>& fc);
211
212 // MANIPULATORS
213
214 /// Throw a @ref format_error exception to indicate this overload should never
215 /// get called.
216 void operator()(bsl::monostate) const;
217
218 /// Write a string representation of the specified `x` to the output
219 /// iterator in `d_format_context_p`, formatted according to the parse
220 /// string referenced by `d_formatContext_p`. This is done by constructing
221 /// an appropriate `formatter` of a type corresponding to the argument type
222 /// of the specified `x`, then call `parse` and `format` on that
223 /// constructed `formatter`.
224 void operator()(bool value) const;
225 void operator()(t_CHAR value) const;
226 void operator()(unsigned value) const;
227 void operator()(long long value) const;
228 void operator()(unsigned long long value) const;
229 void operator()(float value) const;
230 void operator()(double value) const;
231 void operator()(long double value) const;
232 void operator()(const t_CHAR *value) const;
233 void operator()(const void *value) const;
234 void operator()(int value) const;
235 void operator()(bsl::basic_string_view<t_CHAR> value) const;
236
237 /// Write a string representation of type referenced by the specified `h`
238 /// to the output iterator in `d_format_context_p`, formatted according to
239 /// the parse string referenced by `d_formatContext_p`. This is done by
240 /// delegating to the `handle::format` function.
241 void operator()(const handle& h) const;
242};
243
244 // ----------------------------------
245 // class Format_Imp_Processor<t_CHAR>
246 // ----------------------------------
247
248/// This component-private namespace struct provides access to formatting
249/// implementation functions to which the `bslfmt::format` family of free
250/// functions can delegate.
251///
252/// See @ref bslfmt_format_imp_cpp03
253template <class t_CHAR>
254struct Format_Imp_Processor {
255 private:
256 // PRIVATE CLASS METHODS
257
258 /// Format the specified `args` according to the format string specified by
259 /// `fmtStr` and write the result to the output iterator specified by
260 /// `out`. Return an iterator one past the end of the output range.
261 template <class t_OUT>
262 static t_OUT processImp(
263 t_OUT& out,
264 bsl::basic_string_view<t_CHAR> fmtStr,
265 const basic_format_args<basic_format_context<t_OUT, t_CHAR> >& args);
266
267 public:
268 // CLASS METHODS
269
270 /// Format the specified `args` according to the format string specified by
271 /// `fmtStr` and write the result to the output iterator specified by
272 /// `out`. Return an iterator one past the end of the output range. This
273 /// function participates in overload resolution if `out` is of
274 /// `Format_ContextOutputIteratorRef` type.
275 static Format_ContextOutputIteratorRef<t_CHAR>
276 process(Format_ContextOutputIteratorRef<t_CHAR> out,
277 bsl::basic_string_view<t_CHAR> fmtStr,
278 const basic_format_args<
279 basic_format_context<Format_ContextOutputIteratorRef<t_CHAR>,
280 t_CHAR> >& args);
281
282 /// Format the specified `args` according to the format string specified by
283 /// `fmtStr` and write the result to the output iterator specified by
284 /// `out`. Return an iterator one past the end of the output range. This
285 /// function participates in overload resolution if `out` is not of
286 /// `Format_ContextOutputIteratorRef` type.
287 template <class t_OUT, class t_CONTEXT>
288 static t_OUT process(t_OUT out,
289 bsl::basic_string_view<t_CHAR> fmtStr,
290 const basic_format_args<t_CONTEXT>& args);
291};
292
293 // --------------
294 // FREE FUNCTIONS
295 // --------------
296
297// FREE FUNCTIONS
298
299/// Format the specified `args` according to the specification given by the
300/// specified `fmtStr`, and write the result of this operation into the output
301/// iterator given by the specified `out` parameter. In the event of an error
302/// the exception @ref format_error is thrown. Behavior is undefined if `out` is
303/// not a valid output iterator.
304template <class t_OUT>
305inline
306t_OUT vformat_to(t_OUT out, bsl::string_view fmtStr, format_args args);
307
308/// Format the specified `args` according to the specification given by the
309/// specified `fmtStr`, and write the result of this operation into the output
310/// iterator given by the specified `out` parameter. In the event of an error
311/// the exception @ref format_error is thrown. Behavior is undefined if `out` is
312/// not a valid output iterator.
313template <class t_OUT>
314inline
315t_OUT vformat_to(t_OUT out, bsl::wstring_view fmtStr, wformat_args args);
316
317/// Format the specified `args` according to the specification given by the
318/// specified `fmtStr`, and write the result of this operation into the string
319/// addressed by the specified `out` parameter. In the event of an error the
320/// exception @ref format_error is thrown. Behavior is undefined if `out` does
321/// not point to a valid `bsl::string` object.
322inline
323void vformat_to(bsl::string *out, bsl::string_view fmtStr, format_args args);
324
325/// Format the specified `args` according to the specification given by the
326/// specified `fmtStr`, and write the result of this operation into the string
327/// addressed by the specified `out` parameter. In the event of an error the
328/// exception @ref format_error is thrown. Behavior is undefined if `out` does
329/// not point to a valid `bsl::string` object.
330inline
331void vformat_to(bsl::wstring *out,
332 bsl::wstring_view fmtStr,
333 wformat_args args);
334
335/// Format the specified `args` according to the specification given by the
336/// specified `fmt` and return the result. In the event of an error the
337/// exception @ref format_error is thrown.
338inline
339bsl::string vformat(bsl::string_view fmt, format_args args);
340
341/// Format the specified `args` according to the specification given by the
342/// specified `fmtStr` and return the result. In the event of an error the
343/// exception @ref format_error is thrown.
344inline
345bsl::wstring vformat(bsl::wstring_view fmtStr, wformat_args args);
346
347/// Format the specified `args` according to the specification given by the
348/// specified `fmtStr`, using the specified `allocator` to supply memory (if
349/// required), and return the result. In the event of an error the exception
350/// @ref format_error is thrown.
351inline
352bsl::string vformat(bsl::allocator<char> alloc,
353 bsl::string_view fmtStr,
354 format_args args);
355
356/// Format the specified `args` according to the specification given by the
357/// specified `fmtStr`, using the specified `allocator` to supply memory (if
358/// required), and return the result. In the event of an error the exception
359/// @ref format_error is thrown.
360inline
361bsl::wstring vformat(bsl::allocator<wchar_t> alloc,
362 bsl::wstring_view fmtStr,
363 wformat_args args);
364
365#if BSLS_COMPILERFEATURES_SIMULATE_VARIADIC_TEMPLATES
366// {{{ BEGIN GENERATED CODE
367// Command line: sim_cpp11_features.pl bslfmt_format_imp.h
368#ifndef BSLFMT_FORMAT_IMP_VARIADIC_LIMIT
369#define BSLFMT_FORMAT_IMP_VARIADIC_LIMIT 10
370#endif
371#ifndef BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A
372#define BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A BSLFMT_FORMAT_IMP_VARIADIC_LIMIT
373#endif
374#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 0
375template <class t_OUT>
376typename bsl::enable_if<
377 !bsl::is_same<typename bsl::decay<t_OUT>::type, bsl::string *>::value,
378 t_OUT>::type
379inline
380format_to(t_OUT out,
381 BSLFMT_FORMAT_STRING_PARAMETER fmtStr);
382#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 0
383
384#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 1
385template <class t_OUT, class t_ARGS_01>
386typename bsl::enable_if<
387 !bsl::is_same<typename bsl::decay<t_OUT>::type, bsl::string *>::value,
388 t_OUT>::type
389inline
390format_to(t_OUT out,
391 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
392 const t_ARGS_01& args_01);
393#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 1
394
395#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 2
396template <class t_OUT, class t_ARGS_01,
397 class t_ARGS_02>
398typename bsl::enable_if<
399 !bsl::is_same<typename bsl::decay<t_OUT>::type, bsl::string *>::value,
400 t_OUT>::type
401inline
402format_to(t_OUT out,
403 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
404 const t_ARGS_01& args_01,
405 const t_ARGS_02& args_02);
406#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 2
407
408#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 3
409template <class t_OUT, class t_ARGS_01,
410 class t_ARGS_02,
411 class t_ARGS_03>
412typename bsl::enable_if<
413 !bsl::is_same<typename bsl::decay<t_OUT>::type, bsl::string *>::value,
414 t_OUT>::type
415inline
416format_to(t_OUT out,
417 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
418 const t_ARGS_01& args_01,
419 const t_ARGS_02& args_02,
420 const t_ARGS_03& args_03);
421#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 3
422
423#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 4
424template <class t_OUT, class t_ARGS_01,
425 class t_ARGS_02,
426 class t_ARGS_03,
427 class t_ARGS_04>
428typename bsl::enable_if<
429 !bsl::is_same<typename bsl::decay<t_OUT>::type, bsl::string *>::value,
430 t_OUT>::type
431inline
432format_to(t_OUT out,
433 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
434 const t_ARGS_01& args_01,
435 const t_ARGS_02& args_02,
436 const t_ARGS_03& args_03,
437 const t_ARGS_04& args_04);
438#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 4
439
440#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 5
441template <class t_OUT, class t_ARGS_01,
442 class t_ARGS_02,
443 class t_ARGS_03,
444 class t_ARGS_04,
445 class t_ARGS_05>
446typename bsl::enable_if<
447 !bsl::is_same<typename bsl::decay<t_OUT>::type, bsl::string *>::value,
448 t_OUT>::type
449inline
450format_to(t_OUT out,
451 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
452 const t_ARGS_01& args_01,
453 const t_ARGS_02& args_02,
454 const t_ARGS_03& args_03,
455 const t_ARGS_04& args_04,
456 const t_ARGS_05& args_05);
457#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 5
458
459#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 6
460template <class t_OUT, class t_ARGS_01,
461 class t_ARGS_02,
462 class t_ARGS_03,
463 class t_ARGS_04,
464 class t_ARGS_05,
465 class t_ARGS_06>
466typename bsl::enable_if<
467 !bsl::is_same<typename bsl::decay<t_OUT>::type, bsl::string *>::value,
468 t_OUT>::type
469inline
470format_to(t_OUT out,
471 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
472 const t_ARGS_01& args_01,
473 const t_ARGS_02& args_02,
474 const t_ARGS_03& args_03,
475 const t_ARGS_04& args_04,
476 const t_ARGS_05& args_05,
477 const t_ARGS_06& args_06);
478#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 6
479
480#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 7
481template <class t_OUT, class t_ARGS_01,
482 class t_ARGS_02,
483 class t_ARGS_03,
484 class t_ARGS_04,
485 class t_ARGS_05,
486 class t_ARGS_06,
487 class t_ARGS_07>
488typename bsl::enable_if<
489 !bsl::is_same<typename bsl::decay<t_OUT>::type, bsl::string *>::value,
490 t_OUT>::type
491inline
492format_to(t_OUT out,
493 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
494 const t_ARGS_01& args_01,
495 const t_ARGS_02& args_02,
496 const t_ARGS_03& args_03,
497 const t_ARGS_04& args_04,
498 const t_ARGS_05& args_05,
499 const t_ARGS_06& args_06,
500 const t_ARGS_07& args_07);
501#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 7
502
503#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 8
504template <class t_OUT, class t_ARGS_01,
505 class t_ARGS_02,
506 class t_ARGS_03,
507 class t_ARGS_04,
508 class t_ARGS_05,
509 class t_ARGS_06,
510 class t_ARGS_07,
511 class t_ARGS_08>
512typename bsl::enable_if<
513 !bsl::is_same<typename bsl::decay<t_OUT>::type, bsl::string *>::value,
514 t_OUT>::type
515inline
516format_to(t_OUT out,
517 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
518 const t_ARGS_01& args_01,
519 const t_ARGS_02& args_02,
520 const t_ARGS_03& args_03,
521 const t_ARGS_04& args_04,
522 const t_ARGS_05& args_05,
523 const t_ARGS_06& args_06,
524 const t_ARGS_07& args_07,
525 const t_ARGS_08& args_08);
526#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 8
527
528#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 9
529template <class t_OUT, class t_ARGS_01,
530 class t_ARGS_02,
531 class t_ARGS_03,
532 class t_ARGS_04,
533 class t_ARGS_05,
534 class t_ARGS_06,
535 class t_ARGS_07,
536 class t_ARGS_08,
537 class t_ARGS_09>
538typename bsl::enable_if<
539 !bsl::is_same<typename bsl::decay<t_OUT>::type, bsl::string *>::value,
540 t_OUT>::type
541inline
542format_to(t_OUT out,
543 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
544 const t_ARGS_01& args_01,
545 const t_ARGS_02& args_02,
546 const t_ARGS_03& args_03,
547 const t_ARGS_04& args_04,
548 const t_ARGS_05& args_05,
549 const t_ARGS_06& args_06,
550 const t_ARGS_07& args_07,
551 const t_ARGS_08& args_08,
552 const t_ARGS_09& args_09);
553#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 9
554
555#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 10
556template <class t_OUT, class t_ARGS_01,
557 class t_ARGS_02,
558 class t_ARGS_03,
559 class t_ARGS_04,
560 class t_ARGS_05,
561 class t_ARGS_06,
562 class t_ARGS_07,
563 class t_ARGS_08,
564 class t_ARGS_09,
565 class t_ARGS_10>
566typename bsl::enable_if<
567 !bsl::is_same<typename bsl::decay<t_OUT>::type, bsl::string *>::value,
568 t_OUT>::type
569inline
570format_to(t_OUT out,
571 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
572 const t_ARGS_01& args_01,
573 const t_ARGS_02& args_02,
574 const t_ARGS_03& args_03,
575 const t_ARGS_04& args_04,
576 const t_ARGS_05& args_05,
577 const t_ARGS_06& args_06,
578 const t_ARGS_07& args_07,
579 const t_ARGS_08& args_08,
580 const t_ARGS_09& args_09,
581 const t_ARGS_10& args_10);
582#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 10
583
584
585#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 0
586template <class t_OUT>
587typename bsl::enable_if<
588 !bsl::is_same<typename bsl::decay<t_OUT>::type, bsl::wstring *>::value,
589 t_OUT>::type
590inline
591format_to(t_OUT out,
592 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr);
593#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 0
594
595#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 1
596template <class t_OUT, class t_ARGS_01>
597typename bsl::enable_if<
598 !bsl::is_same<typename bsl::decay<t_OUT>::type, bsl::wstring *>::value,
599 t_OUT>::type
600inline
601format_to(t_OUT out,
602 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
603 const t_ARGS_01& args_01);
604#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 1
605
606#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 2
607template <class t_OUT, class t_ARGS_01,
608 class t_ARGS_02>
609typename bsl::enable_if<
610 !bsl::is_same<typename bsl::decay<t_OUT>::type, bsl::wstring *>::value,
611 t_OUT>::type
612inline
613format_to(t_OUT out,
614 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
615 const t_ARGS_01& args_01,
616 const t_ARGS_02& args_02);
617#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 2
618
619#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 3
620template <class t_OUT, class t_ARGS_01,
621 class t_ARGS_02,
622 class t_ARGS_03>
623typename bsl::enable_if<
624 !bsl::is_same<typename bsl::decay<t_OUT>::type, bsl::wstring *>::value,
625 t_OUT>::type
626inline
627format_to(t_OUT out,
628 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
629 const t_ARGS_01& args_01,
630 const t_ARGS_02& args_02,
631 const t_ARGS_03& args_03);
632#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 3
633
634#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 4
635template <class t_OUT, class t_ARGS_01,
636 class t_ARGS_02,
637 class t_ARGS_03,
638 class t_ARGS_04>
639typename bsl::enable_if<
640 !bsl::is_same<typename bsl::decay<t_OUT>::type, bsl::wstring *>::value,
641 t_OUT>::type
642inline
643format_to(t_OUT out,
644 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
645 const t_ARGS_01& args_01,
646 const t_ARGS_02& args_02,
647 const t_ARGS_03& args_03,
648 const t_ARGS_04& args_04);
649#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 4
650
651#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 5
652template <class t_OUT, class t_ARGS_01,
653 class t_ARGS_02,
654 class t_ARGS_03,
655 class t_ARGS_04,
656 class t_ARGS_05>
657typename bsl::enable_if<
658 !bsl::is_same<typename bsl::decay<t_OUT>::type, bsl::wstring *>::value,
659 t_OUT>::type
660inline
661format_to(t_OUT out,
662 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
663 const t_ARGS_01& args_01,
664 const t_ARGS_02& args_02,
665 const t_ARGS_03& args_03,
666 const t_ARGS_04& args_04,
667 const t_ARGS_05& args_05);
668#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 5
669
670#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 6
671template <class t_OUT, class t_ARGS_01,
672 class t_ARGS_02,
673 class t_ARGS_03,
674 class t_ARGS_04,
675 class t_ARGS_05,
676 class t_ARGS_06>
677typename bsl::enable_if<
678 !bsl::is_same<typename bsl::decay<t_OUT>::type, bsl::wstring *>::value,
679 t_OUT>::type
680inline
681format_to(t_OUT out,
682 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
683 const t_ARGS_01& args_01,
684 const t_ARGS_02& args_02,
685 const t_ARGS_03& args_03,
686 const t_ARGS_04& args_04,
687 const t_ARGS_05& args_05,
688 const t_ARGS_06& args_06);
689#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 6
690
691#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 7
692template <class t_OUT, class t_ARGS_01,
693 class t_ARGS_02,
694 class t_ARGS_03,
695 class t_ARGS_04,
696 class t_ARGS_05,
697 class t_ARGS_06,
698 class t_ARGS_07>
699typename bsl::enable_if<
700 !bsl::is_same<typename bsl::decay<t_OUT>::type, bsl::wstring *>::value,
701 t_OUT>::type
702inline
703format_to(t_OUT out,
704 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
705 const t_ARGS_01& args_01,
706 const t_ARGS_02& args_02,
707 const t_ARGS_03& args_03,
708 const t_ARGS_04& args_04,
709 const t_ARGS_05& args_05,
710 const t_ARGS_06& args_06,
711 const t_ARGS_07& args_07);
712#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 7
713
714#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 8
715template <class t_OUT, class t_ARGS_01,
716 class t_ARGS_02,
717 class t_ARGS_03,
718 class t_ARGS_04,
719 class t_ARGS_05,
720 class t_ARGS_06,
721 class t_ARGS_07,
722 class t_ARGS_08>
723typename bsl::enable_if<
724 !bsl::is_same<typename bsl::decay<t_OUT>::type, bsl::wstring *>::value,
725 t_OUT>::type
726inline
727format_to(t_OUT out,
728 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
729 const t_ARGS_01& args_01,
730 const t_ARGS_02& args_02,
731 const t_ARGS_03& args_03,
732 const t_ARGS_04& args_04,
733 const t_ARGS_05& args_05,
734 const t_ARGS_06& args_06,
735 const t_ARGS_07& args_07,
736 const t_ARGS_08& args_08);
737#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 8
738
739#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 9
740template <class t_OUT, class t_ARGS_01,
741 class t_ARGS_02,
742 class t_ARGS_03,
743 class t_ARGS_04,
744 class t_ARGS_05,
745 class t_ARGS_06,
746 class t_ARGS_07,
747 class t_ARGS_08,
748 class t_ARGS_09>
749typename bsl::enable_if<
750 !bsl::is_same<typename bsl::decay<t_OUT>::type, bsl::wstring *>::value,
751 t_OUT>::type
752inline
753format_to(t_OUT out,
754 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
755 const t_ARGS_01& args_01,
756 const t_ARGS_02& args_02,
757 const t_ARGS_03& args_03,
758 const t_ARGS_04& args_04,
759 const t_ARGS_05& args_05,
760 const t_ARGS_06& args_06,
761 const t_ARGS_07& args_07,
762 const t_ARGS_08& args_08,
763 const t_ARGS_09& args_09);
764#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 9
765
766#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 10
767template <class t_OUT, class t_ARGS_01,
768 class t_ARGS_02,
769 class t_ARGS_03,
770 class t_ARGS_04,
771 class t_ARGS_05,
772 class t_ARGS_06,
773 class t_ARGS_07,
774 class t_ARGS_08,
775 class t_ARGS_09,
776 class t_ARGS_10>
777typename bsl::enable_if<
778 !bsl::is_same<typename bsl::decay<t_OUT>::type, bsl::wstring *>::value,
779 t_OUT>::type
780inline
781format_to(t_OUT out,
782 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
783 const t_ARGS_01& args_01,
784 const t_ARGS_02& args_02,
785 const t_ARGS_03& args_03,
786 const t_ARGS_04& args_04,
787 const t_ARGS_05& args_05,
788 const t_ARGS_06& args_06,
789 const t_ARGS_07& args_07,
790 const t_ARGS_08& args_08,
791 const t_ARGS_09& args_09,
792 const t_ARGS_10& args_10);
793#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 10
794
795
796#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 0
797inline
798void format_to(bsl::string *out,
799 BSLFMT_FORMAT_STRING_PARAMETER fmtStr);
800#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 0
801
802#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 1
803template <class t_ARGS_01>
804inline
805void format_to(bsl::string *out,
806 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
807 const t_ARGS_01& args_01);
808#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 1
809
810#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 2
811template <class t_ARGS_01,
812 class t_ARGS_02>
813inline
814void format_to(bsl::string *out,
815 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
816 const t_ARGS_01& args_01,
817 const t_ARGS_02& args_02);
818#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 2
819
820#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 3
821template <class t_ARGS_01,
822 class t_ARGS_02,
823 class t_ARGS_03>
824inline
825void format_to(bsl::string *out,
826 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
827 const t_ARGS_01& args_01,
828 const t_ARGS_02& args_02,
829 const t_ARGS_03& args_03);
830#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 3
831
832#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 4
833template <class t_ARGS_01,
834 class t_ARGS_02,
835 class t_ARGS_03,
836 class t_ARGS_04>
837inline
838void format_to(bsl::string *out,
839 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
840 const t_ARGS_01& args_01,
841 const t_ARGS_02& args_02,
842 const t_ARGS_03& args_03,
843 const t_ARGS_04& args_04);
844#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 4
845
846#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 5
847template <class t_ARGS_01,
848 class t_ARGS_02,
849 class t_ARGS_03,
850 class t_ARGS_04,
851 class t_ARGS_05>
852inline
853void format_to(bsl::string *out,
854 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
855 const t_ARGS_01& args_01,
856 const t_ARGS_02& args_02,
857 const t_ARGS_03& args_03,
858 const t_ARGS_04& args_04,
859 const t_ARGS_05& args_05);
860#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 5
861
862#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 6
863template <class t_ARGS_01,
864 class t_ARGS_02,
865 class t_ARGS_03,
866 class t_ARGS_04,
867 class t_ARGS_05,
868 class t_ARGS_06>
869inline
870void format_to(bsl::string *out,
871 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
872 const t_ARGS_01& args_01,
873 const t_ARGS_02& args_02,
874 const t_ARGS_03& args_03,
875 const t_ARGS_04& args_04,
876 const t_ARGS_05& args_05,
877 const t_ARGS_06& args_06);
878#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 6
879
880#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 7
881template <class t_ARGS_01,
882 class t_ARGS_02,
883 class t_ARGS_03,
884 class t_ARGS_04,
885 class t_ARGS_05,
886 class t_ARGS_06,
887 class t_ARGS_07>
888inline
889void format_to(bsl::string *out,
890 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
891 const t_ARGS_01& args_01,
892 const t_ARGS_02& args_02,
893 const t_ARGS_03& args_03,
894 const t_ARGS_04& args_04,
895 const t_ARGS_05& args_05,
896 const t_ARGS_06& args_06,
897 const t_ARGS_07& args_07);
898#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 7
899
900#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 8
901template <class t_ARGS_01,
902 class t_ARGS_02,
903 class t_ARGS_03,
904 class t_ARGS_04,
905 class t_ARGS_05,
906 class t_ARGS_06,
907 class t_ARGS_07,
908 class t_ARGS_08>
909inline
910void format_to(bsl::string *out,
911 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
912 const t_ARGS_01& args_01,
913 const t_ARGS_02& args_02,
914 const t_ARGS_03& args_03,
915 const t_ARGS_04& args_04,
916 const t_ARGS_05& args_05,
917 const t_ARGS_06& args_06,
918 const t_ARGS_07& args_07,
919 const t_ARGS_08& args_08);
920#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 8
921
922#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 9
923template <class t_ARGS_01,
924 class t_ARGS_02,
925 class t_ARGS_03,
926 class t_ARGS_04,
927 class t_ARGS_05,
928 class t_ARGS_06,
929 class t_ARGS_07,
930 class t_ARGS_08,
931 class t_ARGS_09>
932inline
933void format_to(bsl::string *out,
934 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
935 const t_ARGS_01& args_01,
936 const t_ARGS_02& args_02,
937 const t_ARGS_03& args_03,
938 const t_ARGS_04& args_04,
939 const t_ARGS_05& args_05,
940 const t_ARGS_06& args_06,
941 const t_ARGS_07& args_07,
942 const t_ARGS_08& args_08,
943 const t_ARGS_09& args_09);
944#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 9
945
946#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 10
947template <class t_ARGS_01,
948 class t_ARGS_02,
949 class t_ARGS_03,
950 class t_ARGS_04,
951 class t_ARGS_05,
952 class t_ARGS_06,
953 class t_ARGS_07,
954 class t_ARGS_08,
955 class t_ARGS_09,
956 class t_ARGS_10>
957inline
958void format_to(bsl::string *out,
959 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
960 const t_ARGS_01& args_01,
961 const t_ARGS_02& args_02,
962 const t_ARGS_03& args_03,
963 const t_ARGS_04& args_04,
964 const t_ARGS_05& args_05,
965 const t_ARGS_06& args_06,
966 const t_ARGS_07& args_07,
967 const t_ARGS_08& args_08,
968 const t_ARGS_09& args_09,
969 const t_ARGS_10& args_10);
970#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 10
971
972
973#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 0
974inline
975void format_to(bsl::wstring *out,
976 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr);
977#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 0
978
979#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 1
980template <class t_ARGS_01>
981inline
982void format_to(bsl::wstring *out,
983 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
984 const t_ARGS_01& args_01);
985#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 1
986
987#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 2
988template <class t_ARGS_01,
989 class t_ARGS_02>
990inline
991void format_to(bsl::wstring *out,
992 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
993 const t_ARGS_01& args_01,
994 const t_ARGS_02& args_02);
995#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 2
996
997#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 3
998template <class t_ARGS_01,
999 class t_ARGS_02,
1000 class t_ARGS_03>
1001inline
1002void format_to(bsl::wstring *out,
1003 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
1004 const t_ARGS_01& args_01,
1005 const t_ARGS_02& args_02,
1006 const t_ARGS_03& args_03);
1007#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 3
1008
1009#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 4
1010template <class t_ARGS_01,
1011 class t_ARGS_02,
1012 class t_ARGS_03,
1013 class t_ARGS_04>
1014inline
1015void format_to(bsl::wstring *out,
1016 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
1017 const t_ARGS_01& args_01,
1018 const t_ARGS_02& args_02,
1019 const t_ARGS_03& args_03,
1020 const t_ARGS_04& args_04);
1021#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 4
1022
1023#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 5
1024template <class t_ARGS_01,
1025 class t_ARGS_02,
1026 class t_ARGS_03,
1027 class t_ARGS_04,
1028 class t_ARGS_05>
1029inline
1030void format_to(bsl::wstring *out,
1031 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
1032 const t_ARGS_01& args_01,
1033 const t_ARGS_02& args_02,
1034 const t_ARGS_03& args_03,
1035 const t_ARGS_04& args_04,
1036 const t_ARGS_05& args_05);
1037#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 5
1038
1039#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 6
1040template <class t_ARGS_01,
1041 class t_ARGS_02,
1042 class t_ARGS_03,
1043 class t_ARGS_04,
1044 class t_ARGS_05,
1045 class t_ARGS_06>
1046inline
1047void format_to(bsl::wstring *out,
1048 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
1049 const t_ARGS_01& args_01,
1050 const t_ARGS_02& args_02,
1051 const t_ARGS_03& args_03,
1052 const t_ARGS_04& args_04,
1053 const t_ARGS_05& args_05,
1054 const t_ARGS_06& args_06);
1055#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 6
1056
1057#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 7
1058template <class t_ARGS_01,
1059 class t_ARGS_02,
1060 class t_ARGS_03,
1061 class t_ARGS_04,
1062 class t_ARGS_05,
1063 class t_ARGS_06,
1064 class t_ARGS_07>
1065inline
1066void format_to(bsl::wstring *out,
1067 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
1068 const t_ARGS_01& args_01,
1069 const t_ARGS_02& args_02,
1070 const t_ARGS_03& args_03,
1071 const t_ARGS_04& args_04,
1072 const t_ARGS_05& args_05,
1073 const t_ARGS_06& args_06,
1074 const t_ARGS_07& args_07);
1075#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 7
1076
1077#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 8
1078template <class t_ARGS_01,
1079 class t_ARGS_02,
1080 class t_ARGS_03,
1081 class t_ARGS_04,
1082 class t_ARGS_05,
1083 class t_ARGS_06,
1084 class t_ARGS_07,
1085 class t_ARGS_08>
1086inline
1087void format_to(bsl::wstring *out,
1088 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
1089 const t_ARGS_01& args_01,
1090 const t_ARGS_02& args_02,
1091 const t_ARGS_03& args_03,
1092 const t_ARGS_04& args_04,
1093 const t_ARGS_05& args_05,
1094 const t_ARGS_06& args_06,
1095 const t_ARGS_07& args_07,
1096 const t_ARGS_08& args_08);
1097#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 8
1098
1099#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 9
1100template <class t_ARGS_01,
1101 class t_ARGS_02,
1102 class t_ARGS_03,
1103 class t_ARGS_04,
1104 class t_ARGS_05,
1105 class t_ARGS_06,
1106 class t_ARGS_07,
1107 class t_ARGS_08,
1108 class t_ARGS_09>
1109inline
1110void format_to(bsl::wstring *out,
1111 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
1112 const t_ARGS_01& args_01,
1113 const t_ARGS_02& args_02,
1114 const t_ARGS_03& args_03,
1115 const t_ARGS_04& args_04,
1116 const t_ARGS_05& args_05,
1117 const t_ARGS_06& args_06,
1118 const t_ARGS_07& args_07,
1119 const t_ARGS_08& args_08,
1120 const t_ARGS_09& args_09);
1121#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 9
1122
1123#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 10
1124template <class t_ARGS_01,
1125 class t_ARGS_02,
1126 class t_ARGS_03,
1127 class t_ARGS_04,
1128 class t_ARGS_05,
1129 class t_ARGS_06,
1130 class t_ARGS_07,
1131 class t_ARGS_08,
1132 class t_ARGS_09,
1133 class t_ARGS_10>
1134inline
1135void format_to(bsl::wstring *out,
1136 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
1137 const t_ARGS_01& args_01,
1138 const t_ARGS_02& args_02,
1139 const t_ARGS_03& args_03,
1140 const t_ARGS_04& args_04,
1141 const t_ARGS_05& args_05,
1142 const t_ARGS_06& args_06,
1143 const t_ARGS_07& args_07,
1144 const t_ARGS_08& args_08,
1145 const t_ARGS_09& args_09,
1146 const t_ARGS_10& args_10);
1147#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 10
1148
1149
1150#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 0
1151inline
1152bsl::string format(BSLFMT_FORMAT_STRING_PARAMETER fmtStr);
1153#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 0
1154
1155#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 1
1156template <class t_ARGS_01>
1157inline
1158bsl::string format(BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
1159 const t_ARGS_01& args_01);
1160#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 1
1161
1162#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 2
1163template <class t_ARGS_01,
1164 class t_ARGS_02>
1165inline
1166bsl::string format(BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
1167 const t_ARGS_01& args_01,
1168 const t_ARGS_02& args_02);
1169#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 2
1170
1171#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 3
1172template <class t_ARGS_01,
1173 class t_ARGS_02,
1174 class t_ARGS_03>
1175inline
1176bsl::string format(BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
1177 const t_ARGS_01& args_01,
1178 const t_ARGS_02& args_02,
1179 const t_ARGS_03& args_03);
1180#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 3
1181
1182#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 4
1183template <class t_ARGS_01,
1184 class t_ARGS_02,
1185 class t_ARGS_03,
1186 class t_ARGS_04>
1187inline
1188bsl::string format(BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
1189 const t_ARGS_01& args_01,
1190 const t_ARGS_02& args_02,
1191 const t_ARGS_03& args_03,
1192 const t_ARGS_04& args_04);
1193#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 4
1194
1195#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 5
1196template <class t_ARGS_01,
1197 class t_ARGS_02,
1198 class t_ARGS_03,
1199 class t_ARGS_04,
1200 class t_ARGS_05>
1201inline
1202bsl::string format(BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
1203 const t_ARGS_01& args_01,
1204 const t_ARGS_02& args_02,
1205 const t_ARGS_03& args_03,
1206 const t_ARGS_04& args_04,
1207 const t_ARGS_05& args_05);
1208#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 5
1209
1210#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 6
1211template <class t_ARGS_01,
1212 class t_ARGS_02,
1213 class t_ARGS_03,
1214 class t_ARGS_04,
1215 class t_ARGS_05,
1216 class t_ARGS_06>
1217inline
1218bsl::string format(BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
1219 const t_ARGS_01& args_01,
1220 const t_ARGS_02& args_02,
1221 const t_ARGS_03& args_03,
1222 const t_ARGS_04& args_04,
1223 const t_ARGS_05& args_05,
1224 const t_ARGS_06& args_06);
1225#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 6
1226
1227#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 7
1228template <class t_ARGS_01,
1229 class t_ARGS_02,
1230 class t_ARGS_03,
1231 class t_ARGS_04,
1232 class t_ARGS_05,
1233 class t_ARGS_06,
1234 class t_ARGS_07>
1235inline
1236bsl::string format(BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
1237 const t_ARGS_01& args_01,
1238 const t_ARGS_02& args_02,
1239 const t_ARGS_03& args_03,
1240 const t_ARGS_04& args_04,
1241 const t_ARGS_05& args_05,
1242 const t_ARGS_06& args_06,
1243 const t_ARGS_07& args_07);
1244#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 7
1245
1246#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 8
1247template <class t_ARGS_01,
1248 class t_ARGS_02,
1249 class t_ARGS_03,
1250 class t_ARGS_04,
1251 class t_ARGS_05,
1252 class t_ARGS_06,
1253 class t_ARGS_07,
1254 class t_ARGS_08>
1255inline
1256bsl::string format(BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
1257 const t_ARGS_01& args_01,
1258 const t_ARGS_02& args_02,
1259 const t_ARGS_03& args_03,
1260 const t_ARGS_04& args_04,
1261 const t_ARGS_05& args_05,
1262 const t_ARGS_06& args_06,
1263 const t_ARGS_07& args_07,
1264 const t_ARGS_08& args_08);
1265#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 8
1266
1267#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 9
1268template <class t_ARGS_01,
1269 class t_ARGS_02,
1270 class t_ARGS_03,
1271 class t_ARGS_04,
1272 class t_ARGS_05,
1273 class t_ARGS_06,
1274 class t_ARGS_07,
1275 class t_ARGS_08,
1276 class t_ARGS_09>
1277inline
1278bsl::string format(BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
1279 const t_ARGS_01& args_01,
1280 const t_ARGS_02& args_02,
1281 const t_ARGS_03& args_03,
1282 const t_ARGS_04& args_04,
1283 const t_ARGS_05& args_05,
1284 const t_ARGS_06& args_06,
1285 const t_ARGS_07& args_07,
1286 const t_ARGS_08& args_08,
1287 const t_ARGS_09& args_09);
1288#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 9
1289
1290#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 10
1291template <class t_ARGS_01,
1292 class t_ARGS_02,
1293 class t_ARGS_03,
1294 class t_ARGS_04,
1295 class t_ARGS_05,
1296 class t_ARGS_06,
1297 class t_ARGS_07,
1298 class t_ARGS_08,
1299 class t_ARGS_09,
1300 class t_ARGS_10>
1301inline
1302bsl::string format(BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
1303 const t_ARGS_01& args_01,
1304 const t_ARGS_02& args_02,
1305 const t_ARGS_03& args_03,
1306 const t_ARGS_04& args_04,
1307 const t_ARGS_05& args_05,
1308 const t_ARGS_06& args_06,
1309 const t_ARGS_07& args_07,
1310 const t_ARGS_08& args_08,
1311 const t_ARGS_09& args_09,
1312 const t_ARGS_10& args_10);
1313#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 10
1314
1315
1316#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 0
1317inline
1318bsl::wstring format(BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr);
1319#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 0
1320
1321#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 1
1322template <class t_ARGS_01>
1323inline
1324bsl::wstring format(BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
1325 const t_ARGS_01& args_01);
1326#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 1
1327
1328#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 2
1329template <class t_ARGS_01,
1330 class t_ARGS_02>
1331inline
1332bsl::wstring format(BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
1333 const t_ARGS_01& args_01,
1334 const t_ARGS_02& args_02);
1335#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 2
1336
1337#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 3
1338template <class t_ARGS_01,
1339 class t_ARGS_02,
1340 class t_ARGS_03>
1341inline
1342bsl::wstring format(BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
1343 const t_ARGS_01& args_01,
1344 const t_ARGS_02& args_02,
1345 const t_ARGS_03& args_03);
1346#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 3
1347
1348#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 4
1349template <class t_ARGS_01,
1350 class t_ARGS_02,
1351 class t_ARGS_03,
1352 class t_ARGS_04>
1353inline
1354bsl::wstring format(BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
1355 const t_ARGS_01& args_01,
1356 const t_ARGS_02& args_02,
1357 const t_ARGS_03& args_03,
1358 const t_ARGS_04& args_04);
1359#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 4
1360
1361#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 5
1362template <class t_ARGS_01,
1363 class t_ARGS_02,
1364 class t_ARGS_03,
1365 class t_ARGS_04,
1366 class t_ARGS_05>
1367inline
1368bsl::wstring format(BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
1369 const t_ARGS_01& args_01,
1370 const t_ARGS_02& args_02,
1371 const t_ARGS_03& args_03,
1372 const t_ARGS_04& args_04,
1373 const t_ARGS_05& args_05);
1374#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 5
1375
1376#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 6
1377template <class t_ARGS_01,
1378 class t_ARGS_02,
1379 class t_ARGS_03,
1380 class t_ARGS_04,
1381 class t_ARGS_05,
1382 class t_ARGS_06>
1383inline
1384bsl::wstring format(BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
1385 const t_ARGS_01& args_01,
1386 const t_ARGS_02& args_02,
1387 const t_ARGS_03& args_03,
1388 const t_ARGS_04& args_04,
1389 const t_ARGS_05& args_05,
1390 const t_ARGS_06& args_06);
1391#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 6
1392
1393#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 7
1394template <class t_ARGS_01,
1395 class t_ARGS_02,
1396 class t_ARGS_03,
1397 class t_ARGS_04,
1398 class t_ARGS_05,
1399 class t_ARGS_06,
1400 class t_ARGS_07>
1401inline
1402bsl::wstring format(BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
1403 const t_ARGS_01& args_01,
1404 const t_ARGS_02& args_02,
1405 const t_ARGS_03& args_03,
1406 const t_ARGS_04& args_04,
1407 const t_ARGS_05& args_05,
1408 const t_ARGS_06& args_06,
1409 const t_ARGS_07& args_07);
1410#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 7
1411
1412#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 8
1413template <class t_ARGS_01,
1414 class t_ARGS_02,
1415 class t_ARGS_03,
1416 class t_ARGS_04,
1417 class t_ARGS_05,
1418 class t_ARGS_06,
1419 class t_ARGS_07,
1420 class t_ARGS_08>
1421inline
1422bsl::wstring format(BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
1423 const t_ARGS_01& args_01,
1424 const t_ARGS_02& args_02,
1425 const t_ARGS_03& args_03,
1426 const t_ARGS_04& args_04,
1427 const t_ARGS_05& args_05,
1428 const t_ARGS_06& args_06,
1429 const t_ARGS_07& args_07,
1430 const t_ARGS_08& args_08);
1431#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 8
1432
1433#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 9
1434template <class t_ARGS_01,
1435 class t_ARGS_02,
1436 class t_ARGS_03,
1437 class t_ARGS_04,
1438 class t_ARGS_05,
1439 class t_ARGS_06,
1440 class t_ARGS_07,
1441 class t_ARGS_08,
1442 class t_ARGS_09>
1443inline
1444bsl::wstring format(BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
1445 const t_ARGS_01& args_01,
1446 const t_ARGS_02& args_02,
1447 const t_ARGS_03& args_03,
1448 const t_ARGS_04& args_04,
1449 const t_ARGS_05& args_05,
1450 const t_ARGS_06& args_06,
1451 const t_ARGS_07& args_07,
1452 const t_ARGS_08& args_08,
1453 const t_ARGS_09& args_09);
1454#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 9
1455
1456#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 10
1457template <class t_ARGS_01,
1458 class t_ARGS_02,
1459 class t_ARGS_03,
1460 class t_ARGS_04,
1461 class t_ARGS_05,
1462 class t_ARGS_06,
1463 class t_ARGS_07,
1464 class t_ARGS_08,
1465 class t_ARGS_09,
1466 class t_ARGS_10>
1467inline
1468bsl::wstring format(BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
1469 const t_ARGS_01& args_01,
1470 const t_ARGS_02& args_02,
1471 const t_ARGS_03& args_03,
1472 const t_ARGS_04& args_04,
1473 const t_ARGS_05& args_05,
1474 const t_ARGS_06& args_06,
1475 const t_ARGS_07& args_07,
1476 const t_ARGS_08& args_08,
1477 const t_ARGS_09& args_09,
1478 const t_ARGS_10& args_10);
1479#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 10
1480
1481
1482#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 0
1483inline
1484bsl::string format(bsl::allocator<char> alloc,
1485 BSLFMT_FORMAT_STRING_PARAMETER fmtStr);
1486#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 0
1487
1488#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 1
1489template <class t_ARGS_01>
1490inline
1491bsl::string format(bsl::allocator<char> alloc,
1492 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
1493 const t_ARGS_01& args_01);
1494#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 1
1495
1496#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 2
1497template <class t_ARGS_01,
1498 class t_ARGS_02>
1499inline
1500bsl::string format(bsl::allocator<char> alloc,
1501 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
1502 const t_ARGS_01& args_01,
1503 const t_ARGS_02& args_02);
1504#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 2
1505
1506#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 3
1507template <class t_ARGS_01,
1508 class t_ARGS_02,
1509 class t_ARGS_03>
1510inline
1511bsl::string format(bsl::allocator<char> alloc,
1512 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
1513 const t_ARGS_01& args_01,
1514 const t_ARGS_02& args_02,
1515 const t_ARGS_03& args_03);
1516#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 3
1517
1518#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 4
1519template <class t_ARGS_01,
1520 class t_ARGS_02,
1521 class t_ARGS_03,
1522 class t_ARGS_04>
1523inline
1524bsl::string format(bsl::allocator<char> alloc,
1525 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
1526 const t_ARGS_01& args_01,
1527 const t_ARGS_02& args_02,
1528 const t_ARGS_03& args_03,
1529 const t_ARGS_04& args_04);
1530#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 4
1531
1532#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 5
1533template <class t_ARGS_01,
1534 class t_ARGS_02,
1535 class t_ARGS_03,
1536 class t_ARGS_04,
1537 class t_ARGS_05>
1538inline
1539bsl::string format(bsl::allocator<char> alloc,
1540 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
1541 const t_ARGS_01& args_01,
1542 const t_ARGS_02& args_02,
1543 const t_ARGS_03& args_03,
1544 const t_ARGS_04& args_04,
1545 const t_ARGS_05& args_05);
1546#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 5
1547
1548#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 6
1549template <class t_ARGS_01,
1550 class t_ARGS_02,
1551 class t_ARGS_03,
1552 class t_ARGS_04,
1553 class t_ARGS_05,
1554 class t_ARGS_06>
1555inline
1556bsl::string format(bsl::allocator<char> alloc,
1557 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
1558 const t_ARGS_01& args_01,
1559 const t_ARGS_02& args_02,
1560 const t_ARGS_03& args_03,
1561 const t_ARGS_04& args_04,
1562 const t_ARGS_05& args_05,
1563 const t_ARGS_06& args_06);
1564#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 6
1565
1566#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 7
1567template <class t_ARGS_01,
1568 class t_ARGS_02,
1569 class t_ARGS_03,
1570 class t_ARGS_04,
1571 class t_ARGS_05,
1572 class t_ARGS_06,
1573 class t_ARGS_07>
1574inline
1575bsl::string format(bsl::allocator<char> alloc,
1576 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
1577 const t_ARGS_01& args_01,
1578 const t_ARGS_02& args_02,
1579 const t_ARGS_03& args_03,
1580 const t_ARGS_04& args_04,
1581 const t_ARGS_05& args_05,
1582 const t_ARGS_06& args_06,
1583 const t_ARGS_07& args_07);
1584#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 7
1585
1586#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 8
1587template <class t_ARGS_01,
1588 class t_ARGS_02,
1589 class t_ARGS_03,
1590 class t_ARGS_04,
1591 class t_ARGS_05,
1592 class t_ARGS_06,
1593 class t_ARGS_07,
1594 class t_ARGS_08>
1595inline
1596bsl::string format(bsl::allocator<char> alloc,
1597 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
1598 const t_ARGS_01& args_01,
1599 const t_ARGS_02& args_02,
1600 const t_ARGS_03& args_03,
1601 const t_ARGS_04& args_04,
1602 const t_ARGS_05& args_05,
1603 const t_ARGS_06& args_06,
1604 const t_ARGS_07& args_07,
1605 const t_ARGS_08& args_08);
1606#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 8
1607
1608#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 9
1609template <class t_ARGS_01,
1610 class t_ARGS_02,
1611 class t_ARGS_03,
1612 class t_ARGS_04,
1613 class t_ARGS_05,
1614 class t_ARGS_06,
1615 class t_ARGS_07,
1616 class t_ARGS_08,
1617 class t_ARGS_09>
1618inline
1619bsl::string format(bsl::allocator<char> alloc,
1620 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
1621 const t_ARGS_01& args_01,
1622 const t_ARGS_02& args_02,
1623 const t_ARGS_03& args_03,
1624 const t_ARGS_04& args_04,
1625 const t_ARGS_05& args_05,
1626 const t_ARGS_06& args_06,
1627 const t_ARGS_07& args_07,
1628 const t_ARGS_08& args_08,
1629 const t_ARGS_09& args_09);
1630#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 9
1631
1632#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 10
1633template <class t_ARGS_01,
1634 class t_ARGS_02,
1635 class t_ARGS_03,
1636 class t_ARGS_04,
1637 class t_ARGS_05,
1638 class t_ARGS_06,
1639 class t_ARGS_07,
1640 class t_ARGS_08,
1641 class t_ARGS_09,
1642 class t_ARGS_10>
1643inline
1644bsl::string format(bsl::allocator<char> alloc,
1645 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
1646 const t_ARGS_01& args_01,
1647 const t_ARGS_02& args_02,
1648 const t_ARGS_03& args_03,
1649 const t_ARGS_04& args_04,
1650 const t_ARGS_05& args_05,
1651 const t_ARGS_06& args_06,
1652 const t_ARGS_07& args_07,
1653 const t_ARGS_08& args_08,
1654 const t_ARGS_09& args_09,
1655 const t_ARGS_10& args_10);
1656#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 10
1657
1658
1659#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 0
1660inline
1661bsl::wstring format(bsl::allocator<wchar_t> alloc,
1662 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr);
1663#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 0
1664
1665#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 1
1666template <class t_ARGS_01>
1667inline
1668bsl::wstring format(bsl::allocator<wchar_t> alloc,
1669 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
1670 const t_ARGS_01& args_01);
1671#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 1
1672
1673#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 2
1674template <class t_ARGS_01,
1675 class t_ARGS_02>
1676inline
1677bsl::wstring format(bsl::allocator<wchar_t> alloc,
1678 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
1679 const t_ARGS_01& args_01,
1680 const t_ARGS_02& args_02);
1681#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 2
1682
1683#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 3
1684template <class t_ARGS_01,
1685 class t_ARGS_02,
1686 class t_ARGS_03>
1687inline
1688bsl::wstring format(bsl::allocator<wchar_t> alloc,
1689 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
1690 const t_ARGS_01& args_01,
1691 const t_ARGS_02& args_02,
1692 const t_ARGS_03& args_03);
1693#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 3
1694
1695#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 4
1696template <class t_ARGS_01,
1697 class t_ARGS_02,
1698 class t_ARGS_03,
1699 class t_ARGS_04>
1700inline
1701bsl::wstring format(bsl::allocator<wchar_t> alloc,
1702 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
1703 const t_ARGS_01& args_01,
1704 const t_ARGS_02& args_02,
1705 const t_ARGS_03& args_03,
1706 const t_ARGS_04& args_04);
1707#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 4
1708
1709#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 5
1710template <class t_ARGS_01,
1711 class t_ARGS_02,
1712 class t_ARGS_03,
1713 class t_ARGS_04,
1714 class t_ARGS_05>
1715inline
1716bsl::wstring format(bsl::allocator<wchar_t> alloc,
1717 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
1718 const t_ARGS_01& args_01,
1719 const t_ARGS_02& args_02,
1720 const t_ARGS_03& args_03,
1721 const t_ARGS_04& args_04,
1722 const t_ARGS_05& args_05);
1723#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 5
1724
1725#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 6
1726template <class t_ARGS_01,
1727 class t_ARGS_02,
1728 class t_ARGS_03,
1729 class t_ARGS_04,
1730 class t_ARGS_05,
1731 class t_ARGS_06>
1732inline
1733bsl::wstring format(bsl::allocator<wchar_t> alloc,
1734 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
1735 const t_ARGS_01& args_01,
1736 const t_ARGS_02& args_02,
1737 const t_ARGS_03& args_03,
1738 const t_ARGS_04& args_04,
1739 const t_ARGS_05& args_05,
1740 const t_ARGS_06& args_06);
1741#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 6
1742
1743#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 7
1744template <class t_ARGS_01,
1745 class t_ARGS_02,
1746 class t_ARGS_03,
1747 class t_ARGS_04,
1748 class t_ARGS_05,
1749 class t_ARGS_06,
1750 class t_ARGS_07>
1751inline
1752bsl::wstring format(bsl::allocator<wchar_t> alloc,
1753 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
1754 const t_ARGS_01& args_01,
1755 const t_ARGS_02& args_02,
1756 const t_ARGS_03& args_03,
1757 const t_ARGS_04& args_04,
1758 const t_ARGS_05& args_05,
1759 const t_ARGS_06& args_06,
1760 const t_ARGS_07& args_07);
1761#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 7
1762
1763#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 8
1764template <class t_ARGS_01,
1765 class t_ARGS_02,
1766 class t_ARGS_03,
1767 class t_ARGS_04,
1768 class t_ARGS_05,
1769 class t_ARGS_06,
1770 class t_ARGS_07,
1771 class t_ARGS_08>
1772inline
1773bsl::wstring format(bsl::allocator<wchar_t> alloc,
1774 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
1775 const t_ARGS_01& args_01,
1776 const t_ARGS_02& args_02,
1777 const t_ARGS_03& args_03,
1778 const t_ARGS_04& args_04,
1779 const t_ARGS_05& args_05,
1780 const t_ARGS_06& args_06,
1781 const t_ARGS_07& args_07,
1782 const t_ARGS_08& args_08);
1783#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 8
1784
1785#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 9
1786template <class t_ARGS_01,
1787 class t_ARGS_02,
1788 class t_ARGS_03,
1789 class t_ARGS_04,
1790 class t_ARGS_05,
1791 class t_ARGS_06,
1792 class t_ARGS_07,
1793 class t_ARGS_08,
1794 class t_ARGS_09>
1795inline
1796bsl::wstring format(bsl::allocator<wchar_t> alloc,
1797 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
1798 const t_ARGS_01& args_01,
1799 const t_ARGS_02& args_02,
1800 const t_ARGS_03& args_03,
1801 const t_ARGS_04& args_04,
1802 const t_ARGS_05& args_05,
1803 const t_ARGS_06& args_06,
1804 const t_ARGS_07& args_07,
1805 const t_ARGS_08& args_08,
1806 const t_ARGS_09& args_09);
1807#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 9
1808
1809#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 10
1810template <class t_ARGS_01,
1811 class t_ARGS_02,
1812 class t_ARGS_03,
1813 class t_ARGS_04,
1814 class t_ARGS_05,
1815 class t_ARGS_06,
1816 class t_ARGS_07,
1817 class t_ARGS_08,
1818 class t_ARGS_09,
1819 class t_ARGS_10>
1820inline
1821bsl::wstring format(bsl::allocator<wchar_t> alloc,
1822 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
1823 const t_ARGS_01& args_01,
1824 const t_ARGS_02& args_02,
1825 const t_ARGS_03& args_03,
1826 const t_ARGS_04& args_04,
1827 const t_ARGS_05& args_05,
1828 const t_ARGS_06& args_06,
1829 const t_ARGS_07& args_07,
1830 const t_ARGS_08& args_08,
1831 const t_ARGS_09& args_09,
1832 const t_ARGS_10& args_10);
1833#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 10
1834
1835
1836#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 0
1837inline
1838std::size_t formatted_size(BSLFMT_FORMAT_STRING_PARAMETER fmtStr);
1839#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 0
1840
1841#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 1
1842template <class t_ARGS_01>
1843inline
1844std::size_t formatted_size(BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
1845 const t_ARGS_01& args_01);
1846#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 1
1847
1848#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 2
1849template <class t_ARGS_01,
1850 class t_ARGS_02>
1851inline
1852std::size_t formatted_size(BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
1853 const t_ARGS_01& args_01,
1854 const t_ARGS_02& args_02);
1855#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 2
1856
1857#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 3
1858template <class t_ARGS_01,
1859 class t_ARGS_02,
1860 class t_ARGS_03>
1861inline
1862std::size_t formatted_size(BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
1863 const t_ARGS_01& args_01,
1864 const t_ARGS_02& args_02,
1865 const t_ARGS_03& args_03);
1866#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 3
1867
1868#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 4
1869template <class t_ARGS_01,
1870 class t_ARGS_02,
1871 class t_ARGS_03,
1872 class t_ARGS_04>
1873inline
1874std::size_t formatted_size(BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
1875 const t_ARGS_01& args_01,
1876 const t_ARGS_02& args_02,
1877 const t_ARGS_03& args_03,
1878 const t_ARGS_04& args_04);
1879#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 4
1880
1881#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 5
1882template <class t_ARGS_01,
1883 class t_ARGS_02,
1884 class t_ARGS_03,
1885 class t_ARGS_04,
1886 class t_ARGS_05>
1887inline
1888std::size_t formatted_size(BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
1889 const t_ARGS_01& args_01,
1890 const t_ARGS_02& args_02,
1891 const t_ARGS_03& args_03,
1892 const t_ARGS_04& args_04,
1893 const t_ARGS_05& args_05);
1894#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 5
1895
1896#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 6
1897template <class t_ARGS_01,
1898 class t_ARGS_02,
1899 class t_ARGS_03,
1900 class t_ARGS_04,
1901 class t_ARGS_05,
1902 class t_ARGS_06>
1903inline
1904std::size_t formatted_size(BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
1905 const t_ARGS_01& args_01,
1906 const t_ARGS_02& args_02,
1907 const t_ARGS_03& args_03,
1908 const t_ARGS_04& args_04,
1909 const t_ARGS_05& args_05,
1910 const t_ARGS_06& args_06);
1911#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 6
1912
1913#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 7
1914template <class t_ARGS_01,
1915 class t_ARGS_02,
1916 class t_ARGS_03,
1917 class t_ARGS_04,
1918 class t_ARGS_05,
1919 class t_ARGS_06,
1920 class t_ARGS_07>
1921inline
1922std::size_t formatted_size(BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
1923 const t_ARGS_01& args_01,
1924 const t_ARGS_02& args_02,
1925 const t_ARGS_03& args_03,
1926 const t_ARGS_04& args_04,
1927 const t_ARGS_05& args_05,
1928 const t_ARGS_06& args_06,
1929 const t_ARGS_07& args_07);
1930#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 7
1931
1932#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 8
1933template <class t_ARGS_01,
1934 class t_ARGS_02,
1935 class t_ARGS_03,
1936 class t_ARGS_04,
1937 class t_ARGS_05,
1938 class t_ARGS_06,
1939 class t_ARGS_07,
1940 class t_ARGS_08>
1941inline
1942std::size_t formatted_size(BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
1943 const t_ARGS_01& args_01,
1944 const t_ARGS_02& args_02,
1945 const t_ARGS_03& args_03,
1946 const t_ARGS_04& args_04,
1947 const t_ARGS_05& args_05,
1948 const t_ARGS_06& args_06,
1949 const t_ARGS_07& args_07,
1950 const t_ARGS_08& args_08);
1951#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 8
1952
1953#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 9
1954template <class t_ARGS_01,
1955 class t_ARGS_02,
1956 class t_ARGS_03,
1957 class t_ARGS_04,
1958 class t_ARGS_05,
1959 class t_ARGS_06,
1960 class t_ARGS_07,
1961 class t_ARGS_08,
1962 class t_ARGS_09>
1963inline
1964std::size_t formatted_size(BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
1965 const t_ARGS_01& args_01,
1966 const t_ARGS_02& args_02,
1967 const t_ARGS_03& args_03,
1968 const t_ARGS_04& args_04,
1969 const t_ARGS_05& args_05,
1970 const t_ARGS_06& args_06,
1971 const t_ARGS_07& args_07,
1972 const t_ARGS_08& args_08,
1973 const t_ARGS_09& args_09);
1974#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 9
1975
1976#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 10
1977template <class t_ARGS_01,
1978 class t_ARGS_02,
1979 class t_ARGS_03,
1980 class t_ARGS_04,
1981 class t_ARGS_05,
1982 class t_ARGS_06,
1983 class t_ARGS_07,
1984 class t_ARGS_08,
1985 class t_ARGS_09,
1986 class t_ARGS_10>
1987inline
1988std::size_t formatted_size(BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
1989 const t_ARGS_01& args_01,
1990 const t_ARGS_02& args_02,
1991 const t_ARGS_03& args_03,
1992 const t_ARGS_04& args_04,
1993 const t_ARGS_05& args_05,
1994 const t_ARGS_06& args_06,
1995 const t_ARGS_07& args_07,
1996 const t_ARGS_08& args_08,
1997 const t_ARGS_09& args_09,
1998 const t_ARGS_10& args_10);
1999#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 10
2000
2001
2002#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 0
2003inline
2004std::size_t formatted_size(BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr);
2005#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 0
2006
2007#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 1
2008template <class t_ARGS_01>
2009inline
2010std::size_t formatted_size(BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
2011 const t_ARGS_01& args_01);
2012#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 1
2013
2014#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 2
2015template <class t_ARGS_01,
2016 class t_ARGS_02>
2017inline
2018std::size_t formatted_size(BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
2019 const t_ARGS_01& args_01,
2020 const t_ARGS_02& args_02);
2021#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 2
2022
2023#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 3
2024template <class t_ARGS_01,
2025 class t_ARGS_02,
2026 class t_ARGS_03>
2027inline
2028std::size_t formatted_size(BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
2029 const t_ARGS_01& args_01,
2030 const t_ARGS_02& args_02,
2031 const t_ARGS_03& args_03);
2032#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 3
2033
2034#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 4
2035template <class t_ARGS_01,
2036 class t_ARGS_02,
2037 class t_ARGS_03,
2038 class t_ARGS_04>
2039inline
2040std::size_t formatted_size(BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
2041 const t_ARGS_01& args_01,
2042 const t_ARGS_02& args_02,
2043 const t_ARGS_03& args_03,
2044 const t_ARGS_04& args_04);
2045#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 4
2046
2047#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 5
2048template <class t_ARGS_01,
2049 class t_ARGS_02,
2050 class t_ARGS_03,
2051 class t_ARGS_04,
2052 class t_ARGS_05>
2053inline
2054std::size_t formatted_size(BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
2055 const t_ARGS_01& args_01,
2056 const t_ARGS_02& args_02,
2057 const t_ARGS_03& args_03,
2058 const t_ARGS_04& args_04,
2059 const t_ARGS_05& args_05);
2060#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 5
2061
2062#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 6
2063template <class t_ARGS_01,
2064 class t_ARGS_02,
2065 class t_ARGS_03,
2066 class t_ARGS_04,
2067 class t_ARGS_05,
2068 class t_ARGS_06>
2069inline
2070std::size_t formatted_size(BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
2071 const t_ARGS_01& args_01,
2072 const t_ARGS_02& args_02,
2073 const t_ARGS_03& args_03,
2074 const t_ARGS_04& args_04,
2075 const t_ARGS_05& args_05,
2076 const t_ARGS_06& args_06);
2077#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 6
2078
2079#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 7
2080template <class t_ARGS_01,
2081 class t_ARGS_02,
2082 class t_ARGS_03,
2083 class t_ARGS_04,
2084 class t_ARGS_05,
2085 class t_ARGS_06,
2086 class t_ARGS_07>
2087inline
2088std::size_t formatted_size(BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
2089 const t_ARGS_01& args_01,
2090 const t_ARGS_02& args_02,
2091 const t_ARGS_03& args_03,
2092 const t_ARGS_04& args_04,
2093 const t_ARGS_05& args_05,
2094 const t_ARGS_06& args_06,
2095 const t_ARGS_07& args_07);
2096#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 7
2097
2098#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 8
2099template <class t_ARGS_01,
2100 class t_ARGS_02,
2101 class t_ARGS_03,
2102 class t_ARGS_04,
2103 class t_ARGS_05,
2104 class t_ARGS_06,
2105 class t_ARGS_07,
2106 class t_ARGS_08>
2107inline
2108std::size_t formatted_size(BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
2109 const t_ARGS_01& args_01,
2110 const t_ARGS_02& args_02,
2111 const t_ARGS_03& args_03,
2112 const t_ARGS_04& args_04,
2113 const t_ARGS_05& args_05,
2114 const t_ARGS_06& args_06,
2115 const t_ARGS_07& args_07,
2116 const t_ARGS_08& args_08);
2117#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 8
2118
2119#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 9
2120template <class t_ARGS_01,
2121 class t_ARGS_02,
2122 class t_ARGS_03,
2123 class t_ARGS_04,
2124 class t_ARGS_05,
2125 class t_ARGS_06,
2126 class t_ARGS_07,
2127 class t_ARGS_08,
2128 class t_ARGS_09>
2129inline
2130std::size_t formatted_size(BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
2131 const t_ARGS_01& args_01,
2132 const t_ARGS_02& args_02,
2133 const t_ARGS_03& args_03,
2134 const t_ARGS_04& args_04,
2135 const t_ARGS_05& args_05,
2136 const t_ARGS_06& args_06,
2137 const t_ARGS_07& args_07,
2138 const t_ARGS_08& args_08,
2139 const t_ARGS_09& args_09);
2140#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 9
2141
2142#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 10
2143template <class t_ARGS_01,
2144 class t_ARGS_02,
2145 class t_ARGS_03,
2146 class t_ARGS_04,
2147 class t_ARGS_05,
2148 class t_ARGS_06,
2149 class t_ARGS_07,
2150 class t_ARGS_08,
2151 class t_ARGS_09,
2152 class t_ARGS_10>
2153inline
2154std::size_t formatted_size(BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
2155 const t_ARGS_01& args_01,
2156 const t_ARGS_02& args_02,
2157 const t_ARGS_03& args_03,
2158 const t_ARGS_04& args_04,
2159 const t_ARGS_05& args_05,
2160 const t_ARGS_06& args_06,
2161 const t_ARGS_07& args_07,
2162 const t_ARGS_08& args_08,
2163 const t_ARGS_09& args_09,
2164 const t_ARGS_10& args_10);
2165#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 10
2166
2167
2168#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 0
2169template <class t_OUT>
2170inline
2171format_to_n_result<t_OUT>
2172format_to_n(t_OUT out,
2173 typename bsl::iterator_traits<t_OUT>::difference_type maxNumChars,
2174 BSLFMT_FORMAT_STRING_PARAMETER fmtStr);
2175#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 0
2176
2177#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 1
2178template <class t_OUT, class t_ARGS_01>
2179inline
2180format_to_n_result<t_OUT>
2181format_to_n(t_OUT out,
2182 typename bsl::iterator_traits<t_OUT>::difference_type maxNumChars,
2183 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
2184 const t_ARGS_01& args_01);
2185#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 1
2186
2187#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 2
2188template <class t_OUT, class t_ARGS_01,
2189 class t_ARGS_02>
2190inline
2191format_to_n_result<t_OUT>
2192format_to_n(t_OUT out,
2193 typename bsl::iterator_traits<t_OUT>::difference_type maxNumChars,
2194 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
2195 const t_ARGS_01& args_01,
2196 const t_ARGS_02& args_02);
2197#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 2
2198
2199#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 3
2200template <class t_OUT, class t_ARGS_01,
2201 class t_ARGS_02,
2202 class t_ARGS_03>
2203inline
2204format_to_n_result<t_OUT>
2205format_to_n(t_OUT out,
2206 typename bsl::iterator_traits<t_OUT>::difference_type maxNumChars,
2207 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
2208 const t_ARGS_01& args_01,
2209 const t_ARGS_02& args_02,
2210 const t_ARGS_03& args_03);
2211#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 3
2212
2213#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 4
2214template <class t_OUT, class t_ARGS_01,
2215 class t_ARGS_02,
2216 class t_ARGS_03,
2217 class t_ARGS_04>
2218inline
2219format_to_n_result<t_OUT>
2220format_to_n(t_OUT out,
2221 typename bsl::iterator_traits<t_OUT>::difference_type maxNumChars,
2222 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
2223 const t_ARGS_01& args_01,
2224 const t_ARGS_02& args_02,
2225 const t_ARGS_03& args_03,
2226 const t_ARGS_04& args_04);
2227#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 4
2228
2229#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 5
2230template <class t_OUT, class t_ARGS_01,
2231 class t_ARGS_02,
2232 class t_ARGS_03,
2233 class t_ARGS_04,
2234 class t_ARGS_05>
2235inline
2236format_to_n_result<t_OUT>
2237format_to_n(t_OUT out,
2238 typename bsl::iterator_traits<t_OUT>::difference_type maxNumChars,
2239 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
2240 const t_ARGS_01& args_01,
2241 const t_ARGS_02& args_02,
2242 const t_ARGS_03& args_03,
2243 const t_ARGS_04& args_04,
2244 const t_ARGS_05& args_05);
2245#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 5
2246
2247#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 6
2248template <class t_OUT, class t_ARGS_01,
2249 class t_ARGS_02,
2250 class t_ARGS_03,
2251 class t_ARGS_04,
2252 class t_ARGS_05,
2253 class t_ARGS_06>
2254inline
2255format_to_n_result<t_OUT>
2256format_to_n(t_OUT out,
2257 typename bsl::iterator_traits<t_OUT>::difference_type maxNumChars,
2258 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
2259 const t_ARGS_01& args_01,
2260 const t_ARGS_02& args_02,
2261 const t_ARGS_03& args_03,
2262 const t_ARGS_04& args_04,
2263 const t_ARGS_05& args_05,
2264 const t_ARGS_06& args_06);
2265#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 6
2266
2267#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 7
2268template <class t_OUT, class t_ARGS_01,
2269 class t_ARGS_02,
2270 class t_ARGS_03,
2271 class t_ARGS_04,
2272 class t_ARGS_05,
2273 class t_ARGS_06,
2274 class t_ARGS_07>
2275inline
2276format_to_n_result<t_OUT>
2277format_to_n(t_OUT out,
2278 typename bsl::iterator_traits<t_OUT>::difference_type maxNumChars,
2279 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
2280 const t_ARGS_01& args_01,
2281 const t_ARGS_02& args_02,
2282 const t_ARGS_03& args_03,
2283 const t_ARGS_04& args_04,
2284 const t_ARGS_05& args_05,
2285 const t_ARGS_06& args_06,
2286 const t_ARGS_07& args_07);
2287#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 7
2288
2289#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 8
2290template <class t_OUT, class t_ARGS_01,
2291 class t_ARGS_02,
2292 class t_ARGS_03,
2293 class t_ARGS_04,
2294 class t_ARGS_05,
2295 class t_ARGS_06,
2296 class t_ARGS_07,
2297 class t_ARGS_08>
2298inline
2299format_to_n_result<t_OUT>
2300format_to_n(t_OUT out,
2301 typename bsl::iterator_traits<t_OUT>::difference_type maxNumChars,
2302 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
2303 const t_ARGS_01& args_01,
2304 const t_ARGS_02& args_02,
2305 const t_ARGS_03& args_03,
2306 const t_ARGS_04& args_04,
2307 const t_ARGS_05& args_05,
2308 const t_ARGS_06& args_06,
2309 const t_ARGS_07& args_07,
2310 const t_ARGS_08& args_08);
2311#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 8
2312
2313#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 9
2314template <class t_OUT, class t_ARGS_01,
2315 class t_ARGS_02,
2316 class t_ARGS_03,
2317 class t_ARGS_04,
2318 class t_ARGS_05,
2319 class t_ARGS_06,
2320 class t_ARGS_07,
2321 class t_ARGS_08,
2322 class t_ARGS_09>
2323inline
2324format_to_n_result<t_OUT>
2325format_to_n(t_OUT out,
2326 typename bsl::iterator_traits<t_OUT>::difference_type maxNumChars,
2327 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
2328 const t_ARGS_01& args_01,
2329 const t_ARGS_02& args_02,
2330 const t_ARGS_03& args_03,
2331 const t_ARGS_04& args_04,
2332 const t_ARGS_05& args_05,
2333 const t_ARGS_06& args_06,
2334 const t_ARGS_07& args_07,
2335 const t_ARGS_08& args_08,
2336 const t_ARGS_09& args_09);
2337#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 9
2338
2339#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 10
2340template <class t_OUT, class t_ARGS_01,
2341 class t_ARGS_02,
2342 class t_ARGS_03,
2343 class t_ARGS_04,
2344 class t_ARGS_05,
2345 class t_ARGS_06,
2346 class t_ARGS_07,
2347 class t_ARGS_08,
2348 class t_ARGS_09,
2349 class t_ARGS_10>
2350inline
2351format_to_n_result<t_OUT>
2352format_to_n(t_OUT out,
2353 typename bsl::iterator_traits<t_OUT>::difference_type maxNumChars,
2354 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
2355 const t_ARGS_01& args_01,
2356 const t_ARGS_02& args_02,
2357 const t_ARGS_03& args_03,
2358 const t_ARGS_04& args_04,
2359 const t_ARGS_05& args_05,
2360 const t_ARGS_06& args_06,
2361 const t_ARGS_07& args_07,
2362 const t_ARGS_08& args_08,
2363 const t_ARGS_09& args_09,
2364 const t_ARGS_10& args_10);
2365#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 10
2366
2367
2368#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 0
2369template <class t_OUT>
2370inline
2371format_to_n_result<t_OUT>
2372format_to_n(t_OUT out,
2373 typename bsl::iterator_traits<t_OUT>::difference_type maxNumChars,
2374 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr);
2375#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 0
2376
2377#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 1
2378template <class t_OUT, class t_ARGS_01>
2379inline
2380format_to_n_result<t_OUT>
2381format_to_n(t_OUT out,
2382 typename bsl::iterator_traits<t_OUT>::difference_type maxNumChars,
2383 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
2384 const t_ARGS_01& args_01);
2385#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 1
2386
2387#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 2
2388template <class t_OUT, class t_ARGS_01,
2389 class t_ARGS_02>
2390inline
2391format_to_n_result<t_OUT>
2392format_to_n(t_OUT out,
2393 typename bsl::iterator_traits<t_OUT>::difference_type maxNumChars,
2394 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
2395 const t_ARGS_01& args_01,
2396 const t_ARGS_02& args_02);
2397#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 2
2398
2399#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 3
2400template <class t_OUT, class t_ARGS_01,
2401 class t_ARGS_02,
2402 class t_ARGS_03>
2403inline
2404format_to_n_result<t_OUT>
2405format_to_n(t_OUT out,
2406 typename bsl::iterator_traits<t_OUT>::difference_type maxNumChars,
2407 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
2408 const t_ARGS_01& args_01,
2409 const t_ARGS_02& args_02,
2410 const t_ARGS_03& args_03);
2411#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 3
2412
2413#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 4
2414template <class t_OUT, class t_ARGS_01,
2415 class t_ARGS_02,
2416 class t_ARGS_03,
2417 class t_ARGS_04>
2418inline
2419format_to_n_result<t_OUT>
2420format_to_n(t_OUT out,
2421 typename bsl::iterator_traits<t_OUT>::difference_type maxNumChars,
2422 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
2423 const t_ARGS_01& args_01,
2424 const t_ARGS_02& args_02,
2425 const t_ARGS_03& args_03,
2426 const t_ARGS_04& args_04);
2427#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 4
2428
2429#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 5
2430template <class t_OUT, class t_ARGS_01,
2431 class t_ARGS_02,
2432 class t_ARGS_03,
2433 class t_ARGS_04,
2434 class t_ARGS_05>
2435inline
2436format_to_n_result<t_OUT>
2437format_to_n(t_OUT out,
2438 typename bsl::iterator_traits<t_OUT>::difference_type maxNumChars,
2439 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
2440 const t_ARGS_01& args_01,
2441 const t_ARGS_02& args_02,
2442 const t_ARGS_03& args_03,
2443 const t_ARGS_04& args_04,
2444 const t_ARGS_05& args_05);
2445#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 5
2446
2447#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 6
2448template <class t_OUT, class t_ARGS_01,
2449 class t_ARGS_02,
2450 class t_ARGS_03,
2451 class t_ARGS_04,
2452 class t_ARGS_05,
2453 class t_ARGS_06>
2454inline
2455format_to_n_result<t_OUT>
2456format_to_n(t_OUT out,
2457 typename bsl::iterator_traits<t_OUT>::difference_type maxNumChars,
2458 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
2459 const t_ARGS_01& args_01,
2460 const t_ARGS_02& args_02,
2461 const t_ARGS_03& args_03,
2462 const t_ARGS_04& args_04,
2463 const t_ARGS_05& args_05,
2464 const t_ARGS_06& args_06);
2465#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 6
2466
2467#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 7
2468template <class t_OUT, class t_ARGS_01,
2469 class t_ARGS_02,
2470 class t_ARGS_03,
2471 class t_ARGS_04,
2472 class t_ARGS_05,
2473 class t_ARGS_06,
2474 class t_ARGS_07>
2475inline
2476format_to_n_result<t_OUT>
2477format_to_n(t_OUT out,
2478 typename bsl::iterator_traits<t_OUT>::difference_type maxNumChars,
2479 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
2480 const t_ARGS_01& args_01,
2481 const t_ARGS_02& args_02,
2482 const t_ARGS_03& args_03,
2483 const t_ARGS_04& args_04,
2484 const t_ARGS_05& args_05,
2485 const t_ARGS_06& args_06,
2486 const t_ARGS_07& args_07);
2487#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 7
2488
2489#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 8
2490template <class t_OUT, class t_ARGS_01,
2491 class t_ARGS_02,
2492 class t_ARGS_03,
2493 class t_ARGS_04,
2494 class t_ARGS_05,
2495 class t_ARGS_06,
2496 class t_ARGS_07,
2497 class t_ARGS_08>
2498inline
2499format_to_n_result<t_OUT>
2500format_to_n(t_OUT out,
2501 typename bsl::iterator_traits<t_OUT>::difference_type maxNumChars,
2502 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
2503 const t_ARGS_01& args_01,
2504 const t_ARGS_02& args_02,
2505 const t_ARGS_03& args_03,
2506 const t_ARGS_04& args_04,
2507 const t_ARGS_05& args_05,
2508 const t_ARGS_06& args_06,
2509 const t_ARGS_07& args_07,
2510 const t_ARGS_08& args_08);
2511#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 8
2512
2513#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 9
2514template <class t_OUT, class t_ARGS_01,
2515 class t_ARGS_02,
2516 class t_ARGS_03,
2517 class t_ARGS_04,
2518 class t_ARGS_05,
2519 class t_ARGS_06,
2520 class t_ARGS_07,
2521 class t_ARGS_08,
2522 class t_ARGS_09>
2523inline
2524format_to_n_result<t_OUT>
2525format_to_n(t_OUT out,
2526 typename bsl::iterator_traits<t_OUT>::difference_type maxNumChars,
2527 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
2528 const t_ARGS_01& args_01,
2529 const t_ARGS_02& args_02,
2530 const t_ARGS_03& args_03,
2531 const t_ARGS_04& args_04,
2532 const t_ARGS_05& args_05,
2533 const t_ARGS_06& args_06,
2534 const t_ARGS_07& args_07,
2535 const t_ARGS_08& args_08,
2536 const t_ARGS_09& args_09);
2537#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 9
2538
2539#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 10
2540template <class t_OUT, class t_ARGS_01,
2541 class t_ARGS_02,
2542 class t_ARGS_03,
2543 class t_ARGS_04,
2544 class t_ARGS_05,
2545 class t_ARGS_06,
2546 class t_ARGS_07,
2547 class t_ARGS_08,
2548 class t_ARGS_09,
2549 class t_ARGS_10>
2550inline
2551format_to_n_result<t_OUT>
2552format_to_n(t_OUT out,
2553 typename bsl::iterator_traits<t_OUT>::difference_type maxNumChars,
2554 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
2555 const t_ARGS_01& args_01,
2556 const t_ARGS_02& args_02,
2557 const t_ARGS_03& args_03,
2558 const t_ARGS_04& args_04,
2559 const t_ARGS_05& args_05,
2560 const t_ARGS_06& args_06,
2561 const t_ARGS_07& args_07,
2562 const t_ARGS_08& args_08,
2563 const t_ARGS_09& args_09,
2564 const t_ARGS_10& args_10);
2565#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_A >= 10
2566
2567#else
2568// The generated code below is a workaround for the absence of perfect
2569// forwarding in some compilers.
2570template <class t_OUT, class... t_ARGS>
2571typename bsl::enable_if<
2572 !bsl::is_same<typename bsl::decay<t_OUT>::type, bsl::string *>::value,
2573 t_OUT>::type
2574inline
2575format_to(t_OUT out,
2576 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
2577 const t_ARGS&... args);
2578
2579template <class t_OUT, class... t_ARGS>
2580typename bsl::enable_if<
2581 !bsl::is_same<typename bsl::decay<t_OUT>::type, bsl::wstring *>::value,
2582 t_OUT>::type
2583inline
2584format_to(t_OUT out,
2585 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
2586 const t_ARGS&... args);
2587
2588template <class... t_ARGS>
2589inline
2590void format_to(bsl::string *out,
2591 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
2592 const t_ARGS&... args);
2593
2594template <class... t_ARGS>
2595inline
2596void format_to(bsl::wstring *out,
2597 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
2598 const t_ARGS&... args);
2599
2600template <class... t_ARGS>
2601inline
2602bsl::string format(BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
2603 const t_ARGS&... args);
2604
2605template <class... t_ARGS>
2606inline
2607bsl::wstring format(BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
2608 const t_ARGS&... args);
2609
2610template <class... t_ARGS>
2611inline
2612bsl::string format(bsl::allocator<char> alloc,
2613 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
2614 const t_ARGS&... args);
2615
2616template <class... t_ARGS>
2617inline
2618bsl::wstring format(bsl::allocator<wchar_t> alloc,
2619 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
2620 const t_ARGS&... args);
2621
2622template <class... t_ARGS>
2623inline
2624std::size_t formatted_size(BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
2625 const t_ARGS&... args);
2626
2627template <class... t_ARGS>
2628inline
2629std::size_t formatted_size(BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
2630 const t_ARGS&... args);
2631
2632template <class t_OUT, class... t_ARGS>
2633inline
2634format_to_n_result<t_OUT>
2635format_to_n(t_OUT out,
2636 typename bsl::iterator_traits<t_OUT>::difference_type maxNumChars,
2637 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
2638 const t_ARGS&... args);
2639
2640template <class t_OUT, class... t_ARGS>
2641inline
2642format_to_n_result<t_OUT>
2643format_to_n(t_OUT out,
2644 typename bsl::iterator_traits<t_OUT>::difference_type maxNumChars,
2645 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
2646 const t_ARGS&... args);
2647
2648// }}} END GENERATED CODE
2649#endif
2650
2651
2652// ============================================================================
2653// INLINE DEFINITIONS
2654// ============================================================================
2655
2656 // -----------------------------------
2657 // class Format_Imp_TruncatingIterator
2658 // -----------------------------------
2659
2660// CREATORS
2661template <class t_ITERATOR, class t_VALUE_TYPE, class t_DIFF_TYPE>
2662Format_Imp_TruncatingIterator<t_ITERATOR, t_VALUE_TYPE, t_DIFF_TYPE>::
2663 Format_Imp_TruncatingIterator(t_ITERATOR iterator, t_DIFF_TYPE limit)
2664: d_iterator(iterator)
2665, d_limit(limit)
2666, d_count(0)
2667{
2668}
2669
2670// MANIPULATORS
2671template <class t_ITERATOR, class t_VALUE_TYPE, class t_DIFF_TYPE>
2672Format_Imp_TruncatingIterator<t_ITERATOR, t_VALUE_TYPE, t_DIFF_TYPE>&
2673Format_Imp_TruncatingIterator<t_ITERATOR, t_VALUE_TYPE, t_DIFF_TYPE>::
2674operator*()
2675{
2676 return *this;
2677}
2678
2679template <class t_ITERATOR, class t_VALUE_TYPE, class t_DIFF_TYPE>
2680void Format_Imp_TruncatingIterator<t_ITERATOR, t_VALUE_TYPE, t_DIFF_TYPE>::
2681operator=(t_VALUE_TYPE x)
2682{
2683 if (d_count++ < d_limit) {
2684 *d_iterator = x;
2685 // We deliberately use prefix not postfix increment, as the postfix
2686 // increment operator returns by value which could cause issues with
2687 // counting or other stateful iterators.
2688 ++d_iterator;
2689 }
2690}
2691
2692template <class t_ITERATOR, class t_VALUE_TYPE, class t_DIFF_TYPE>
2693Format_Imp_TruncatingIterator<t_ITERATOR, t_VALUE_TYPE, t_DIFF_TYPE>&
2694Format_Imp_TruncatingIterator<t_ITERATOR, t_VALUE_TYPE, t_DIFF_TYPE>::
2695operator++()
2696{
2697 return *this;
2698}
2699
2700// ACCESSORS
2701template <class t_ITERATOR, class t_VALUE_TYPE, class t_DIFF_TYPE>
2702t_DIFF_TYPE
2703Format_Imp_TruncatingIterator<t_ITERATOR, t_VALUE_TYPE, t_DIFF_TYPE>::count()
2704 const
2705{
2706 return d_count;
2707}
2708
2709template <class t_ITERATOR, class t_VALUE_TYPE, class t_DIFF_TYPE>
2710t_ITERATOR Format_Imp_TruncatingIterator<t_ITERATOR,
2711 t_VALUE_TYPE,
2712 t_DIFF_TYPE>::underlying() const
2713{
2714 return d_iterator;
2715}
2716
2717 // ------------------------
2718 // class Format_Imp_Visitor
2719 // ------------------------
2720
2721// CREATORS
2722
2723template <class t_OUT, class t_CHAR>
2724Format_Imp_Visitor<t_OUT, t_CHAR>::Format_Imp_Visitor(
2725 basic_format_parse_context<t_CHAR>& pc,
2726 basic_format_context<t_OUT, t_CHAR>& fc)
2727: d_parseContext_p(&pc)
2728, d_formatContext_p(&fc)
2729{
2730}
2731
2732// MANIPULATORS
2733
2734template <class t_OUT, class t_CHAR>
2735void Format_Imp_Visitor<t_OUT, t_CHAR>::operator()(bsl::monostate) const
2736{
2737 BSLS_ASSERT_OPT_UNREACHABLE(
2738 "This call should be impossible - arg uninitialized");
2739 BSLS_THROW(
2740 format_error("This call should be impossible - arg uninitialized"));
2741}
2742
2743template <class t_OUT, class t_CHAR>
2744void Format_Imp_Visitor<t_OUT, t_CHAR>::operator()(bool value) const
2745{
2746 bsl::formatter<bool, t_CHAR> f;
2747 d_parseContext_p->advance_to(f.parse(*d_parseContext_p));
2748 d_formatContext_p->advance_to(bsl::as_const(f).format(value,
2749 *d_formatContext_p));
2750}
2751
2752template <class t_OUT, class t_CHAR>
2753void Format_Imp_Visitor<t_OUT, t_CHAR>::operator()(t_CHAR value) const
2754{
2755 bsl::formatter<t_CHAR, t_CHAR> f;
2756 d_parseContext_p->advance_to(f.parse(*d_parseContext_p));
2757 d_formatContext_p->advance_to(bsl::as_const(f).format(value,
2758 *d_formatContext_p));
2759}
2760
2761template <class t_OUT, class t_CHAR>
2762void Format_Imp_Visitor<t_OUT, t_CHAR>::operator()(unsigned value) const
2763{
2764 bsl::formatter<unsigned, t_CHAR> f;
2765 d_parseContext_p->advance_to(f.parse(*d_parseContext_p));
2766 d_formatContext_p->advance_to(bsl::as_const(f).format(value,
2767 *d_formatContext_p));
2768}
2769
2770template <class t_OUT, class t_CHAR>
2771void Format_Imp_Visitor<t_OUT, t_CHAR>::operator()(long long value) const
2772{
2773 bsl::formatter<long long, t_CHAR> f;
2774 d_parseContext_p->advance_to(f.parse(*d_parseContext_p));
2775 d_formatContext_p->advance_to(bsl::as_const(f).format(value,
2776 *d_formatContext_p));
2777}
2778
2779template <class t_OUT, class t_CHAR>
2780void Format_Imp_Visitor<t_OUT, t_CHAR>::operator()(
2781 unsigned long long value) const
2782{
2783 bsl::formatter<unsigned long long, t_CHAR> f;
2784 d_parseContext_p->advance_to(f.parse(*d_parseContext_p));
2785 d_formatContext_p->advance_to(bsl::as_const(f).format(value,
2786 *d_formatContext_p));
2787}
2788
2789template <class t_OUT, class t_CHAR>
2790void Format_Imp_Visitor<t_OUT, t_CHAR>::operator()(float value) const
2791{
2792 bsl::formatter<float, t_CHAR> f;
2793 d_parseContext_p->advance_to(f.parse(*d_parseContext_p));
2794 d_formatContext_p->advance_to(bsl::as_const(f).format(value,
2795 *d_formatContext_p));
2796}
2797
2798template <class t_OUT, class t_CHAR>
2799void Format_Imp_Visitor<t_OUT, t_CHAR>::operator()(double value) const
2800{
2801 bsl::formatter<double, t_CHAR> f;
2802 d_parseContext_p->advance_to(f.parse(*d_parseContext_p));
2803 d_formatContext_p->advance_to(bsl::as_const(f).format(value,
2804 *d_formatContext_p));
2805}
2806
2807template <class t_OUT, class t_CHAR>
2808void Format_Imp_Visitor<t_OUT, t_CHAR>::operator()(long double value) const
2809{
2810 bsl::formatter<long double, t_CHAR> f;
2811 d_parseContext_p->advance_to(f.parse(*d_parseContext_p));
2812 d_formatContext_p->advance_to(bsl::as_const(f).format(value,
2813 *d_formatContext_p));
2814}
2815
2816template <class t_OUT, class t_CHAR>
2817void Format_Imp_Visitor<t_OUT, t_CHAR>::operator()(const t_CHAR *value) const
2818{
2819 bsl::formatter<const t_CHAR *, t_CHAR> f;
2820 d_parseContext_p->advance_to(f.parse(*d_parseContext_p));
2821 d_formatContext_p->advance_to(bsl::as_const(f).format(value,
2822 *d_formatContext_p));
2823}
2824
2825template <class t_OUT, class t_CHAR>
2826void Format_Imp_Visitor<t_OUT, t_CHAR>::operator()(const void *value) const
2827{
2828 bsl::formatter<const void *, t_CHAR> f;
2829 d_parseContext_p->advance_to(f.parse(*d_parseContext_p));
2830 d_formatContext_p->advance_to(bsl::as_const(f).format(value,
2831 *d_formatContext_p));
2832}
2833
2834template <class t_OUT, class t_CHAR>
2835void Format_Imp_Visitor<t_OUT, t_CHAR>::operator()(int value) const
2836{
2837 bsl::formatter<int, t_CHAR> f;
2838 d_parseContext_p->advance_to(f.parse(*d_parseContext_p));
2839 d_formatContext_p->advance_to(bsl::as_const(f).format(value,
2840 *d_formatContext_p));
2841}
2842
2843template <class t_OUT, class t_CHAR>
2844void Format_Imp_Visitor<t_OUT, t_CHAR>::operator()(
2845 bsl::basic_string_view<t_CHAR> value) const
2846{
2847 bsl::formatter<bsl::basic_string_view<t_CHAR>, t_CHAR> f;
2848 d_parseContext_p->advance_to(f.parse(*d_parseContext_p));
2849 d_formatContext_p->advance_to(bsl::as_const(f).format(value,
2850 *d_formatContext_p));
2851}
2852
2853template <class t_OUT, class t_CHAR>
2854void Format_Imp_Visitor<t_OUT, t_CHAR>::operator()(const handle& h) const
2855{
2856 h.format(*d_parseContext_p, *d_formatContext_p);
2857}
2858
2859 // --------------------------
2860 // class Format_Imp_Processor
2861 // --------------------------
2862
2863template <class t_CHAR>
2864template <class t_OUT>
2865t_OUT Format_Imp_Processor<t_CHAR>::processImp(
2866 t_OUT& out,
2867 bsl::basic_string_view<t_CHAR> fmtStr,
2868 const basic_format_args<basic_format_context<t_OUT, t_CHAR> >& args)
2869 // The actual meat of the implementation.
2870{
2871 const size_t argSize = Format_ArgsUtil::formatArgsSize(args);
2872
2873 basic_format_parse_context<t_CHAR> pc(fmtStr, argSize);
2874 basic_format_context<t_OUT, t_CHAR> fc(
2875 Format_ContextFactory::construct(out, args));
2876 Format_Imp_Visitor<t_OUT, t_CHAR> visitor(pc, fc);
2877
2878 typename bsl::basic_string_view<t_CHAR>::iterator it = pc.begin();
2879
2880 while (it != pc.end()) {
2881 if (*it == '{') {
2882 ++it;
2883 if (it == pc.end()) {
2884 BSLS_THROW(format_error("unmatched {"));
2885 }
2886 else if (*it == '{') {
2887 // literal {
2888 ++it;
2889 out = fc.out();
2890 *out = '{';
2891 ++out; // prefer prefix increment
2892 fc.advance_to(out);
2893 continue; // CONTINUE
2894 }
2895 size_t id = -1;
2896 if (*it >= '0' && *it <= '9') {
2897 // numeric ID
2898 id = 0;
2899 while (it != pc.end() && *it >= '0' && *it <= '9') {
2900 id = 10 * id + (*it - '0');
2901 ++it;
2902 if (id >= argSize) {
2903 BSLS_THROW(format_error("arg id too large"));
2904 }
2905 }
2906 if (it == pc.end()) {
2907 BSLS_THROW(format_error("unmatched {"));
2908 }
2909 }
2910 if (id == size_t(-1)) {
2911 id = pc.next_arg_id();
2912 }
2913 else {
2914 pc.check_arg_id(id);
2915 }
2916
2917 // Separator between arg Id and format specification
2918
2919 if (*it == ':') {
2920 ++it;
2921 }
2922 else if (*it != '}') {
2923 BSLS_THROW(format_error("Separator ':' missing"));
2924 }
2925
2926 pc.advance_to(it);
2927 visit_format_arg(visitor, args.get(id));
2928 it = pc.begin();
2929 if (it != pc.end()) {
2930 if (*it != '}') {
2931 BSLS_THROW(format_error("parsing terminated before }"));
2932 }
2933 // advance past the terminating }
2934 ++it;
2935 }
2936 out = fc.out();
2937 }
2938 else if (*it == '}') {
2939 // must be escaped
2940 ++it;
2941 if (it == pc.end() || *it != '}') {
2942 BSLS_THROW(format_error("} must be escaped"));
2943 }
2944 ++it;
2945 out = fc.out();
2946 *out = '}';
2947 ++out; // prefer prefix increment
2948 fc.advance_to(out);
2949 }
2950 else {
2951 // just copy it
2952 out = fc.out();
2953 *out = *it;
2954 ++out;
2955 ++it;
2956 fc.advance_to(out);
2957 }
2958 }
2959 return fc.out();
2960}
2961
2962template <class t_CHAR>
2963Format_ContextOutputIteratorRef<t_CHAR> Format_Imp_Processor<t_CHAR>::process(
2964 Format_ContextOutputIteratorRef<t_CHAR> out,
2965 bsl::basic_string_view<t_CHAR> fmtStr,
2966 const basic_format_args<
2967 basic_format_context<Format_ContextOutputIteratorRef<t_CHAR>,
2968 t_CHAR> >& args)
2969{
2970 processImp(out, fmtStr, args);
2971 return out;
2972}
2973
2974template <class t_CHAR>
2975template <class t_OUT, class t_CONTEXT>
2976t_OUT Format_Imp_Processor<t_CHAR>::process(
2977 t_OUT out,
2978 bsl::basic_string_view<t_CHAR> fmtStr,
2979 const basic_format_args<t_CONTEXT>& args)
2980{
2981 Format_ContextOutputIteratorImpl<t_CHAR, t_OUT> wrappedOut(out);
2982 Format_ContextOutputIteratorRef<t_CHAR> wrappedOutRef(&wrappedOut);
2983 processImp(wrappedOutRef, fmtStr, args);
2984 return out;
2985}
2986
2987// FREE FUNCTIONS
2988
2989template <class t_OUT>
2990inline
2991t_OUT vformat_to(t_OUT out, bsl::string_view fmtStr, format_args args)
2992{
2993 return Format_Imp_Processor<char>::process(out, fmtStr, args);
2994}
2995
2996template <class t_OUT>
2997inline
2998t_OUT vformat_to(t_OUT out, bsl::wstring_view fmtStr, wformat_args args)
2999{
3000 return Format_Imp_Processor<wchar_t>::process(out, fmtStr, args);
3001}
3002
3003inline
3004void vformat_to(bsl::string *out, bsl::string_view fmtStr, format_args args)
3005{
3006 vformat_to(bsl::back_inserter(*out), fmtStr, args);
3007}
3008
3009inline
3010void vformat_to(bsl::wstring *out, bsl::wstring_view fmtStr, wformat_args args)
3011{
3012 vformat_to(bsl::back_inserter(*out), fmtStr, args);
3013}
3014
3015inline
3016bsl::string vformat(bsl::string_view fmtStr, format_args args)
3017{
3018 bsl::string result;
3019 vformat_to(&result, fmtStr, args);
3020 return result;
3021}
3022
3023inline
3024bsl::wstring vformat(bsl::wstring_view fmtStr, wformat_args args)
3025{
3026 bsl::wstring result;
3027 vformat_to(&result, fmtStr, args);
3028 return result;
3029}
3030
3031inline
3032bsl::string vformat(bsl::allocator<char> alloc,
3033 bsl::string_view fmtStr,
3034 format_args args)
3035{
3036 bsl::string result(alloc);
3037 vformat_to(&result, fmtStr, args);
3038 return bsl::string(result, alloc);
3039}
3040
3041inline
3042bsl::wstring vformat(bsl::allocator<wchar_t> alloc,
3043 bsl::wstring_view fmtStr,
3044 wformat_args args)
3045{
3046 bsl::wstring result(alloc);
3047 vformat_to(&result, fmtStr, args);
3048 return bsl::wstring(result, alloc);
3049}
3050
3051#if BSLS_COMPILERFEATURES_SIMULATE_VARIADIC_TEMPLATES
3052// {{{ BEGIN GENERATED CODE
3053// Command line: sim_cpp11_features.pl bslfmt_format_imp.h
3054#ifndef BSLFMT_FORMAT_IMP_VARIADIC_LIMIT
3055#define BSLFMT_FORMAT_IMP_VARIADIC_LIMIT 10
3056#endif
3057#ifndef BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B
3058#define BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B BSLFMT_FORMAT_IMP_VARIADIC_LIMIT
3059#endif
3060#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 0
3061template <class t_OUT>
3062typename bsl::enable_if<
3063 !bsl::is_same<typename bsl::decay<t_OUT>::type, bsl::string *>::value,
3064 t_OUT>::type
3065format_to(t_OUT out,
3066 BSLFMT_FORMAT_STRING_PARAMETER fmtStr)
3067{
3068 return vformat_to(out, fmtStr.get(), bslfmt::make_format_args());
3069}
3070#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 0
3071
3072#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 1
3073template <class t_OUT, class t_ARGS_01>
3074typename bsl::enable_if<
3075 !bsl::is_same<typename bsl::decay<t_OUT>::type, bsl::string *>::value,
3076 t_OUT>::type
3077format_to(t_OUT out,
3078 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
3079 const t_ARGS_01& args_01)
3080{
3081 return vformat_to(out, fmtStr.get(), bslfmt::make_format_args(args_01));
3082}
3083#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 1
3084
3085#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 2
3086template <class t_OUT, class t_ARGS_01,
3087 class t_ARGS_02>
3088typename bsl::enable_if<
3089 !bsl::is_same<typename bsl::decay<t_OUT>::type, bsl::string *>::value,
3090 t_OUT>::type
3091format_to(t_OUT out,
3092 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
3093 const t_ARGS_01& args_01,
3094 const t_ARGS_02& args_02)
3095{
3096 return vformat_to(out, fmtStr.get(), bslfmt::make_format_args(args_01,
3097 args_02));
3098}
3099#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 2
3100
3101#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 3
3102template <class t_OUT, class t_ARGS_01,
3103 class t_ARGS_02,
3104 class t_ARGS_03>
3105typename bsl::enable_if<
3106 !bsl::is_same<typename bsl::decay<t_OUT>::type, bsl::string *>::value,
3107 t_OUT>::type
3108format_to(t_OUT out,
3109 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
3110 const t_ARGS_01& args_01,
3111 const t_ARGS_02& args_02,
3112 const t_ARGS_03& args_03)
3113{
3114 return vformat_to(out, fmtStr.get(), bslfmt::make_format_args(args_01,
3115 args_02,
3116 args_03));
3117}
3118#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 3
3119
3120#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 4
3121template <class t_OUT, class t_ARGS_01,
3122 class t_ARGS_02,
3123 class t_ARGS_03,
3124 class t_ARGS_04>
3125typename bsl::enable_if<
3126 !bsl::is_same<typename bsl::decay<t_OUT>::type, bsl::string *>::value,
3127 t_OUT>::type
3128format_to(t_OUT out,
3129 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
3130 const t_ARGS_01& args_01,
3131 const t_ARGS_02& args_02,
3132 const t_ARGS_03& args_03,
3133 const t_ARGS_04& args_04)
3134{
3135 return vformat_to(out, fmtStr.get(), bslfmt::make_format_args(args_01,
3136 args_02,
3137 args_03,
3138 args_04));
3139}
3140#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 4
3141
3142#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 5
3143template <class t_OUT, class t_ARGS_01,
3144 class t_ARGS_02,
3145 class t_ARGS_03,
3146 class t_ARGS_04,
3147 class t_ARGS_05>
3148typename bsl::enable_if<
3149 !bsl::is_same<typename bsl::decay<t_OUT>::type, bsl::string *>::value,
3150 t_OUT>::type
3151format_to(t_OUT out,
3152 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
3153 const t_ARGS_01& args_01,
3154 const t_ARGS_02& args_02,
3155 const t_ARGS_03& args_03,
3156 const t_ARGS_04& args_04,
3157 const t_ARGS_05& args_05)
3158{
3159 return vformat_to(out, fmtStr.get(), bslfmt::make_format_args(args_01,
3160 args_02,
3161 args_03,
3162 args_04,
3163 args_05));
3164}
3165#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 5
3166
3167#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 6
3168template <class t_OUT, class t_ARGS_01,
3169 class t_ARGS_02,
3170 class t_ARGS_03,
3171 class t_ARGS_04,
3172 class t_ARGS_05,
3173 class t_ARGS_06>
3174typename bsl::enable_if<
3175 !bsl::is_same<typename bsl::decay<t_OUT>::type, bsl::string *>::value,
3176 t_OUT>::type
3177format_to(t_OUT out,
3178 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
3179 const t_ARGS_01& args_01,
3180 const t_ARGS_02& args_02,
3181 const t_ARGS_03& args_03,
3182 const t_ARGS_04& args_04,
3183 const t_ARGS_05& args_05,
3184 const t_ARGS_06& args_06)
3185{
3186 return vformat_to(out, fmtStr.get(), bslfmt::make_format_args(args_01,
3187 args_02,
3188 args_03,
3189 args_04,
3190 args_05,
3191 args_06));
3192}
3193#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 6
3194
3195#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 7
3196template <class t_OUT, class t_ARGS_01,
3197 class t_ARGS_02,
3198 class t_ARGS_03,
3199 class t_ARGS_04,
3200 class t_ARGS_05,
3201 class t_ARGS_06,
3202 class t_ARGS_07>
3203typename bsl::enable_if<
3204 !bsl::is_same<typename bsl::decay<t_OUT>::type, bsl::string *>::value,
3205 t_OUT>::type
3206format_to(t_OUT out,
3207 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
3208 const t_ARGS_01& args_01,
3209 const t_ARGS_02& args_02,
3210 const t_ARGS_03& args_03,
3211 const t_ARGS_04& args_04,
3212 const t_ARGS_05& args_05,
3213 const t_ARGS_06& args_06,
3214 const t_ARGS_07& args_07)
3215{
3216 return vformat_to(out, fmtStr.get(), bslfmt::make_format_args(args_01,
3217 args_02,
3218 args_03,
3219 args_04,
3220 args_05,
3221 args_06,
3222 args_07));
3223}
3224#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 7
3225
3226#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 8
3227template <class t_OUT, class t_ARGS_01,
3228 class t_ARGS_02,
3229 class t_ARGS_03,
3230 class t_ARGS_04,
3231 class t_ARGS_05,
3232 class t_ARGS_06,
3233 class t_ARGS_07,
3234 class t_ARGS_08>
3235typename bsl::enable_if<
3236 !bsl::is_same<typename bsl::decay<t_OUT>::type, bsl::string *>::value,
3237 t_OUT>::type
3238format_to(t_OUT out,
3239 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
3240 const t_ARGS_01& args_01,
3241 const t_ARGS_02& args_02,
3242 const t_ARGS_03& args_03,
3243 const t_ARGS_04& args_04,
3244 const t_ARGS_05& args_05,
3245 const t_ARGS_06& args_06,
3246 const t_ARGS_07& args_07,
3247 const t_ARGS_08& args_08)
3248{
3249 return vformat_to(out, fmtStr.get(), bslfmt::make_format_args(args_01,
3250 args_02,
3251 args_03,
3252 args_04,
3253 args_05,
3254 args_06,
3255 args_07,
3256 args_08));
3257}
3258#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 8
3259
3260#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 9
3261template <class t_OUT, class t_ARGS_01,
3262 class t_ARGS_02,
3263 class t_ARGS_03,
3264 class t_ARGS_04,
3265 class t_ARGS_05,
3266 class t_ARGS_06,
3267 class t_ARGS_07,
3268 class t_ARGS_08,
3269 class t_ARGS_09>
3270typename bsl::enable_if<
3271 !bsl::is_same<typename bsl::decay<t_OUT>::type, bsl::string *>::value,
3272 t_OUT>::type
3273format_to(t_OUT out,
3274 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
3275 const t_ARGS_01& args_01,
3276 const t_ARGS_02& args_02,
3277 const t_ARGS_03& args_03,
3278 const t_ARGS_04& args_04,
3279 const t_ARGS_05& args_05,
3280 const t_ARGS_06& args_06,
3281 const t_ARGS_07& args_07,
3282 const t_ARGS_08& args_08,
3283 const t_ARGS_09& args_09)
3284{
3285 return vformat_to(out, fmtStr.get(), bslfmt::make_format_args(args_01,
3286 args_02,
3287 args_03,
3288 args_04,
3289 args_05,
3290 args_06,
3291 args_07,
3292 args_08,
3293 args_09));
3294}
3295#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 9
3296
3297#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 10
3298template <class t_OUT, class t_ARGS_01,
3299 class t_ARGS_02,
3300 class t_ARGS_03,
3301 class t_ARGS_04,
3302 class t_ARGS_05,
3303 class t_ARGS_06,
3304 class t_ARGS_07,
3305 class t_ARGS_08,
3306 class t_ARGS_09,
3307 class t_ARGS_10>
3308typename bsl::enable_if<
3309 !bsl::is_same<typename bsl::decay<t_OUT>::type, bsl::string *>::value,
3310 t_OUT>::type
3311format_to(t_OUT out,
3312 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
3313 const t_ARGS_01& args_01,
3314 const t_ARGS_02& args_02,
3315 const t_ARGS_03& args_03,
3316 const t_ARGS_04& args_04,
3317 const t_ARGS_05& args_05,
3318 const t_ARGS_06& args_06,
3319 const t_ARGS_07& args_07,
3320 const t_ARGS_08& args_08,
3321 const t_ARGS_09& args_09,
3322 const t_ARGS_10& args_10)
3323{
3324 return vformat_to(out, fmtStr.get(), bslfmt::make_format_args(args_01,
3325 args_02,
3326 args_03,
3327 args_04,
3328 args_05,
3329 args_06,
3330 args_07,
3331 args_08,
3332 args_09,
3333 args_10));
3334}
3335#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 10
3336
3337
3338#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 0
3339template <class t_OUT>
3340typename bsl::enable_if<
3341 !bsl::is_same<typename bsl::decay<t_OUT>::type, bsl::wstring *>::value,
3342 t_OUT>::type
3343format_to(t_OUT out,
3344 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr)
3345{
3346 return vformat_to(out, fmtStr.get(), bslfmt::make_wformat_args());
3347}
3348#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 0
3349
3350#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 1
3351template <class t_OUT, class t_ARGS_01>
3352typename bsl::enable_if<
3353 !bsl::is_same<typename bsl::decay<t_OUT>::type, bsl::wstring *>::value,
3354 t_OUT>::type
3355format_to(t_OUT out,
3356 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
3357 const t_ARGS_01& args_01)
3358{
3359 return vformat_to(out, fmtStr.get(), bslfmt::make_wformat_args(args_01));
3360}
3361#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 1
3362
3363#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 2
3364template <class t_OUT, class t_ARGS_01,
3365 class t_ARGS_02>
3366typename bsl::enable_if<
3367 !bsl::is_same<typename bsl::decay<t_OUT>::type, bsl::wstring *>::value,
3368 t_OUT>::type
3369format_to(t_OUT out,
3370 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
3371 const t_ARGS_01& args_01,
3372 const t_ARGS_02& args_02)
3373{
3374 return vformat_to(out, fmtStr.get(), bslfmt::make_wformat_args(args_01,
3375 args_02));
3376}
3377#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 2
3378
3379#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 3
3380template <class t_OUT, class t_ARGS_01,
3381 class t_ARGS_02,
3382 class t_ARGS_03>
3383typename bsl::enable_if<
3384 !bsl::is_same<typename bsl::decay<t_OUT>::type, bsl::wstring *>::value,
3385 t_OUT>::type
3386format_to(t_OUT out,
3387 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
3388 const t_ARGS_01& args_01,
3389 const t_ARGS_02& args_02,
3390 const t_ARGS_03& args_03)
3391{
3392 return vformat_to(out, fmtStr.get(), bslfmt::make_wformat_args(args_01,
3393 args_02,
3394 args_03));
3395}
3396#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 3
3397
3398#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 4
3399template <class t_OUT, class t_ARGS_01,
3400 class t_ARGS_02,
3401 class t_ARGS_03,
3402 class t_ARGS_04>
3403typename bsl::enable_if<
3404 !bsl::is_same<typename bsl::decay<t_OUT>::type, bsl::wstring *>::value,
3405 t_OUT>::type
3406format_to(t_OUT out,
3407 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
3408 const t_ARGS_01& args_01,
3409 const t_ARGS_02& args_02,
3410 const t_ARGS_03& args_03,
3411 const t_ARGS_04& args_04)
3412{
3413 return vformat_to(out, fmtStr.get(), bslfmt::make_wformat_args(args_01,
3414 args_02,
3415 args_03,
3416 args_04));
3417}
3418#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 4
3419
3420#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 5
3421template <class t_OUT, class t_ARGS_01,
3422 class t_ARGS_02,
3423 class t_ARGS_03,
3424 class t_ARGS_04,
3425 class t_ARGS_05>
3426typename bsl::enable_if<
3427 !bsl::is_same<typename bsl::decay<t_OUT>::type, bsl::wstring *>::value,
3428 t_OUT>::type
3429format_to(t_OUT out,
3430 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
3431 const t_ARGS_01& args_01,
3432 const t_ARGS_02& args_02,
3433 const t_ARGS_03& args_03,
3434 const t_ARGS_04& args_04,
3435 const t_ARGS_05& args_05)
3436{
3437 return vformat_to(out, fmtStr.get(), bslfmt::make_wformat_args(args_01,
3438 args_02,
3439 args_03,
3440 args_04,
3441 args_05));
3442}
3443#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 5
3444
3445#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 6
3446template <class t_OUT, class t_ARGS_01,
3447 class t_ARGS_02,
3448 class t_ARGS_03,
3449 class t_ARGS_04,
3450 class t_ARGS_05,
3451 class t_ARGS_06>
3452typename bsl::enable_if<
3453 !bsl::is_same<typename bsl::decay<t_OUT>::type, bsl::wstring *>::value,
3454 t_OUT>::type
3455format_to(t_OUT out,
3456 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
3457 const t_ARGS_01& args_01,
3458 const t_ARGS_02& args_02,
3459 const t_ARGS_03& args_03,
3460 const t_ARGS_04& args_04,
3461 const t_ARGS_05& args_05,
3462 const t_ARGS_06& args_06)
3463{
3464 return vformat_to(out, fmtStr.get(), bslfmt::make_wformat_args(args_01,
3465 args_02,
3466 args_03,
3467 args_04,
3468 args_05,
3469 args_06));
3470}
3471#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 6
3472
3473#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 7
3474template <class t_OUT, class t_ARGS_01,
3475 class t_ARGS_02,
3476 class t_ARGS_03,
3477 class t_ARGS_04,
3478 class t_ARGS_05,
3479 class t_ARGS_06,
3480 class t_ARGS_07>
3481typename bsl::enable_if<
3482 !bsl::is_same<typename bsl::decay<t_OUT>::type, bsl::wstring *>::value,
3483 t_OUT>::type
3484format_to(t_OUT out,
3485 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
3486 const t_ARGS_01& args_01,
3487 const t_ARGS_02& args_02,
3488 const t_ARGS_03& args_03,
3489 const t_ARGS_04& args_04,
3490 const t_ARGS_05& args_05,
3491 const t_ARGS_06& args_06,
3492 const t_ARGS_07& args_07)
3493{
3494 return vformat_to(out, fmtStr.get(), bslfmt::make_wformat_args(args_01,
3495 args_02,
3496 args_03,
3497 args_04,
3498 args_05,
3499 args_06,
3500 args_07));
3501}
3502#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 7
3503
3504#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 8
3505template <class t_OUT, class t_ARGS_01,
3506 class t_ARGS_02,
3507 class t_ARGS_03,
3508 class t_ARGS_04,
3509 class t_ARGS_05,
3510 class t_ARGS_06,
3511 class t_ARGS_07,
3512 class t_ARGS_08>
3513typename bsl::enable_if<
3514 !bsl::is_same<typename bsl::decay<t_OUT>::type, bsl::wstring *>::value,
3515 t_OUT>::type
3516format_to(t_OUT out,
3517 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
3518 const t_ARGS_01& args_01,
3519 const t_ARGS_02& args_02,
3520 const t_ARGS_03& args_03,
3521 const t_ARGS_04& args_04,
3522 const t_ARGS_05& args_05,
3523 const t_ARGS_06& args_06,
3524 const t_ARGS_07& args_07,
3525 const t_ARGS_08& args_08)
3526{
3527 return vformat_to(out, fmtStr.get(), bslfmt::make_wformat_args(args_01,
3528 args_02,
3529 args_03,
3530 args_04,
3531 args_05,
3532 args_06,
3533 args_07,
3534 args_08));
3535}
3536#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 8
3537
3538#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 9
3539template <class t_OUT, class t_ARGS_01,
3540 class t_ARGS_02,
3541 class t_ARGS_03,
3542 class t_ARGS_04,
3543 class t_ARGS_05,
3544 class t_ARGS_06,
3545 class t_ARGS_07,
3546 class t_ARGS_08,
3547 class t_ARGS_09>
3548typename bsl::enable_if<
3549 !bsl::is_same<typename bsl::decay<t_OUT>::type, bsl::wstring *>::value,
3550 t_OUT>::type
3551format_to(t_OUT out,
3552 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
3553 const t_ARGS_01& args_01,
3554 const t_ARGS_02& args_02,
3555 const t_ARGS_03& args_03,
3556 const t_ARGS_04& args_04,
3557 const t_ARGS_05& args_05,
3558 const t_ARGS_06& args_06,
3559 const t_ARGS_07& args_07,
3560 const t_ARGS_08& args_08,
3561 const t_ARGS_09& args_09)
3562{
3563 return vformat_to(out, fmtStr.get(), bslfmt::make_wformat_args(args_01,
3564 args_02,
3565 args_03,
3566 args_04,
3567 args_05,
3568 args_06,
3569 args_07,
3570 args_08,
3571 args_09));
3572}
3573#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 9
3574
3575#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 10
3576template <class t_OUT, class t_ARGS_01,
3577 class t_ARGS_02,
3578 class t_ARGS_03,
3579 class t_ARGS_04,
3580 class t_ARGS_05,
3581 class t_ARGS_06,
3582 class t_ARGS_07,
3583 class t_ARGS_08,
3584 class t_ARGS_09,
3585 class t_ARGS_10>
3586typename bsl::enable_if<
3587 !bsl::is_same<typename bsl::decay<t_OUT>::type, bsl::wstring *>::value,
3588 t_OUT>::type
3589format_to(t_OUT out,
3590 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
3591 const t_ARGS_01& args_01,
3592 const t_ARGS_02& args_02,
3593 const t_ARGS_03& args_03,
3594 const t_ARGS_04& args_04,
3595 const t_ARGS_05& args_05,
3596 const t_ARGS_06& args_06,
3597 const t_ARGS_07& args_07,
3598 const t_ARGS_08& args_08,
3599 const t_ARGS_09& args_09,
3600 const t_ARGS_10& args_10)
3601{
3602 return vformat_to(out, fmtStr.get(), bslfmt::make_wformat_args(args_01,
3603 args_02,
3604 args_03,
3605 args_04,
3606 args_05,
3607 args_06,
3608 args_07,
3609 args_08,
3610 args_09,
3611 args_10));
3612}
3613#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 10
3614
3615
3616#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 0
3617void format_to(bsl::string *out,
3618 BSLFMT_FORMAT_STRING_PARAMETER fmtStr)
3619{
3620 vformat_to(bsl::back_inserter(*out),
3621 fmtStr.get(),
3622 bslfmt::make_format_args());
3623}
3624#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 0
3625
3626#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 1
3627template <class t_ARGS_01>
3628void format_to(bsl::string *out,
3629 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
3630 const t_ARGS_01& args_01)
3631{
3632 vformat_to(bsl::back_inserter(*out),
3633 fmtStr.get(),
3634 bslfmt::make_format_args(args_01));
3635}
3636#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 1
3637
3638#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 2
3639template <class t_ARGS_01,
3640 class t_ARGS_02>
3641void format_to(bsl::string *out,
3642 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
3643 const t_ARGS_01& args_01,
3644 const t_ARGS_02& args_02)
3645{
3646 vformat_to(bsl::back_inserter(*out),
3647 fmtStr.get(),
3648 bslfmt::make_format_args(args_01,
3649 args_02));
3650}
3651#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 2
3652
3653#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 3
3654template <class t_ARGS_01,
3655 class t_ARGS_02,
3656 class t_ARGS_03>
3657void format_to(bsl::string *out,
3658 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
3659 const t_ARGS_01& args_01,
3660 const t_ARGS_02& args_02,
3661 const t_ARGS_03& args_03)
3662{
3663 vformat_to(bsl::back_inserter(*out),
3664 fmtStr.get(),
3665 bslfmt::make_format_args(args_01,
3666 args_02,
3667 args_03));
3668}
3669#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 3
3670
3671#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 4
3672template <class t_ARGS_01,
3673 class t_ARGS_02,
3674 class t_ARGS_03,
3675 class t_ARGS_04>
3676void format_to(bsl::string *out,
3677 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
3678 const t_ARGS_01& args_01,
3679 const t_ARGS_02& args_02,
3680 const t_ARGS_03& args_03,
3681 const t_ARGS_04& args_04)
3682{
3683 vformat_to(bsl::back_inserter(*out),
3684 fmtStr.get(),
3685 bslfmt::make_format_args(args_01,
3686 args_02,
3687 args_03,
3688 args_04));
3689}
3690#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 4
3691
3692#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 5
3693template <class t_ARGS_01,
3694 class t_ARGS_02,
3695 class t_ARGS_03,
3696 class t_ARGS_04,
3697 class t_ARGS_05>
3698void format_to(bsl::string *out,
3699 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
3700 const t_ARGS_01& args_01,
3701 const t_ARGS_02& args_02,
3702 const t_ARGS_03& args_03,
3703 const t_ARGS_04& args_04,
3704 const t_ARGS_05& args_05)
3705{
3706 vformat_to(bsl::back_inserter(*out),
3707 fmtStr.get(),
3708 bslfmt::make_format_args(args_01,
3709 args_02,
3710 args_03,
3711 args_04,
3712 args_05));
3713}
3714#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 5
3715
3716#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 6
3717template <class t_ARGS_01,
3718 class t_ARGS_02,
3719 class t_ARGS_03,
3720 class t_ARGS_04,
3721 class t_ARGS_05,
3722 class t_ARGS_06>
3723void format_to(bsl::string *out,
3724 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
3725 const t_ARGS_01& args_01,
3726 const t_ARGS_02& args_02,
3727 const t_ARGS_03& args_03,
3728 const t_ARGS_04& args_04,
3729 const t_ARGS_05& args_05,
3730 const t_ARGS_06& args_06)
3731{
3732 vformat_to(bsl::back_inserter(*out),
3733 fmtStr.get(),
3734 bslfmt::make_format_args(args_01,
3735 args_02,
3736 args_03,
3737 args_04,
3738 args_05,
3739 args_06));
3740}
3741#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 6
3742
3743#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 7
3744template <class t_ARGS_01,
3745 class t_ARGS_02,
3746 class t_ARGS_03,
3747 class t_ARGS_04,
3748 class t_ARGS_05,
3749 class t_ARGS_06,
3750 class t_ARGS_07>
3751void format_to(bsl::string *out,
3752 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
3753 const t_ARGS_01& args_01,
3754 const t_ARGS_02& args_02,
3755 const t_ARGS_03& args_03,
3756 const t_ARGS_04& args_04,
3757 const t_ARGS_05& args_05,
3758 const t_ARGS_06& args_06,
3759 const t_ARGS_07& args_07)
3760{
3761 vformat_to(bsl::back_inserter(*out),
3762 fmtStr.get(),
3763 bslfmt::make_format_args(args_01,
3764 args_02,
3765 args_03,
3766 args_04,
3767 args_05,
3768 args_06,
3769 args_07));
3770}
3771#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 7
3772
3773#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 8
3774template <class t_ARGS_01,
3775 class t_ARGS_02,
3776 class t_ARGS_03,
3777 class t_ARGS_04,
3778 class t_ARGS_05,
3779 class t_ARGS_06,
3780 class t_ARGS_07,
3781 class t_ARGS_08>
3782void format_to(bsl::string *out,
3783 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
3784 const t_ARGS_01& args_01,
3785 const t_ARGS_02& args_02,
3786 const t_ARGS_03& args_03,
3787 const t_ARGS_04& args_04,
3788 const t_ARGS_05& args_05,
3789 const t_ARGS_06& args_06,
3790 const t_ARGS_07& args_07,
3791 const t_ARGS_08& args_08)
3792{
3793 vformat_to(bsl::back_inserter(*out),
3794 fmtStr.get(),
3795 bslfmt::make_format_args(args_01,
3796 args_02,
3797 args_03,
3798 args_04,
3799 args_05,
3800 args_06,
3801 args_07,
3802 args_08));
3803}
3804#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 8
3805
3806#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 9
3807template <class t_ARGS_01,
3808 class t_ARGS_02,
3809 class t_ARGS_03,
3810 class t_ARGS_04,
3811 class t_ARGS_05,
3812 class t_ARGS_06,
3813 class t_ARGS_07,
3814 class t_ARGS_08,
3815 class t_ARGS_09>
3816void format_to(bsl::string *out,
3817 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
3818 const t_ARGS_01& args_01,
3819 const t_ARGS_02& args_02,
3820 const t_ARGS_03& args_03,
3821 const t_ARGS_04& args_04,
3822 const t_ARGS_05& args_05,
3823 const t_ARGS_06& args_06,
3824 const t_ARGS_07& args_07,
3825 const t_ARGS_08& args_08,
3826 const t_ARGS_09& args_09)
3827{
3828 vformat_to(bsl::back_inserter(*out),
3829 fmtStr.get(),
3830 bslfmt::make_format_args(args_01,
3831 args_02,
3832 args_03,
3833 args_04,
3834 args_05,
3835 args_06,
3836 args_07,
3837 args_08,
3838 args_09));
3839}
3840#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 9
3841
3842#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 10
3843template <class t_ARGS_01,
3844 class t_ARGS_02,
3845 class t_ARGS_03,
3846 class t_ARGS_04,
3847 class t_ARGS_05,
3848 class t_ARGS_06,
3849 class t_ARGS_07,
3850 class t_ARGS_08,
3851 class t_ARGS_09,
3852 class t_ARGS_10>
3853void format_to(bsl::string *out,
3854 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
3855 const t_ARGS_01& args_01,
3856 const t_ARGS_02& args_02,
3857 const t_ARGS_03& args_03,
3858 const t_ARGS_04& args_04,
3859 const t_ARGS_05& args_05,
3860 const t_ARGS_06& args_06,
3861 const t_ARGS_07& args_07,
3862 const t_ARGS_08& args_08,
3863 const t_ARGS_09& args_09,
3864 const t_ARGS_10& args_10)
3865{
3866 vformat_to(bsl::back_inserter(*out),
3867 fmtStr.get(),
3868 bslfmt::make_format_args(args_01,
3869 args_02,
3870 args_03,
3871 args_04,
3872 args_05,
3873 args_06,
3874 args_07,
3875 args_08,
3876 args_09,
3877 args_10));
3878}
3879#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 10
3880
3881
3882#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 0
3883void format_to(bsl::wstring *out,
3884 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr)
3885{
3886 vformat_to(bsl::back_inserter(*out),
3887 fmtStr.get(),
3888 bslfmt::make_wformat_args());
3889}
3890#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 0
3891
3892#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 1
3893template <class t_ARGS_01>
3894void format_to(bsl::wstring *out,
3895 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
3896 const t_ARGS_01& args_01)
3897{
3898 vformat_to(bsl::back_inserter(*out),
3899 fmtStr.get(),
3900 bslfmt::make_wformat_args(args_01));
3901}
3902#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 1
3903
3904#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 2
3905template <class t_ARGS_01,
3906 class t_ARGS_02>
3907void format_to(bsl::wstring *out,
3908 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
3909 const t_ARGS_01& args_01,
3910 const t_ARGS_02& args_02)
3911{
3912 vformat_to(bsl::back_inserter(*out),
3913 fmtStr.get(),
3914 bslfmt::make_wformat_args(args_01,
3915 args_02));
3916}
3917#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 2
3918
3919#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 3
3920template <class t_ARGS_01,
3921 class t_ARGS_02,
3922 class t_ARGS_03>
3923void format_to(bsl::wstring *out,
3924 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
3925 const t_ARGS_01& args_01,
3926 const t_ARGS_02& args_02,
3927 const t_ARGS_03& args_03)
3928{
3929 vformat_to(bsl::back_inserter(*out),
3930 fmtStr.get(),
3931 bslfmt::make_wformat_args(args_01,
3932 args_02,
3933 args_03));
3934}
3935#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 3
3936
3937#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 4
3938template <class t_ARGS_01,
3939 class t_ARGS_02,
3940 class t_ARGS_03,
3941 class t_ARGS_04>
3942void format_to(bsl::wstring *out,
3943 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
3944 const t_ARGS_01& args_01,
3945 const t_ARGS_02& args_02,
3946 const t_ARGS_03& args_03,
3947 const t_ARGS_04& args_04)
3948{
3949 vformat_to(bsl::back_inserter(*out),
3950 fmtStr.get(),
3951 bslfmt::make_wformat_args(args_01,
3952 args_02,
3953 args_03,
3954 args_04));
3955}
3956#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 4
3957
3958#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 5
3959template <class t_ARGS_01,
3960 class t_ARGS_02,
3961 class t_ARGS_03,
3962 class t_ARGS_04,
3963 class t_ARGS_05>
3964void format_to(bsl::wstring *out,
3965 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
3966 const t_ARGS_01& args_01,
3967 const t_ARGS_02& args_02,
3968 const t_ARGS_03& args_03,
3969 const t_ARGS_04& args_04,
3970 const t_ARGS_05& args_05)
3971{
3972 vformat_to(bsl::back_inserter(*out),
3973 fmtStr.get(),
3974 bslfmt::make_wformat_args(args_01,
3975 args_02,
3976 args_03,
3977 args_04,
3978 args_05));
3979}
3980#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 5
3981
3982#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 6
3983template <class t_ARGS_01,
3984 class t_ARGS_02,
3985 class t_ARGS_03,
3986 class t_ARGS_04,
3987 class t_ARGS_05,
3988 class t_ARGS_06>
3989void format_to(bsl::wstring *out,
3990 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
3991 const t_ARGS_01& args_01,
3992 const t_ARGS_02& args_02,
3993 const t_ARGS_03& args_03,
3994 const t_ARGS_04& args_04,
3995 const t_ARGS_05& args_05,
3996 const t_ARGS_06& args_06)
3997{
3998 vformat_to(bsl::back_inserter(*out),
3999 fmtStr.get(),
4000 bslfmt::make_wformat_args(args_01,
4001 args_02,
4002 args_03,
4003 args_04,
4004 args_05,
4005 args_06));
4006}
4007#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 6
4008
4009#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 7
4010template <class t_ARGS_01,
4011 class t_ARGS_02,
4012 class t_ARGS_03,
4013 class t_ARGS_04,
4014 class t_ARGS_05,
4015 class t_ARGS_06,
4016 class t_ARGS_07>
4017void format_to(bsl::wstring *out,
4018 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
4019 const t_ARGS_01& args_01,
4020 const t_ARGS_02& args_02,
4021 const t_ARGS_03& args_03,
4022 const t_ARGS_04& args_04,
4023 const t_ARGS_05& args_05,
4024 const t_ARGS_06& args_06,
4025 const t_ARGS_07& args_07)
4026{
4027 vformat_to(bsl::back_inserter(*out),
4028 fmtStr.get(),
4029 bslfmt::make_wformat_args(args_01,
4030 args_02,
4031 args_03,
4032 args_04,
4033 args_05,
4034 args_06,
4035 args_07));
4036}
4037#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 7
4038
4039#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 8
4040template <class t_ARGS_01,
4041 class t_ARGS_02,
4042 class t_ARGS_03,
4043 class t_ARGS_04,
4044 class t_ARGS_05,
4045 class t_ARGS_06,
4046 class t_ARGS_07,
4047 class t_ARGS_08>
4048void format_to(bsl::wstring *out,
4049 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
4050 const t_ARGS_01& args_01,
4051 const t_ARGS_02& args_02,
4052 const t_ARGS_03& args_03,
4053 const t_ARGS_04& args_04,
4054 const t_ARGS_05& args_05,
4055 const t_ARGS_06& args_06,
4056 const t_ARGS_07& args_07,
4057 const t_ARGS_08& args_08)
4058{
4059 vformat_to(bsl::back_inserter(*out),
4060 fmtStr.get(),
4061 bslfmt::make_wformat_args(args_01,
4062 args_02,
4063 args_03,
4064 args_04,
4065 args_05,
4066 args_06,
4067 args_07,
4068 args_08));
4069}
4070#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 8
4071
4072#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 9
4073template <class t_ARGS_01,
4074 class t_ARGS_02,
4075 class t_ARGS_03,
4076 class t_ARGS_04,
4077 class t_ARGS_05,
4078 class t_ARGS_06,
4079 class t_ARGS_07,
4080 class t_ARGS_08,
4081 class t_ARGS_09>
4082void format_to(bsl::wstring *out,
4083 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
4084 const t_ARGS_01& args_01,
4085 const t_ARGS_02& args_02,
4086 const t_ARGS_03& args_03,
4087 const t_ARGS_04& args_04,
4088 const t_ARGS_05& args_05,
4089 const t_ARGS_06& args_06,
4090 const t_ARGS_07& args_07,
4091 const t_ARGS_08& args_08,
4092 const t_ARGS_09& args_09)
4093{
4094 vformat_to(bsl::back_inserter(*out),
4095 fmtStr.get(),
4096 bslfmt::make_wformat_args(args_01,
4097 args_02,
4098 args_03,
4099 args_04,
4100 args_05,
4101 args_06,
4102 args_07,
4103 args_08,
4104 args_09));
4105}
4106#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 9
4107
4108#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 10
4109template <class t_ARGS_01,
4110 class t_ARGS_02,
4111 class t_ARGS_03,
4112 class t_ARGS_04,
4113 class t_ARGS_05,
4114 class t_ARGS_06,
4115 class t_ARGS_07,
4116 class t_ARGS_08,
4117 class t_ARGS_09,
4118 class t_ARGS_10>
4119void format_to(bsl::wstring *out,
4120 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
4121 const t_ARGS_01& args_01,
4122 const t_ARGS_02& args_02,
4123 const t_ARGS_03& args_03,
4124 const t_ARGS_04& args_04,
4125 const t_ARGS_05& args_05,
4126 const t_ARGS_06& args_06,
4127 const t_ARGS_07& args_07,
4128 const t_ARGS_08& args_08,
4129 const t_ARGS_09& args_09,
4130 const t_ARGS_10& args_10)
4131{
4132 vformat_to(bsl::back_inserter(*out),
4133 fmtStr.get(),
4134 bslfmt::make_wformat_args(args_01,
4135 args_02,
4136 args_03,
4137 args_04,
4138 args_05,
4139 args_06,
4140 args_07,
4141 args_08,
4142 args_09,
4143 args_10));
4144}
4145#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 10
4146
4147
4148#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 0
4149bsl::string format(BSLFMT_FORMAT_STRING_PARAMETER fmtStr)
4150{
4151 bsl::string result;
4152 vformat_to(&result, fmtStr.get(), bslfmt::make_format_args());
4153 return result;
4154}
4155#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 0
4156
4157#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 1
4158template <class t_ARGS_01>
4159bsl::string format(BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
4160 const t_ARGS_01& args_01)
4161{
4162 bsl::string result;
4163 vformat_to(&result, fmtStr.get(), bslfmt::make_format_args(args_01));
4164 return result;
4165}
4166#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 1
4167
4168#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 2
4169template <class t_ARGS_01,
4170 class t_ARGS_02>
4171bsl::string format(BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
4172 const t_ARGS_01& args_01,
4173 const t_ARGS_02& args_02)
4174{
4175 bsl::string result;
4176 vformat_to(&result, fmtStr.get(), bslfmt::make_format_args(args_01,
4177 args_02));
4178 return result;
4179}
4180#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 2
4181
4182#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 3
4183template <class t_ARGS_01,
4184 class t_ARGS_02,
4185 class t_ARGS_03>
4186bsl::string format(BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
4187 const t_ARGS_01& args_01,
4188 const t_ARGS_02& args_02,
4189 const t_ARGS_03& args_03)
4190{
4191 bsl::string result;
4192 vformat_to(&result, fmtStr.get(), bslfmt::make_format_args(args_01,
4193 args_02,
4194 args_03));
4195 return result;
4196}
4197#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 3
4198
4199#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 4
4200template <class t_ARGS_01,
4201 class t_ARGS_02,
4202 class t_ARGS_03,
4203 class t_ARGS_04>
4204bsl::string format(BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
4205 const t_ARGS_01& args_01,
4206 const t_ARGS_02& args_02,
4207 const t_ARGS_03& args_03,
4208 const t_ARGS_04& args_04)
4209{
4210 bsl::string result;
4211 vformat_to(&result, fmtStr.get(), bslfmt::make_format_args(args_01,
4212 args_02,
4213 args_03,
4214 args_04));
4215 return result;
4216}
4217#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 4
4218
4219#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 5
4220template <class t_ARGS_01,
4221 class t_ARGS_02,
4222 class t_ARGS_03,
4223 class t_ARGS_04,
4224 class t_ARGS_05>
4225bsl::string format(BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
4226 const t_ARGS_01& args_01,
4227 const t_ARGS_02& args_02,
4228 const t_ARGS_03& args_03,
4229 const t_ARGS_04& args_04,
4230 const t_ARGS_05& args_05)
4231{
4232 bsl::string result;
4233 vformat_to(&result, fmtStr.get(), bslfmt::make_format_args(args_01,
4234 args_02,
4235 args_03,
4236 args_04,
4237 args_05));
4238 return result;
4239}
4240#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 5
4241
4242#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 6
4243template <class t_ARGS_01,
4244 class t_ARGS_02,
4245 class t_ARGS_03,
4246 class t_ARGS_04,
4247 class t_ARGS_05,
4248 class t_ARGS_06>
4249bsl::string format(BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
4250 const t_ARGS_01& args_01,
4251 const t_ARGS_02& args_02,
4252 const t_ARGS_03& args_03,
4253 const t_ARGS_04& args_04,
4254 const t_ARGS_05& args_05,
4255 const t_ARGS_06& args_06)
4256{
4257 bsl::string result;
4258 vformat_to(&result, fmtStr.get(), bslfmt::make_format_args(args_01,
4259 args_02,
4260 args_03,
4261 args_04,
4262 args_05,
4263 args_06));
4264 return result;
4265}
4266#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 6
4267
4268#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 7
4269template <class t_ARGS_01,
4270 class t_ARGS_02,
4271 class t_ARGS_03,
4272 class t_ARGS_04,
4273 class t_ARGS_05,
4274 class t_ARGS_06,
4275 class t_ARGS_07>
4276bsl::string format(BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
4277 const t_ARGS_01& args_01,
4278 const t_ARGS_02& args_02,
4279 const t_ARGS_03& args_03,
4280 const t_ARGS_04& args_04,
4281 const t_ARGS_05& args_05,
4282 const t_ARGS_06& args_06,
4283 const t_ARGS_07& args_07)
4284{
4285 bsl::string result;
4286 vformat_to(&result, fmtStr.get(), bslfmt::make_format_args(args_01,
4287 args_02,
4288 args_03,
4289 args_04,
4290 args_05,
4291 args_06,
4292 args_07));
4293 return result;
4294}
4295#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 7
4296
4297#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 8
4298template <class t_ARGS_01,
4299 class t_ARGS_02,
4300 class t_ARGS_03,
4301 class t_ARGS_04,
4302 class t_ARGS_05,
4303 class t_ARGS_06,
4304 class t_ARGS_07,
4305 class t_ARGS_08>
4306bsl::string format(BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
4307 const t_ARGS_01& args_01,
4308 const t_ARGS_02& args_02,
4309 const t_ARGS_03& args_03,
4310 const t_ARGS_04& args_04,
4311 const t_ARGS_05& args_05,
4312 const t_ARGS_06& args_06,
4313 const t_ARGS_07& args_07,
4314 const t_ARGS_08& args_08)
4315{
4316 bsl::string result;
4317 vformat_to(&result, fmtStr.get(), bslfmt::make_format_args(args_01,
4318 args_02,
4319 args_03,
4320 args_04,
4321 args_05,
4322 args_06,
4323 args_07,
4324 args_08));
4325 return result;
4326}
4327#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 8
4328
4329#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 9
4330template <class t_ARGS_01,
4331 class t_ARGS_02,
4332 class t_ARGS_03,
4333 class t_ARGS_04,
4334 class t_ARGS_05,
4335 class t_ARGS_06,
4336 class t_ARGS_07,
4337 class t_ARGS_08,
4338 class t_ARGS_09>
4339bsl::string format(BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
4340 const t_ARGS_01& args_01,
4341 const t_ARGS_02& args_02,
4342 const t_ARGS_03& args_03,
4343 const t_ARGS_04& args_04,
4344 const t_ARGS_05& args_05,
4345 const t_ARGS_06& args_06,
4346 const t_ARGS_07& args_07,
4347 const t_ARGS_08& args_08,
4348 const t_ARGS_09& args_09)
4349{
4350 bsl::string result;
4351 vformat_to(&result, fmtStr.get(), bslfmt::make_format_args(args_01,
4352 args_02,
4353 args_03,
4354 args_04,
4355 args_05,
4356 args_06,
4357 args_07,
4358 args_08,
4359 args_09));
4360 return result;
4361}
4362#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 9
4363
4364#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 10
4365template <class t_ARGS_01,
4366 class t_ARGS_02,
4367 class t_ARGS_03,
4368 class t_ARGS_04,
4369 class t_ARGS_05,
4370 class t_ARGS_06,
4371 class t_ARGS_07,
4372 class t_ARGS_08,
4373 class t_ARGS_09,
4374 class t_ARGS_10>
4375bsl::string format(BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
4376 const t_ARGS_01& args_01,
4377 const t_ARGS_02& args_02,
4378 const t_ARGS_03& args_03,
4379 const t_ARGS_04& args_04,
4380 const t_ARGS_05& args_05,
4381 const t_ARGS_06& args_06,
4382 const t_ARGS_07& args_07,
4383 const t_ARGS_08& args_08,
4384 const t_ARGS_09& args_09,
4385 const t_ARGS_10& args_10)
4386{
4387 bsl::string result;
4388 vformat_to(&result, fmtStr.get(), bslfmt::make_format_args(args_01,
4389 args_02,
4390 args_03,
4391 args_04,
4392 args_05,
4393 args_06,
4394 args_07,
4395 args_08,
4396 args_09,
4397 args_10));
4398 return result;
4399}
4400#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 10
4401
4402
4403#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 0
4404bsl::wstring format(BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr)
4405{
4406 bsl::wstring result;
4407 vformat_to(&result, fmtStr.get(), bslfmt::make_wformat_args());
4408 return result;
4409}
4410#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 0
4411
4412#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 1
4413template <class t_ARGS_01>
4414bsl::wstring format(BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
4415 const t_ARGS_01& args_01)
4416{
4417 bsl::wstring result;
4418 vformat_to(&result, fmtStr.get(), bslfmt::make_wformat_args(args_01));
4419 return result;
4420}
4421#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 1
4422
4423#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 2
4424template <class t_ARGS_01,
4425 class t_ARGS_02>
4426bsl::wstring format(BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
4427 const t_ARGS_01& args_01,
4428 const t_ARGS_02& args_02)
4429{
4430 bsl::wstring result;
4431 vformat_to(&result, fmtStr.get(), bslfmt::make_wformat_args(args_01,
4432 args_02));
4433 return result;
4434}
4435#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 2
4436
4437#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 3
4438template <class t_ARGS_01,
4439 class t_ARGS_02,
4440 class t_ARGS_03>
4441bsl::wstring format(BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
4442 const t_ARGS_01& args_01,
4443 const t_ARGS_02& args_02,
4444 const t_ARGS_03& args_03)
4445{
4446 bsl::wstring result;
4447 vformat_to(&result, fmtStr.get(), bslfmt::make_wformat_args(args_01,
4448 args_02,
4449 args_03));
4450 return result;
4451}
4452#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 3
4453
4454#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 4
4455template <class t_ARGS_01,
4456 class t_ARGS_02,
4457 class t_ARGS_03,
4458 class t_ARGS_04>
4459bsl::wstring format(BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
4460 const t_ARGS_01& args_01,
4461 const t_ARGS_02& args_02,
4462 const t_ARGS_03& args_03,
4463 const t_ARGS_04& args_04)
4464{
4465 bsl::wstring result;
4466 vformat_to(&result, fmtStr.get(), bslfmt::make_wformat_args(args_01,
4467 args_02,
4468 args_03,
4469 args_04));
4470 return result;
4471}
4472#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 4
4473
4474#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 5
4475template <class t_ARGS_01,
4476 class t_ARGS_02,
4477 class t_ARGS_03,
4478 class t_ARGS_04,
4479 class t_ARGS_05>
4480bsl::wstring format(BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
4481 const t_ARGS_01& args_01,
4482 const t_ARGS_02& args_02,
4483 const t_ARGS_03& args_03,
4484 const t_ARGS_04& args_04,
4485 const t_ARGS_05& args_05)
4486{
4487 bsl::wstring result;
4488 vformat_to(&result, fmtStr.get(), bslfmt::make_wformat_args(args_01,
4489 args_02,
4490 args_03,
4491 args_04,
4492 args_05));
4493 return result;
4494}
4495#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 5
4496
4497#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 6
4498template <class t_ARGS_01,
4499 class t_ARGS_02,
4500 class t_ARGS_03,
4501 class t_ARGS_04,
4502 class t_ARGS_05,
4503 class t_ARGS_06>
4504bsl::wstring format(BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
4505 const t_ARGS_01& args_01,
4506 const t_ARGS_02& args_02,
4507 const t_ARGS_03& args_03,
4508 const t_ARGS_04& args_04,
4509 const t_ARGS_05& args_05,
4510 const t_ARGS_06& args_06)
4511{
4512 bsl::wstring result;
4513 vformat_to(&result, fmtStr.get(), bslfmt::make_wformat_args(args_01,
4514 args_02,
4515 args_03,
4516 args_04,
4517 args_05,
4518 args_06));
4519 return result;
4520}
4521#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 6
4522
4523#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 7
4524template <class t_ARGS_01,
4525 class t_ARGS_02,
4526 class t_ARGS_03,
4527 class t_ARGS_04,
4528 class t_ARGS_05,
4529 class t_ARGS_06,
4530 class t_ARGS_07>
4531bsl::wstring format(BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
4532 const t_ARGS_01& args_01,
4533 const t_ARGS_02& args_02,
4534 const t_ARGS_03& args_03,
4535 const t_ARGS_04& args_04,
4536 const t_ARGS_05& args_05,
4537 const t_ARGS_06& args_06,
4538 const t_ARGS_07& args_07)
4539{
4540 bsl::wstring result;
4541 vformat_to(&result, fmtStr.get(), bslfmt::make_wformat_args(args_01,
4542 args_02,
4543 args_03,
4544 args_04,
4545 args_05,
4546 args_06,
4547 args_07));
4548 return result;
4549}
4550#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 7
4551
4552#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 8
4553template <class t_ARGS_01,
4554 class t_ARGS_02,
4555 class t_ARGS_03,
4556 class t_ARGS_04,
4557 class t_ARGS_05,
4558 class t_ARGS_06,
4559 class t_ARGS_07,
4560 class t_ARGS_08>
4561bsl::wstring format(BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
4562 const t_ARGS_01& args_01,
4563 const t_ARGS_02& args_02,
4564 const t_ARGS_03& args_03,
4565 const t_ARGS_04& args_04,
4566 const t_ARGS_05& args_05,
4567 const t_ARGS_06& args_06,
4568 const t_ARGS_07& args_07,
4569 const t_ARGS_08& args_08)
4570{
4571 bsl::wstring result;
4572 vformat_to(&result, fmtStr.get(), bslfmt::make_wformat_args(args_01,
4573 args_02,
4574 args_03,
4575 args_04,
4576 args_05,
4577 args_06,
4578 args_07,
4579 args_08));
4580 return result;
4581}
4582#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 8
4583
4584#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 9
4585template <class t_ARGS_01,
4586 class t_ARGS_02,
4587 class t_ARGS_03,
4588 class t_ARGS_04,
4589 class t_ARGS_05,
4590 class t_ARGS_06,
4591 class t_ARGS_07,
4592 class t_ARGS_08,
4593 class t_ARGS_09>
4594bsl::wstring format(BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
4595 const t_ARGS_01& args_01,
4596 const t_ARGS_02& args_02,
4597 const t_ARGS_03& args_03,
4598 const t_ARGS_04& args_04,
4599 const t_ARGS_05& args_05,
4600 const t_ARGS_06& args_06,
4601 const t_ARGS_07& args_07,
4602 const t_ARGS_08& args_08,
4603 const t_ARGS_09& args_09)
4604{
4605 bsl::wstring result;
4606 vformat_to(&result, fmtStr.get(), bslfmt::make_wformat_args(args_01,
4607 args_02,
4608 args_03,
4609 args_04,
4610 args_05,
4611 args_06,
4612 args_07,
4613 args_08,
4614 args_09));
4615 return result;
4616}
4617#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 9
4618
4619#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 10
4620template <class t_ARGS_01,
4621 class t_ARGS_02,
4622 class t_ARGS_03,
4623 class t_ARGS_04,
4624 class t_ARGS_05,
4625 class t_ARGS_06,
4626 class t_ARGS_07,
4627 class t_ARGS_08,
4628 class t_ARGS_09,
4629 class t_ARGS_10>
4630bsl::wstring format(BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
4631 const t_ARGS_01& args_01,
4632 const t_ARGS_02& args_02,
4633 const t_ARGS_03& args_03,
4634 const t_ARGS_04& args_04,
4635 const t_ARGS_05& args_05,
4636 const t_ARGS_06& args_06,
4637 const t_ARGS_07& args_07,
4638 const t_ARGS_08& args_08,
4639 const t_ARGS_09& args_09,
4640 const t_ARGS_10& args_10)
4641{
4642 bsl::wstring result;
4643 vformat_to(&result, fmtStr.get(), bslfmt::make_wformat_args(args_01,
4644 args_02,
4645 args_03,
4646 args_04,
4647 args_05,
4648 args_06,
4649 args_07,
4650 args_08,
4651 args_09,
4652 args_10));
4653 return result;
4654}
4655#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 10
4656
4657
4658#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 0
4659bsl::string format(bsl::allocator<char> alloc,
4660 BSLFMT_FORMAT_STRING_PARAMETER fmtStr)
4661{
4662 bsl::string result(alloc);
4663 vformat_to(&result, fmtStr.get(), bslfmt::make_format_args());
4664 return bsl::string(result, alloc);
4665}
4666#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 0
4667
4668#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 1
4669template <class t_ARGS_01>
4670bsl::string format(bsl::allocator<char> alloc,
4671 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
4672 const t_ARGS_01& args_01)
4673{
4674 bsl::string result(alloc);
4675 vformat_to(&result, fmtStr.get(), bslfmt::make_format_args(args_01));
4676 return bsl::string(result, alloc);
4677}
4678#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 1
4679
4680#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 2
4681template <class t_ARGS_01,
4682 class t_ARGS_02>
4683bsl::string format(bsl::allocator<char> alloc,
4684 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
4685 const t_ARGS_01& args_01,
4686 const t_ARGS_02& args_02)
4687{
4688 bsl::string result(alloc);
4689 vformat_to(&result, fmtStr.get(), bslfmt::make_format_args(args_01,
4690 args_02));
4691 return bsl::string(result, alloc);
4692}
4693#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 2
4694
4695#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 3
4696template <class t_ARGS_01,
4697 class t_ARGS_02,
4698 class t_ARGS_03>
4699bsl::string format(bsl::allocator<char> alloc,
4700 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
4701 const t_ARGS_01& args_01,
4702 const t_ARGS_02& args_02,
4703 const t_ARGS_03& args_03)
4704{
4705 bsl::string result(alloc);
4706 vformat_to(&result, fmtStr.get(), bslfmt::make_format_args(args_01,
4707 args_02,
4708 args_03));
4709 return bsl::string(result, alloc);
4710}
4711#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 3
4712
4713#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 4
4714template <class t_ARGS_01,
4715 class t_ARGS_02,
4716 class t_ARGS_03,
4717 class t_ARGS_04>
4718bsl::string format(bsl::allocator<char> alloc,
4719 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
4720 const t_ARGS_01& args_01,
4721 const t_ARGS_02& args_02,
4722 const t_ARGS_03& args_03,
4723 const t_ARGS_04& args_04)
4724{
4725 bsl::string result(alloc);
4726 vformat_to(&result, fmtStr.get(), bslfmt::make_format_args(args_01,
4727 args_02,
4728 args_03,
4729 args_04));
4730 return bsl::string(result, alloc);
4731}
4732#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 4
4733
4734#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 5
4735template <class t_ARGS_01,
4736 class t_ARGS_02,
4737 class t_ARGS_03,
4738 class t_ARGS_04,
4739 class t_ARGS_05>
4740bsl::string format(bsl::allocator<char> alloc,
4741 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
4742 const t_ARGS_01& args_01,
4743 const t_ARGS_02& args_02,
4744 const t_ARGS_03& args_03,
4745 const t_ARGS_04& args_04,
4746 const t_ARGS_05& args_05)
4747{
4748 bsl::string result(alloc);
4749 vformat_to(&result, fmtStr.get(), bslfmt::make_format_args(args_01,
4750 args_02,
4751 args_03,
4752 args_04,
4753 args_05));
4754 return bsl::string(result, alloc);
4755}
4756#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 5
4757
4758#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 6
4759template <class t_ARGS_01,
4760 class t_ARGS_02,
4761 class t_ARGS_03,
4762 class t_ARGS_04,
4763 class t_ARGS_05,
4764 class t_ARGS_06>
4765bsl::string format(bsl::allocator<char> alloc,
4766 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
4767 const t_ARGS_01& args_01,
4768 const t_ARGS_02& args_02,
4769 const t_ARGS_03& args_03,
4770 const t_ARGS_04& args_04,
4771 const t_ARGS_05& args_05,
4772 const t_ARGS_06& args_06)
4773{
4774 bsl::string result(alloc);
4775 vformat_to(&result, fmtStr.get(), bslfmt::make_format_args(args_01,
4776 args_02,
4777 args_03,
4778 args_04,
4779 args_05,
4780 args_06));
4781 return bsl::string(result, alloc);
4782}
4783#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 6
4784
4785#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 7
4786template <class t_ARGS_01,
4787 class t_ARGS_02,
4788 class t_ARGS_03,
4789 class t_ARGS_04,
4790 class t_ARGS_05,
4791 class t_ARGS_06,
4792 class t_ARGS_07>
4793bsl::string format(bsl::allocator<char> alloc,
4794 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
4795 const t_ARGS_01& args_01,
4796 const t_ARGS_02& args_02,
4797 const t_ARGS_03& args_03,
4798 const t_ARGS_04& args_04,
4799 const t_ARGS_05& args_05,
4800 const t_ARGS_06& args_06,
4801 const t_ARGS_07& args_07)
4802{
4803 bsl::string result(alloc);
4804 vformat_to(&result, fmtStr.get(), bslfmt::make_format_args(args_01,
4805 args_02,
4806 args_03,
4807 args_04,
4808 args_05,
4809 args_06,
4810 args_07));
4811 return bsl::string(result, alloc);
4812}
4813#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 7
4814
4815#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 8
4816template <class t_ARGS_01,
4817 class t_ARGS_02,
4818 class t_ARGS_03,
4819 class t_ARGS_04,
4820 class t_ARGS_05,
4821 class t_ARGS_06,
4822 class t_ARGS_07,
4823 class t_ARGS_08>
4824bsl::string format(bsl::allocator<char> alloc,
4825 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
4826 const t_ARGS_01& args_01,
4827 const t_ARGS_02& args_02,
4828 const t_ARGS_03& args_03,
4829 const t_ARGS_04& args_04,
4830 const t_ARGS_05& args_05,
4831 const t_ARGS_06& args_06,
4832 const t_ARGS_07& args_07,
4833 const t_ARGS_08& args_08)
4834{
4835 bsl::string result(alloc);
4836 vformat_to(&result, fmtStr.get(), bslfmt::make_format_args(args_01,
4837 args_02,
4838 args_03,
4839 args_04,
4840 args_05,
4841 args_06,
4842 args_07,
4843 args_08));
4844 return bsl::string(result, alloc);
4845}
4846#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 8
4847
4848#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 9
4849template <class t_ARGS_01,
4850 class t_ARGS_02,
4851 class t_ARGS_03,
4852 class t_ARGS_04,
4853 class t_ARGS_05,
4854 class t_ARGS_06,
4855 class t_ARGS_07,
4856 class t_ARGS_08,
4857 class t_ARGS_09>
4858bsl::string format(bsl::allocator<char> alloc,
4859 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
4860 const t_ARGS_01& args_01,
4861 const t_ARGS_02& args_02,
4862 const t_ARGS_03& args_03,
4863 const t_ARGS_04& args_04,
4864 const t_ARGS_05& args_05,
4865 const t_ARGS_06& args_06,
4866 const t_ARGS_07& args_07,
4867 const t_ARGS_08& args_08,
4868 const t_ARGS_09& args_09)
4869{
4870 bsl::string result(alloc);
4871 vformat_to(&result, fmtStr.get(), bslfmt::make_format_args(args_01,
4872 args_02,
4873 args_03,
4874 args_04,
4875 args_05,
4876 args_06,
4877 args_07,
4878 args_08,
4879 args_09));
4880 return bsl::string(result, alloc);
4881}
4882#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 9
4883
4884#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 10
4885template <class t_ARGS_01,
4886 class t_ARGS_02,
4887 class t_ARGS_03,
4888 class t_ARGS_04,
4889 class t_ARGS_05,
4890 class t_ARGS_06,
4891 class t_ARGS_07,
4892 class t_ARGS_08,
4893 class t_ARGS_09,
4894 class t_ARGS_10>
4895bsl::string format(bsl::allocator<char> alloc,
4896 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
4897 const t_ARGS_01& args_01,
4898 const t_ARGS_02& args_02,
4899 const t_ARGS_03& args_03,
4900 const t_ARGS_04& args_04,
4901 const t_ARGS_05& args_05,
4902 const t_ARGS_06& args_06,
4903 const t_ARGS_07& args_07,
4904 const t_ARGS_08& args_08,
4905 const t_ARGS_09& args_09,
4906 const t_ARGS_10& args_10)
4907{
4908 bsl::string result(alloc);
4909 vformat_to(&result, fmtStr.get(), bslfmt::make_format_args(args_01,
4910 args_02,
4911 args_03,
4912 args_04,
4913 args_05,
4914 args_06,
4915 args_07,
4916 args_08,
4917 args_09,
4918 args_10));
4919 return bsl::string(result, alloc);
4920}
4921#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 10
4922
4923
4924#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 0
4925bsl::wstring format(bsl::allocator<wchar_t> alloc,
4926 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr)
4927{
4928 bsl::wstring result(alloc);
4929 vformat_to(&result, fmtStr.get(), bslfmt::make_wformat_args());
4930 return bsl::wstring(result, alloc);
4931}
4932#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 0
4933
4934#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 1
4935template <class t_ARGS_01>
4936bsl::wstring format(bsl::allocator<wchar_t> alloc,
4937 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
4938 const t_ARGS_01& args_01)
4939{
4940 bsl::wstring result(alloc);
4941 vformat_to(&result, fmtStr.get(), bslfmt::make_wformat_args(args_01));
4942 return bsl::wstring(result, alloc);
4943}
4944#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 1
4945
4946#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 2
4947template <class t_ARGS_01,
4948 class t_ARGS_02>
4949bsl::wstring format(bsl::allocator<wchar_t> alloc,
4950 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
4951 const t_ARGS_01& args_01,
4952 const t_ARGS_02& args_02)
4953{
4954 bsl::wstring result(alloc);
4955 vformat_to(&result, fmtStr.get(), bslfmt::make_wformat_args(args_01,
4956 args_02));
4957 return bsl::wstring(result, alloc);
4958}
4959#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 2
4960
4961#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 3
4962template <class t_ARGS_01,
4963 class t_ARGS_02,
4964 class t_ARGS_03>
4965bsl::wstring format(bsl::allocator<wchar_t> alloc,
4966 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
4967 const t_ARGS_01& args_01,
4968 const t_ARGS_02& args_02,
4969 const t_ARGS_03& args_03)
4970{
4971 bsl::wstring result(alloc);
4972 vformat_to(&result, fmtStr.get(), bslfmt::make_wformat_args(args_01,
4973 args_02,
4974 args_03));
4975 return bsl::wstring(result, alloc);
4976}
4977#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 3
4978
4979#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 4
4980template <class t_ARGS_01,
4981 class t_ARGS_02,
4982 class t_ARGS_03,
4983 class t_ARGS_04>
4984bsl::wstring format(bsl::allocator<wchar_t> alloc,
4985 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
4986 const t_ARGS_01& args_01,
4987 const t_ARGS_02& args_02,
4988 const t_ARGS_03& args_03,
4989 const t_ARGS_04& args_04)
4990{
4991 bsl::wstring result(alloc);
4992 vformat_to(&result, fmtStr.get(), bslfmt::make_wformat_args(args_01,
4993 args_02,
4994 args_03,
4995 args_04));
4996 return bsl::wstring(result, alloc);
4997}
4998#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 4
4999
5000#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 5
5001template <class t_ARGS_01,
5002 class t_ARGS_02,
5003 class t_ARGS_03,
5004 class t_ARGS_04,
5005 class t_ARGS_05>
5006bsl::wstring format(bsl::allocator<wchar_t> alloc,
5007 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
5008 const t_ARGS_01& args_01,
5009 const t_ARGS_02& args_02,
5010 const t_ARGS_03& args_03,
5011 const t_ARGS_04& args_04,
5012 const t_ARGS_05& args_05)
5013{
5014 bsl::wstring result(alloc);
5015 vformat_to(&result, fmtStr.get(), bslfmt::make_wformat_args(args_01,
5016 args_02,
5017 args_03,
5018 args_04,
5019 args_05));
5020 return bsl::wstring(result, alloc);
5021}
5022#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 5
5023
5024#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 6
5025template <class t_ARGS_01,
5026 class t_ARGS_02,
5027 class t_ARGS_03,
5028 class t_ARGS_04,
5029 class t_ARGS_05,
5030 class t_ARGS_06>
5031bsl::wstring format(bsl::allocator<wchar_t> alloc,
5032 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
5033 const t_ARGS_01& args_01,
5034 const t_ARGS_02& args_02,
5035 const t_ARGS_03& args_03,
5036 const t_ARGS_04& args_04,
5037 const t_ARGS_05& args_05,
5038 const t_ARGS_06& args_06)
5039{
5040 bsl::wstring result(alloc);
5041 vformat_to(&result, fmtStr.get(), bslfmt::make_wformat_args(args_01,
5042 args_02,
5043 args_03,
5044 args_04,
5045 args_05,
5046 args_06));
5047 return bsl::wstring(result, alloc);
5048}
5049#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 6
5050
5051#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 7
5052template <class t_ARGS_01,
5053 class t_ARGS_02,
5054 class t_ARGS_03,
5055 class t_ARGS_04,
5056 class t_ARGS_05,
5057 class t_ARGS_06,
5058 class t_ARGS_07>
5059bsl::wstring format(bsl::allocator<wchar_t> alloc,
5060 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
5061 const t_ARGS_01& args_01,
5062 const t_ARGS_02& args_02,
5063 const t_ARGS_03& args_03,
5064 const t_ARGS_04& args_04,
5065 const t_ARGS_05& args_05,
5066 const t_ARGS_06& args_06,
5067 const t_ARGS_07& args_07)
5068{
5069 bsl::wstring result(alloc);
5070 vformat_to(&result, fmtStr.get(), bslfmt::make_wformat_args(args_01,
5071 args_02,
5072 args_03,
5073 args_04,
5074 args_05,
5075 args_06,
5076 args_07));
5077 return bsl::wstring(result, alloc);
5078}
5079#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 7
5080
5081#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 8
5082template <class t_ARGS_01,
5083 class t_ARGS_02,
5084 class t_ARGS_03,
5085 class t_ARGS_04,
5086 class t_ARGS_05,
5087 class t_ARGS_06,
5088 class t_ARGS_07,
5089 class t_ARGS_08>
5090bsl::wstring format(bsl::allocator<wchar_t> alloc,
5091 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
5092 const t_ARGS_01& args_01,
5093 const t_ARGS_02& args_02,
5094 const t_ARGS_03& args_03,
5095 const t_ARGS_04& args_04,
5096 const t_ARGS_05& args_05,
5097 const t_ARGS_06& args_06,
5098 const t_ARGS_07& args_07,
5099 const t_ARGS_08& args_08)
5100{
5101 bsl::wstring result(alloc);
5102 vformat_to(&result, fmtStr.get(), bslfmt::make_wformat_args(args_01,
5103 args_02,
5104 args_03,
5105 args_04,
5106 args_05,
5107 args_06,
5108 args_07,
5109 args_08));
5110 return bsl::wstring(result, alloc);
5111}
5112#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 8
5113
5114#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 9
5115template <class t_ARGS_01,
5116 class t_ARGS_02,
5117 class t_ARGS_03,
5118 class t_ARGS_04,
5119 class t_ARGS_05,
5120 class t_ARGS_06,
5121 class t_ARGS_07,
5122 class t_ARGS_08,
5123 class t_ARGS_09>
5124bsl::wstring format(bsl::allocator<wchar_t> alloc,
5125 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
5126 const t_ARGS_01& args_01,
5127 const t_ARGS_02& args_02,
5128 const t_ARGS_03& args_03,
5129 const t_ARGS_04& args_04,
5130 const t_ARGS_05& args_05,
5131 const t_ARGS_06& args_06,
5132 const t_ARGS_07& args_07,
5133 const t_ARGS_08& args_08,
5134 const t_ARGS_09& args_09)
5135{
5136 bsl::wstring result(alloc);
5137 vformat_to(&result, fmtStr.get(), bslfmt::make_wformat_args(args_01,
5138 args_02,
5139 args_03,
5140 args_04,
5141 args_05,
5142 args_06,
5143 args_07,
5144 args_08,
5145 args_09));
5146 return bsl::wstring(result, alloc);
5147}
5148#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 9
5149
5150#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 10
5151template <class t_ARGS_01,
5152 class t_ARGS_02,
5153 class t_ARGS_03,
5154 class t_ARGS_04,
5155 class t_ARGS_05,
5156 class t_ARGS_06,
5157 class t_ARGS_07,
5158 class t_ARGS_08,
5159 class t_ARGS_09,
5160 class t_ARGS_10>
5161bsl::wstring format(bsl::allocator<wchar_t> alloc,
5162 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
5163 const t_ARGS_01& args_01,
5164 const t_ARGS_02& args_02,
5165 const t_ARGS_03& args_03,
5166 const t_ARGS_04& args_04,
5167 const t_ARGS_05& args_05,
5168 const t_ARGS_06& args_06,
5169 const t_ARGS_07& args_07,
5170 const t_ARGS_08& args_08,
5171 const t_ARGS_09& args_09,
5172 const t_ARGS_10& args_10)
5173{
5174 bsl::wstring result(alloc);
5175 vformat_to(&result, fmtStr.get(), bslfmt::make_wformat_args(args_01,
5176 args_02,
5177 args_03,
5178 args_04,
5179 args_05,
5180 args_06,
5181 args_07,
5182 args_08,
5183 args_09,
5184 args_10));
5185 return bsl::wstring(result, alloc);
5186}
5187#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 10
5188
5189
5190#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 0
5191std::size_t formatted_size(BSLFMT_FORMAT_STRING_PARAMETER fmtStr)
5192{
5193 typedef Format_Imp_TruncatingIterator<char *, char, ptrdiff_t>
5194 TruncatingIterator;
5195
5196 TruncatingIterator it(0, 0);
5197 TruncatingIterator end = format_to(it, fmtStr);
5198 return end.count();
5199}
5200#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 0
5201
5202#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 1
5203template <class t_ARGS_01>
5204std::size_t formatted_size(BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
5205 const t_ARGS_01& args_01)
5206{
5207 typedef Format_Imp_TruncatingIterator<char *, char, ptrdiff_t>
5208 TruncatingIterator;
5209
5210 TruncatingIterator it(0, 0);
5211 TruncatingIterator end = format_to(it, fmtStr, args_01);
5212 return end.count();
5213}
5214#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 1
5215
5216#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 2
5217template <class t_ARGS_01,
5218 class t_ARGS_02>
5219std::size_t formatted_size(BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
5220 const t_ARGS_01& args_01,
5221 const t_ARGS_02& args_02)
5222{
5223 typedef Format_Imp_TruncatingIterator<char *, char, ptrdiff_t>
5224 TruncatingIterator;
5225
5226 TruncatingIterator it(0, 0);
5227 TruncatingIterator end = format_to(it, fmtStr, args_01,
5228 args_02);
5229 return end.count();
5230}
5231#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 2
5232
5233#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 3
5234template <class t_ARGS_01,
5235 class t_ARGS_02,
5236 class t_ARGS_03>
5237std::size_t formatted_size(BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
5238 const t_ARGS_01& args_01,
5239 const t_ARGS_02& args_02,
5240 const t_ARGS_03& args_03)
5241{
5242 typedef Format_Imp_TruncatingIterator<char *, char, ptrdiff_t>
5243 TruncatingIterator;
5244
5245 TruncatingIterator it(0, 0);
5246 TruncatingIterator end = format_to(it, fmtStr, args_01,
5247 args_02,
5248 args_03);
5249 return end.count();
5250}
5251#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 3
5252
5253#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 4
5254template <class t_ARGS_01,
5255 class t_ARGS_02,
5256 class t_ARGS_03,
5257 class t_ARGS_04>
5258std::size_t formatted_size(BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
5259 const t_ARGS_01& args_01,
5260 const t_ARGS_02& args_02,
5261 const t_ARGS_03& args_03,
5262 const t_ARGS_04& args_04)
5263{
5264 typedef Format_Imp_TruncatingIterator<char *, char, ptrdiff_t>
5265 TruncatingIterator;
5266
5267 TruncatingIterator it(0, 0);
5268 TruncatingIterator end = format_to(it, fmtStr, args_01,
5269 args_02,
5270 args_03,
5271 args_04);
5272 return end.count();
5273}
5274#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 4
5275
5276#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 5
5277template <class t_ARGS_01,
5278 class t_ARGS_02,
5279 class t_ARGS_03,
5280 class t_ARGS_04,
5281 class t_ARGS_05>
5282std::size_t formatted_size(BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
5283 const t_ARGS_01& args_01,
5284 const t_ARGS_02& args_02,
5285 const t_ARGS_03& args_03,
5286 const t_ARGS_04& args_04,
5287 const t_ARGS_05& args_05)
5288{
5289 typedef Format_Imp_TruncatingIterator<char *, char, ptrdiff_t>
5290 TruncatingIterator;
5291
5292 TruncatingIterator it(0, 0);
5293 TruncatingIterator end = format_to(it, fmtStr, args_01,
5294 args_02,
5295 args_03,
5296 args_04,
5297 args_05);
5298 return end.count();
5299}
5300#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 5
5301
5302#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 6
5303template <class t_ARGS_01,
5304 class t_ARGS_02,
5305 class t_ARGS_03,
5306 class t_ARGS_04,
5307 class t_ARGS_05,
5308 class t_ARGS_06>
5309std::size_t formatted_size(BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
5310 const t_ARGS_01& args_01,
5311 const t_ARGS_02& args_02,
5312 const t_ARGS_03& args_03,
5313 const t_ARGS_04& args_04,
5314 const t_ARGS_05& args_05,
5315 const t_ARGS_06& args_06)
5316{
5317 typedef Format_Imp_TruncatingIterator<char *, char, ptrdiff_t>
5318 TruncatingIterator;
5319
5320 TruncatingIterator it(0, 0);
5321 TruncatingIterator end = format_to(it, fmtStr, args_01,
5322 args_02,
5323 args_03,
5324 args_04,
5325 args_05,
5326 args_06);
5327 return end.count();
5328}
5329#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 6
5330
5331#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 7
5332template <class t_ARGS_01,
5333 class t_ARGS_02,
5334 class t_ARGS_03,
5335 class t_ARGS_04,
5336 class t_ARGS_05,
5337 class t_ARGS_06,
5338 class t_ARGS_07>
5339std::size_t formatted_size(BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
5340 const t_ARGS_01& args_01,
5341 const t_ARGS_02& args_02,
5342 const t_ARGS_03& args_03,
5343 const t_ARGS_04& args_04,
5344 const t_ARGS_05& args_05,
5345 const t_ARGS_06& args_06,
5346 const t_ARGS_07& args_07)
5347{
5348 typedef Format_Imp_TruncatingIterator<char *, char, ptrdiff_t>
5349 TruncatingIterator;
5350
5351 TruncatingIterator it(0, 0);
5352 TruncatingIterator end = format_to(it, fmtStr, args_01,
5353 args_02,
5354 args_03,
5355 args_04,
5356 args_05,
5357 args_06,
5358 args_07);
5359 return end.count();
5360}
5361#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 7
5362
5363#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 8
5364template <class t_ARGS_01,
5365 class t_ARGS_02,
5366 class t_ARGS_03,
5367 class t_ARGS_04,
5368 class t_ARGS_05,
5369 class t_ARGS_06,
5370 class t_ARGS_07,
5371 class t_ARGS_08>
5372std::size_t formatted_size(BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
5373 const t_ARGS_01& args_01,
5374 const t_ARGS_02& args_02,
5375 const t_ARGS_03& args_03,
5376 const t_ARGS_04& args_04,
5377 const t_ARGS_05& args_05,
5378 const t_ARGS_06& args_06,
5379 const t_ARGS_07& args_07,
5380 const t_ARGS_08& args_08)
5381{
5382 typedef Format_Imp_TruncatingIterator<char *, char, ptrdiff_t>
5383 TruncatingIterator;
5384
5385 TruncatingIterator it(0, 0);
5386 TruncatingIterator end = format_to(it, fmtStr, args_01,
5387 args_02,
5388 args_03,
5389 args_04,
5390 args_05,
5391 args_06,
5392 args_07,
5393 args_08);
5394 return end.count();
5395}
5396#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 8
5397
5398#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 9
5399template <class t_ARGS_01,
5400 class t_ARGS_02,
5401 class t_ARGS_03,
5402 class t_ARGS_04,
5403 class t_ARGS_05,
5404 class t_ARGS_06,
5405 class t_ARGS_07,
5406 class t_ARGS_08,
5407 class t_ARGS_09>
5408std::size_t formatted_size(BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
5409 const t_ARGS_01& args_01,
5410 const t_ARGS_02& args_02,
5411 const t_ARGS_03& args_03,
5412 const t_ARGS_04& args_04,
5413 const t_ARGS_05& args_05,
5414 const t_ARGS_06& args_06,
5415 const t_ARGS_07& args_07,
5416 const t_ARGS_08& args_08,
5417 const t_ARGS_09& args_09)
5418{
5419 typedef Format_Imp_TruncatingIterator<char *, char, ptrdiff_t>
5420 TruncatingIterator;
5421
5422 TruncatingIterator it(0, 0);
5423 TruncatingIterator end = format_to(it, fmtStr, args_01,
5424 args_02,
5425 args_03,
5426 args_04,
5427 args_05,
5428 args_06,
5429 args_07,
5430 args_08,
5431 args_09);
5432 return end.count();
5433}
5434#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 9
5435
5436#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 10
5437template <class t_ARGS_01,
5438 class t_ARGS_02,
5439 class t_ARGS_03,
5440 class t_ARGS_04,
5441 class t_ARGS_05,
5442 class t_ARGS_06,
5443 class t_ARGS_07,
5444 class t_ARGS_08,
5445 class t_ARGS_09,
5446 class t_ARGS_10>
5447std::size_t formatted_size(BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
5448 const t_ARGS_01& args_01,
5449 const t_ARGS_02& args_02,
5450 const t_ARGS_03& args_03,
5451 const t_ARGS_04& args_04,
5452 const t_ARGS_05& args_05,
5453 const t_ARGS_06& args_06,
5454 const t_ARGS_07& args_07,
5455 const t_ARGS_08& args_08,
5456 const t_ARGS_09& args_09,
5457 const t_ARGS_10& args_10)
5458{
5459 typedef Format_Imp_TruncatingIterator<char *, char, ptrdiff_t>
5460 TruncatingIterator;
5461
5462 TruncatingIterator it(0, 0);
5463 TruncatingIterator end = format_to(it, fmtStr, args_01,
5464 args_02,
5465 args_03,
5466 args_04,
5467 args_05,
5468 args_06,
5469 args_07,
5470 args_08,
5471 args_09,
5472 args_10);
5473 return end.count();
5474}
5475#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 10
5476
5477
5478#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 0
5479std::size_t formatted_size(BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr)
5480{
5481 typedef Format_Imp_TruncatingIterator<wchar_t *, wchar_t, ptrdiff_t>
5482 TruncatingIterator;
5483
5484 TruncatingIterator it(0, 0);
5485 TruncatingIterator end = format_to(it, fmtStr);
5486 return end.count();
5487}
5488#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 0
5489
5490#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 1
5491template <class t_ARGS_01>
5492std::size_t formatted_size(BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
5493 const t_ARGS_01& args_01)
5494{
5495 typedef Format_Imp_TruncatingIterator<wchar_t *, wchar_t, ptrdiff_t>
5496 TruncatingIterator;
5497
5498 TruncatingIterator it(0, 0);
5499 TruncatingIterator end = format_to(it, fmtStr, args_01);
5500 return end.count();
5501}
5502#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 1
5503
5504#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 2
5505template <class t_ARGS_01,
5506 class t_ARGS_02>
5507std::size_t formatted_size(BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
5508 const t_ARGS_01& args_01,
5509 const t_ARGS_02& args_02)
5510{
5511 typedef Format_Imp_TruncatingIterator<wchar_t *, wchar_t, ptrdiff_t>
5512 TruncatingIterator;
5513
5514 TruncatingIterator it(0, 0);
5515 TruncatingIterator end = format_to(it, fmtStr, args_01,
5516 args_02);
5517 return end.count();
5518}
5519#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 2
5520
5521#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 3
5522template <class t_ARGS_01,
5523 class t_ARGS_02,
5524 class t_ARGS_03>
5525std::size_t formatted_size(BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
5526 const t_ARGS_01& args_01,
5527 const t_ARGS_02& args_02,
5528 const t_ARGS_03& args_03)
5529{
5530 typedef Format_Imp_TruncatingIterator<wchar_t *, wchar_t, ptrdiff_t>
5531 TruncatingIterator;
5532
5533 TruncatingIterator it(0, 0);
5534 TruncatingIterator end = format_to(it, fmtStr, args_01,
5535 args_02,
5536 args_03);
5537 return end.count();
5538}
5539#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 3
5540
5541#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 4
5542template <class t_ARGS_01,
5543 class t_ARGS_02,
5544 class t_ARGS_03,
5545 class t_ARGS_04>
5546std::size_t formatted_size(BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
5547 const t_ARGS_01& args_01,
5548 const t_ARGS_02& args_02,
5549 const t_ARGS_03& args_03,
5550 const t_ARGS_04& args_04)
5551{
5552 typedef Format_Imp_TruncatingIterator<wchar_t *, wchar_t, ptrdiff_t>
5553 TruncatingIterator;
5554
5555 TruncatingIterator it(0, 0);
5556 TruncatingIterator end = format_to(it, fmtStr, args_01,
5557 args_02,
5558 args_03,
5559 args_04);
5560 return end.count();
5561}
5562#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 4
5563
5564#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 5
5565template <class t_ARGS_01,
5566 class t_ARGS_02,
5567 class t_ARGS_03,
5568 class t_ARGS_04,
5569 class t_ARGS_05>
5570std::size_t formatted_size(BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
5571 const t_ARGS_01& args_01,
5572 const t_ARGS_02& args_02,
5573 const t_ARGS_03& args_03,
5574 const t_ARGS_04& args_04,
5575 const t_ARGS_05& args_05)
5576{
5577 typedef Format_Imp_TruncatingIterator<wchar_t *, wchar_t, ptrdiff_t>
5578 TruncatingIterator;
5579
5580 TruncatingIterator it(0, 0);
5581 TruncatingIterator end = format_to(it, fmtStr, args_01,
5582 args_02,
5583 args_03,
5584 args_04,
5585 args_05);
5586 return end.count();
5587}
5588#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 5
5589
5590#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 6
5591template <class t_ARGS_01,
5592 class t_ARGS_02,
5593 class t_ARGS_03,
5594 class t_ARGS_04,
5595 class t_ARGS_05,
5596 class t_ARGS_06>
5597std::size_t formatted_size(BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
5598 const t_ARGS_01& args_01,
5599 const t_ARGS_02& args_02,
5600 const t_ARGS_03& args_03,
5601 const t_ARGS_04& args_04,
5602 const t_ARGS_05& args_05,
5603 const t_ARGS_06& args_06)
5604{
5605 typedef Format_Imp_TruncatingIterator<wchar_t *, wchar_t, ptrdiff_t>
5606 TruncatingIterator;
5607
5608 TruncatingIterator it(0, 0);
5609 TruncatingIterator end = format_to(it, fmtStr, args_01,
5610 args_02,
5611 args_03,
5612 args_04,
5613 args_05,
5614 args_06);
5615 return end.count();
5616}
5617#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 6
5618
5619#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 7
5620template <class t_ARGS_01,
5621 class t_ARGS_02,
5622 class t_ARGS_03,
5623 class t_ARGS_04,
5624 class t_ARGS_05,
5625 class t_ARGS_06,
5626 class t_ARGS_07>
5627std::size_t formatted_size(BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
5628 const t_ARGS_01& args_01,
5629 const t_ARGS_02& args_02,
5630 const t_ARGS_03& args_03,
5631 const t_ARGS_04& args_04,
5632 const t_ARGS_05& args_05,
5633 const t_ARGS_06& args_06,
5634 const t_ARGS_07& args_07)
5635{
5636 typedef Format_Imp_TruncatingIterator<wchar_t *, wchar_t, ptrdiff_t>
5637 TruncatingIterator;
5638
5639 TruncatingIterator it(0, 0);
5640 TruncatingIterator end = format_to(it, fmtStr, args_01,
5641 args_02,
5642 args_03,
5643 args_04,
5644 args_05,
5645 args_06,
5646 args_07);
5647 return end.count();
5648}
5649#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 7
5650
5651#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 8
5652template <class t_ARGS_01,
5653 class t_ARGS_02,
5654 class t_ARGS_03,
5655 class t_ARGS_04,
5656 class t_ARGS_05,
5657 class t_ARGS_06,
5658 class t_ARGS_07,
5659 class t_ARGS_08>
5660std::size_t formatted_size(BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
5661 const t_ARGS_01& args_01,
5662 const t_ARGS_02& args_02,
5663 const t_ARGS_03& args_03,
5664 const t_ARGS_04& args_04,
5665 const t_ARGS_05& args_05,
5666 const t_ARGS_06& args_06,
5667 const t_ARGS_07& args_07,
5668 const t_ARGS_08& args_08)
5669{
5670 typedef Format_Imp_TruncatingIterator<wchar_t *, wchar_t, ptrdiff_t>
5671 TruncatingIterator;
5672
5673 TruncatingIterator it(0, 0);
5674 TruncatingIterator end = format_to(it, fmtStr, args_01,
5675 args_02,
5676 args_03,
5677 args_04,
5678 args_05,
5679 args_06,
5680 args_07,
5681 args_08);
5682 return end.count();
5683}
5684#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 8
5685
5686#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 9
5687template <class t_ARGS_01,
5688 class t_ARGS_02,
5689 class t_ARGS_03,
5690 class t_ARGS_04,
5691 class t_ARGS_05,
5692 class t_ARGS_06,
5693 class t_ARGS_07,
5694 class t_ARGS_08,
5695 class t_ARGS_09>
5696std::size_t formatted_size(BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
5697 const t_ARGS_01& args_01,
5698 const t_ARGS_02& args_02,
5699 const t_ARGS_03& args_03,
5700 const t_ARGS_04& args_04,
5701 const t_ARGS_05& args_05,
5702 const t_ARGS_06& args_06,
5703 const t_ARGS_07& args_07,
5704 const t_ARGS_08& args_08,
5705 const t_ARGS_09& args_09)
5706{
5707 typedef Format_Imp_TruncatingIterator<wchar_t *, wchar_t, ptrdiff_t>
5708 TruncatingIterator;
5709
5710 TruncatingIterator it(0, 0);
5711 TruncatingIterator end = format_to(it, fmtStr, args_01,
5712 args_02,
5713 args_03,
5714 args_04,
5715 args_05,
5716 args_06,
5717 args_07,
5718 args_08,
5719 args_09);
5720 return end.count();
5721}
5722#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 9
5723
5724#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 10
5725template <class t_ARGS_01,
5726 class t_ARGS_02,
5727 class t_ARGS_03,
5728 class t_ARGS_04,
5729 class t_ARGS_05,
5730 class t_ARGS_06,
5731 class t_ARGS_07,
5732 class t_ARGS_08,
5733 class t_ARGS_09,
5734 class t_ARGS_10>
5735std::size_t formatted_size(BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
5736 const t_ARGS_01& args_01,
5737 const t_ARGS_02& args_02,
5738 const t_ARGS_03& args_03,
5739 const t_ARGS_04& args_04,
5740 const t_ARGS_05& args_05,
5741 const t_ARGS_06& args_06,
5742 const t_ARGS_07& args_07,
5743 const t_ARGS_08& args_08,
5744 const t_ARGS_09& args_09,
5745 const t_ARGS_10& args_10)
5746{
5747 typedef Format_Imp_TruncatingIterator<wchar_t *, wchar_t, ptrdiff_t>
5748 TruncatingIterator;
5749
5750 TruncatingIterator it(0, 0);
5751 TruncatingIterator end = format_to(it, fmtStr, args_01,
5752 args_02,
5753 args_03,
5754 args_04,
5755 args_05,
5756 args_06,
5757 args_07,
5758 args_08,
5759 args_09,
5760 args_10);
5761 return end.count();
5762}
5763#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 10
5764
5765
5766
5767#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 0
5768template <class t_OUT>
5769format_to_n_result<t_OUT>
5770format_to_n(t_OUT out,
5771 typename bsl::iterator_traits<t_OUT>::difference_type maxNumChars,
5772 BSLFMT_FORMAT_STRING_PARAMETER fmtStr)
5773{
5774 if (maxNumChars < 0)
5775 maxNumChars = 0;
5776
5777 typedef Format_Imp_TruncatingIterator<
5778 t_OUT,
5779 typename bsl::iterator_traits<t_OUT>::value_type,
5780 typename bsl::iterator_traits<t_OUT>::difference_type>
5781 TruncatingIterator;
5782
5783 TruncatingIterator it(out, maxNumChars);
5784
5785 TruncatingIterator end = format_to(it, fmtStr);
5786
5787 format_to_n_result<t_OUT> result;
5788 result.out = end.underlying();
5789 result.size = end.count();
5790 return result;
5791}
5792#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 0
5793
5794#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 1
5795template <class t_OUT, class t_ARGS_01>
5796format_to_n_result<t_OUT>
5797format_to_n(t_OUT out,
5798 typename bsl::iterator_traits<t_OUT>::difference_type maxNumChars,
5799 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
5800 const t_ARGS_01& args_01)
5801{
5802 if (maxNumChars < 0)
5803 maxNumChars = 0;
5804
5805 typedef Format_Imp_TruncatingIterator<
5806 t_OUT,
5807 typename bsl::iterator_traits<t_OUT>::value_type,
5808 typename bsl::iterator_traits<t_OUT>::difference_type>
5809 TruncatingIterator;
5810
5811 TruncatingIterator it(out, maxNumChars);
5812
5813 TruncatingIterator end = format_to(it, fmtStr, args_01);
5814
5815 format_to_n_result<t_OUT> result;
5816 result.out = end.underlying();
5817 result.size = end.count();
5818 return result;
5819}
5820#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 1
5821
5822#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 2
5823template <class t_OUT, class t_ARGS_01,
5824 class t_ARGS_02>
5825format_to_n_result<t_OUT>
5826format_to_n(t_OUT out,
5827 typename bsl::iterator_traits<t_OUT>::difference_type maxNumChars,
5828 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
5829 const t_ARGS_01& args_01,
5830 const t_ARGS_02& args_02)
5831{
5832 if (maxNumChars < 0)
5833 maxNumChars = 0;
5834
5835 typedef Format_Imp_TruncatingIterator<
5836 t_OUT,
5837 typename bsl::iterator_traits<t_OUT>::value_type,
5838 typename bsl::iterator_traits<t_OUT>::difference_type>
5839 TruncatingIterator;
5840
5841 TruncatingIterator it(out, maxNumChars);
5842
5843 TruncatingIterator end = format_to(it, fmtStr, args_01,
5844 args_02);
5845
5846 format_to_n_result<t_OUT> result;
5847 result.out = end.underlying();
5848 result.size = end.count();
5849 return result;
5850}
5851#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 2
5852
5853#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 3
5854template <class t_OUT, class t_ARGS_01,
5855 class t_ARGS_02,
5856 class t_ARGS_03>
5857format_to_n_result<t_OUT>
5858format_to_n(t_OUT out,
5859 typename bsl::iterator_traits<t_OUT>::difference_type maxNumChars,
5860 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
5861 const t_ARGS_01& args_01,
5862 const t_ARGS_02& args_02,
5863 const t_ARGS_03& args_03)
5864{
5865 if (maxNumChars < 0)
5866 maxNumChars = 0;
5867
5868 typedef Format_Imp_TruncatingIterator<
5869 t_OUT,
5870 typename bsl::iterator_traits<t_OUT>::value_type,
5871 typename bsl::iterator_traits<t_OUT>::difference_type>
5872 TruncatingIterator;
5873
5874 TruncatingIterator it(out, maxNumChars);
5875
5876 TruncatingIterator end = format_to(it, fmtStr, args_01,
5877 args_02,
5878 args_03);
5879
5880 format_to_n_result<t_OUT> result;
5881 result.out = end.underlying();
5882 result.size = end.count();
5883 return result;
5884}
5885#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 3
5886
5887#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 4
5888template <class t_OUT, class t_ARGS_01,
5889 class t_ARGS_02,
5890 class t_ARGS_03,
5891 class t_ARGS_04>
5892format_to_n_result<t_OUT>
5893format_to_n(t_OUT out,
5894 typename bsl::iterator_traits<t_OUT>::difference_type maxNumChars,
5895 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
5896 const t_ARGS_01& args_01,
5897 const t_ARGS_02& args_02,
5898 const t_ARGS_03& args_03,
5899 const t_ARGS_04& args_04)
5900{
5901 if (maxNumChars < 0)
5902 maxNumChars = 0;
5903
5904 typedef Format_Imp_TruncatingIterator<
5905 t_OUT,
5906 typename bsl::iterator_traits<t_OUT>::value_type,
5907 typename bsl::iterator_traits<t_OUT>::difference_type>
5908 TruncatingIterator;
5909
5910 TruncatingIterator it(out, maxNumChars);
5911
5912 TruncatingIterator end = format_to(it, fmtStr, args_01,
5913 args_02,
5914 args_03,
5915 args_04);
5916
5917 format_to_n_result<t_OUT> result;
5918 result.out = end.underlying();
5919 result.size = end.count();
5920 return result;
5921}
5922#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 4
5923
5924#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 5
5925template <class t_OUT, class t_ARGS_01,
5926 class t_ARGS_02,
5927 class t_ARGS_03,
5928 class t_ARGS_04,
5929 class t_ARGS_05>
5930format_to_n_result<t_OUT>
5931format_to_n(t_OUT out,
5932 typename bsl::iterator_traits<t_OUT>::difference_type maxNumChars,
5933 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
5934 const t_ARGS_01& args_01,
5935 const t_ARGS_02& args_02,
5936 const t_ARGS_03& args_03,
5937 const t_ARGS_04& args_04,
5938 const t_ARGS_05& args_05)
5939{
5940 if (maxNumChars < 0)
5941 maxNumChars = 0;
5942
5943 typedef Format_Imp_TruncatingIterator<
5944 t_OUT,
5945 typename bsl::iterator_traits<t_OUT>::value_type,
5946 typename bsl::iterator_traits<t_OUT>::difference_type>
5947 TruncatingIterator;
5948
5949 TruncatingIterator it(out, maxNumChars);
5950
5951 TruncatingIterator end = format_to(it, fmtStr, args_01,
5952 args_02,
5953 args_03,
5954 args_04,
5955 args_05);
5956
5957 format_to_n_result<t_OUT> result;
5958 result.out = end.underlying();
5959 result.size = end.count();
5960 return result;
5961}
5962#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 5
5963
5964#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 6
5965template <class t_OUT, class t_ARGS_01,
5966 class t_ARGS_02,
5967 class t_ARGS_03,
5968 class t_ARGS_04,
5969 class t_ARGS_05,
5970 class t_ARGS_06>
5971format_to_n_result<t_OUT>
5972format_to_n(t_OUT out,
5973 typename bsl::iterator_traits<t_OUT>::difference_type maxNumChars,
5974 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
5975 const t_ARGS_01& args_01,
5976 const t_ARGS_02& args_02,
5977 const t_ARGS_03& args_03,
5978 const t_ARGS_04& args_04,
5979 const t_ARGS_05& args_05,
5980 const t_ARGS_06& args_06)
5981{
5982 if (maxNumChars < 0)
5983 maxNumChars = 0;
5984
5985 typedef Format_Imp_TruncatingIterator<
5986 t_OUT,
5987 typename bsl::iterator_traits<t_OUT>::value_type,
5988 typename bsl::iterator_traits<t_OUT>::difference_type>
5989 TruncatingIterator;
5990
5991 TruncatingIterator it(out, maxNumChars);
5992
5993 TruncatingIterator end = format_to(it, fmtStr, args_01,
5994 args_02,
5995 args_03,
5996 args_04,
5997 args_05,
5998 args_06);
5999
6000 format_to_n_result<t_OUT> result;
6001 result.out = end.underlying();
6002 result.size = end.count();
6003 return result;
6004}
6005#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 6
6006
6007#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 7
6008template <class t_OUT, class t_ARGS_01,
6009 class t_ARGS_02,
6010 class t_ARGS_03,
6011 class t_ARGS_04,
6012 class t_ARGS_05,
6013 class t_ARGS_06,
6014 class t_ARGS_07>
6015format_to_n_result<t_OUT>
6016format_to_n(t_OUT out,
6017 typename bsl::iterator_traits<t_OUT>::difference_type maxNumChars,
6018 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
6019 const t_ARGS_01& args_01,
6020 const t_ARGS_02& args_02,
6021 const t_ARGS_03& args_03,
6022 const t_ARGS_04& args_04,
6023 const t_ARGS_05& args_05,
6024 const t_ARGS_06& args_06,
6025 const t_ARGS_07& args_07)
6026{
6027 if (maxNumChars < 0)
6028 maxNumChars = 0;
6029
6030 typedef Format_Imp_TruncatingIterator<
6031 t_OUT,
6032 typename bsl::iterator_traits<t_OUT>::value_type,
6033 typename bsl::iterator_traits<t_OUT>::difference_type>
6034 TruncatingIterator;
6035
6036 TruncatingIterator it(out, maxNumChars);
6037
6038 TruncatingIterator end = format_to(it, fmtStr, args_01,
6039 args_02,
6040 args_03,
6041 args_04,
6042 args_05,
6043 args_06,
6044 args_07);
6045
6046 format_to_n_result<t_OUT> result;
6047 result.out = end.underlying();
6048 result.size = end.count();
6049 return result;
6050}
6051#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 7
6052
6053#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 8
6054template <class t_OUT, class t_ARGS_01,
6055 class t_ARGS_02,
6056 class t_ARGS_03,
6057 class t_ARGS_04,
6058 class t_ARGS_05,
6059 class t_ARGS_06,
6060 class t_ARGS_07,
6061 class t_ARGS_08>
6062format_to_n_result<t_OUT>
6063format_to_n(t_OUT out,
6064 typename bsl::iterator_traits<t_OUT>::difference_type maxNumChars,
6065 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
6066 const t_ARGS_01& args_01,
6067 const t_ARGS_02& args_02,
6068 const t_ARGS_03& args_03,
6069 const t_ARGS_04& args_04,
6070 const t_ARGS_05& args_05,
6071 const t_ARGS_06& args_06,
6072 const t_ARGS_07& args_07,
6073 const t_ARGS_08& args_08)
6074{
6075 if (maxNumChars < 0)
6076 maxNumChars = 0;
6077
6078 typedef Format_Imp_TruncatingIterator<
6079 t_OUT,
6080 typename bsl::iterator_traits<t_OUT>::value_type,
6081 typename bsl::iterator_traits<t_OUT>::difference_type>
6082 TruncatingIterator;
6083
6084 TruncatingIterator it(out, maxNumChars);
6085
6086 TruncatingIterator end = format_to(it, fmtStr, args_01,
6087 args_02,
6088 args_03,
6089 args_04,
6090 args_05,
6091 args_06,
6092 args_07,
6093 args_08);
6094
6095 format_to_n_result<t_OUT> result;
6096 result.out = end.underlying();
6097 result.size = end.count();
6098 return result;
6099}
6100#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 8
6101
6102#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 9
6103template <class t_OUT, class t_ARGS_01,
6104 class t_ARGS_02,
6105 class t_ARGS_03,
6106 class t_ARGS_04,
6107 class t_ARGS_05,
6108 class t_ARGS_06,
6109 class t_ARGS_07,
6110 class t_ARGS_08,
6111 class t_ARGS_09>
6112format_to_n_result<t_OUT>
6113format_to_n(t_OUT out,
6114 typename bsl::iterator_traits<t_OUT>::difference_type maxNumChars,
6115 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
6116 const t_ARGS_01& args_01,
6117 const t_ARGS_02& args_02,
6118 const t_ARGS_03& args_03,
6119 const t_ARGS_04& args_04,
6120 const t_ARGS_05& args_05,
6121 const t_ARGS_06& args_06,
6122 const t_ARGS_07& args_07,
6123 const t_ARGS_08& args_08,
6124 const t_ARGS_09& args_09)
6125{
6126 if (maxNumChars < 0)
6127 maxNumChars = 0;
6128
6129 typedef Format_Imp_TruncatingIterator<
6130 t_OUT,
6131 typename bsl::iterator_traits<t_OUT>::value_type,
6132 typename bsl::iterator_traits<t_OUT>::difference_type>
6133 TruncatingIterator;
6134
6135 TruncatingIterator it(out, maxNumChars);
6136
6137 TruncatingIterator end = format_to(it, fmtStr, args_01,
6138 args_02,
6139 args_03,
6140 args_04,
6141 args_05,
6142 args_06,
6143 args_07,
6144 args_08,
6145 args_09);
6146
6147 format_to_n_result<t_OUT> result;
6148 result.out = end.underlying();
6149 result.size = end.count();
6150 return result;
6151}
6152#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 9
6153
6154#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 10
6155template <class t_OUT, class t_ARGS_01,
6156 class t_ARGS_02,
6157 class t_ARGS_03,
6158 class t_ARGS_04,
6159 class t_ARGS_05,
6160 class t_ARGS_06,
6161 class t_ARGS_07,
6162 class t_ARGS_08,
6163 class t_ARGS_09,
6164 class t_ARGS_10>
6165format_to_n_result<t_OUT>
6166format_to_n(t_OUT out,
6167 typename bsl::iterator_traits<t_OUT>::difference_type maxNumChars,
6168 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
6169 const t_ARGS_01& args_01,
6170 const t_ARGS_02& args_02,
6171 const t_ARGS_03& args_03,
6172 const t_ARGS_04& args_04,
6173 const t_ARGS_05& args_05,
6174 const t_ARGS_06& args_06,
6175 const t_ARGS_07& args_07,
6176 const t_ARGS_08& args_08,
6177 const t_ARGS_09& args_09,
6178 const t_ARGS_10& args_10)
6179{
6180 if (maxNumChars < 0)
6181 maxNumChars = 0;
6182
6183 typedef Format_Imp_TruncatingIterator<
6184 t_OUT,
6185 typename bsl::iterator_traits<t_OUT>::value_type,
6186 typename bsl::iterator_traits<t_OUT>::difference_type>
6187 TruncatingIterator;
6188
6189 TruncatingIterator it(out, maxNumChars);
6190
6191 TruncatingIterator end = format_to(it, fmtStr, args_01,
6192 args_02,
6193 args_03,
6194 args_04,
6195 args_05,
6196 args_06,
6197 args_07,
6198 args_08,
6199 args_09,
6200 args_10);
6201
6202 format_to_n_result<t_OUT> result;
6203 result.out = end.underlying();
6204 result.size = end.count();
6205 return result;
6206}
6207#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 10
6208
6209
6210#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 0
6211template <class t_OUT>
6212format_to_n_result<t_OUT>
6213format_to_n(t_OUT out,
6214 typename bsl::iterator_traits<t_OUT>::difference_type maxNumChars,
6215 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr)
6216{
6217 if (maxNumChars < 0)
6218 maxNumChars = 0;
6219
6220 typedef Format_Imp_TruncatingIterator<
6221 t_OUT,
6222 typename bsl::iterator_traits<t_OUT>::value_type,
6223 typename bsl::iterator_traits<t_OUT>::difference_type>
6224 TruncatingIterator;
6225
6226 TruncatingIterator it(out, maxNumChars);
6227
6228 TruncatingIterator end = format_to(it, fmtStr);
6229
6230 format_to_n_result<t_OUT> result;
6231 result.out = end.underlying();
6232 result.size = end.count();
6233 return result;
6234}
6235#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 0
6236
6237#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 1
6238template <class t_OUT, class t_ARGS_01>
6239format_to_n_result<t_OUT>
6240format_to_n(t_OUT out,
6241 typename bsl::iterator_traits<t_OUT>::difference_type maxNumChars,
6242 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
6243 const t_ARGS_01& args_01)
6244{
6245 if (maxNumChars < 0)
6246 maxNumChars = 0;
6247
6248 typedef Format_Imp_TruncatingIterator<
6249 t_OUT,
6250 typename bsl::iterator_traits<t_OUT>::value_type,
6251 typename bsl::iterator_traits<t_OUT>::difference_type>
6252 TruncatingIterator;
6253
6254 TruncatingIterator it(out, maxNumChars);
6255
6256 TruncatingIterator end = format_to(it, fmtStr, args_01);
6257
6258 format_to_n_result<t_OUT> result;
6259 result.out = end.underlying();
6260 result.size = end.count();
6261 return result;
6262}
6263#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 1
6264
6265#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 2
6266template <class t_OUT, class t_ARGS_01,
6267 class t_ARGS_02>
6268format_to_n_result<t_OUT>
6269format_to_n(t_OUT out,
6270 typename bsl::iterator_traits<t_OUT>::difference_type maxNumChars,
6271 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
6272 const t_ARGS_01& args_01,
6273 const t_ARGS_02& args_02)
6274{
6275 if (maxNumChars < 0)
6276 maxNumChars = 0;
6277
6278 typedef Format_Imp_TruncatingIterator<
6279 t_OUT,
6280 typename bsl::iterator_traits<t_OUT>::value_type,
6281 typename bsl::iterator_traits<t_OUT>::difference_type>
6282 TruncatingIterator;
6283
6284 TruncatingIterator it(out, maxNumChars);
6285
6286 TruncatingIterator end = format_to(it, fmtStr, args_01,
6287 args_02);
6288
6289 format_to_n_result<t_OUT> result;
6290 result.out = end.underlying();
6291 result.size = end.count();
6292 return result;
6293}
6294#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 2
6295
6296#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 3
6297template <class t_OUT, class t_ARGS_01,
6298 class t_ARGS_02,
6299 class t_ARGS_03>
6300format_to_n_result<t_OUT>
6301format_to_n(t_OUT out,
6302 typename bsl::iterator_traits<t_OUT>::difference_type maxNumChars,
6303 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
6304 const t_ARGS_01& args_01,
6305 const t_ARGS_02& args_02,
6306 const t_ARGS_03& args_03)
6307{
6308 if (maxNumChars < 0)
6309 maxNumChars = 0;
6310
6311 typedef Format_Imp_TruncatingIterator<
6312 t_OUT,
6313 typename bsl::iterator_traits<t_OUT>::value_type,
6314 typename bsl::iterator_traits<t_OUT>::difference_type>
6315 TruncatingIterator;
6316
6317 TruncatingIterator it(out, maxNumChars);
6318
6319 TruncatingIterator end = format_to(it, fmtStr, args_01,
6320 args_02,
6321 args_03);
6322
6323 format_to_n_result<t_OUT> result;
6324 result.out = end.underlying();
6325 result.size = end.count();
6326 return result;
6327}
6328#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 3
6329
6330#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 4
6331template <class t_OUT, class t_ARGS_01,
6332 class t_ARGS_02,
6333 class t_ARGS_03,
6334 class t_ARGS_04>
6335format_to_n_result<t_OUT>
6336format_to_n(t_OUT out,
6337 typename bsl::iterator_traits<t_OUT>::difference_type maxNumChars,
6338 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
6339 const t_ARGS_01& args_01,
6340 const t_ARGS_02& args_02,
6341 const t_ARGS_03& args_03,
6342 const t_ARGS_04& args_04)
6343{
6344 if (maxNumChars < 0)
6345 maxNumChars = 0;
6346
6347 typedef Format_Imp_TruncatingIterator<
6348 t_OUT,
6349 typename bsl::iterator_traits<t_OUT>::value_type,
6350 typename bsl::iterator_traits<t_OUT>::difference_type>
6351 TruncatingIterator;
6352
6353 TruncatingIterator it(out, maxNumChars);
6354
6355 TruncatingIterator end = format_to(it, fmtStr, args_01,
6356 args_02,
6357 args_03,
6358 args_04);
6359
6360 format_to_n_result<t_OUT> result;
6361 result.out = end.underlying();
6362 result.size = end.count();
6363 return result;
6364}
6365#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 4
6366
6367#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 5
6368template <class t_OUT, class t_ARGS_01,
6369 class t_ARGS_02,
6370 class t_ARGS_03,
6371 class t_ARGS_04,
6372 class t_ARGS_05>
6373format_to_n_result<t_OUT>
6374format_to_n(t_OUT out,
6375 typename bsl::iterator_traits<t_OUT>::difference_type maxNumChars,
6376 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
6377 const t_ARGS_01& args_01,
6378 const t_ARGS_02& args_02,
6379 const t_ARGS_03& args_03,
6380 const t_ARGS_04& args_04,
6381 const t_ARGS_05& args_05)
6382{
6383 if (maxNumChars < 0)
6384 maxNumChars = 0;
6385
6386 typedef Format_Imp_TruncatingIterator<
6387 t_OUT,
6388 typename bsl::iterator_traits<t_OUT>::value_type,
6389 typename bsl::iterator_traits<t_OUT>::difference_type>
6390 TruncatingIterator;
6391
6392 TruncatingIterator it(out, maxNumChars);
6393
6394 TruncatingIterator end = format_to(it, fmtStr, args_01,
6395 args_02,
6396 args_03,
6397 args_04,
6398 args_05);
6399
6400 format_to_n_result<t_OUT> result;
6401 result.out = end.underlying();
6402 result.size = end.count();
6403 return result;
6404}
6405#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 5
6406
6407#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 6
6408template <class t_OUT, class t_ARGS_01,
6409 class t_ARGS_02,
6410 class t_ARGS_03,
6411 class t_ARGS_04,
6412 class t_ARGS_05,
6413 class t_ARGS_06>
6414format_to_n_result<t_OUT>
6415format_to_n(t_OUT out,
6416 typename bsl::iterator_traits<t_OUT>::difference_type maxNumChars,
6417 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
6418 const t_ARGS_01& args_01,
6419 const t_ARGS_02& args_02,
6420 const t_ARGS_03& args_03,
6421 const t_ARGS_04& args_04,
6422 const t_ARGS_05& args_05,
6423 const t_ARGS_06& args_06)
6424{
6425 if (maxNumChars < 0)
6426 maxNumChars = 0;
6427
6428 typedef Format_Imp_TruncatingIterator<
6429 t_OUT,
6430 typename bsl::iterator_traits<t_OUT>::value_type,
6431 typename bsl::iterator_traits<t_OUT>::difference_type>
6432 TruncatingIterator;
6433
6434 TruncatingIterator it(out, maxNumChars);
6435
6436 TruncatingIterator end = format_to(it, fmtStr, args_01,
6437 args_02,
6438 args_03,
6439 args_04,
6440 args_05,
6441 args_06);
6442
6443 format_to_n_result<t_OUT> result;
6444 result.out = end.underlying();
6445 result.size = end.count();
6446 return result;
6447}
6448#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 6
6449
6450#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 7
6451template <class t_OUT, class t_ARGS_01,
6452 class t_ARGS_02,
6453 class t_ARGS_03,
6454 class t_ARGS_04,
6455 class t_ARGS_05,
6456 class t_ARGS_06,
6457 class t_ARGS_07>
6458format_to_n_result<t_OUT>
6459format_to_n(t_OUT out,
6460 typename bsl::iterator_traits<t_OUT>::difference_type maxNumChars,
6461 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
6462 const t_ARGS_01& args_01,
6463 const t_ARGS_02& args_02,
6464 const t_ARGS_03& args_03,
6465 const t_ARGS_04& args_04,
6466 const t_ARGS_05& args_05,
6467 const t_ARGS_06& args_06,
6468 const t_ARGS_07& args_07)
6469{
6470 if (maxNumChars < 0)
6471 maxNumChars = 0;
6472
6473 typedef Format_Imp_TruncatingIterator<
6474 t_OUT,
6475 typename bsl::iterator_traits<t_OUT>::value_type,
6476 typename bsl::iterator_traits<t_OUT>::difference_type>
6477 TruncatingIterator;
6478
6479 TruncatingIterator it(out, maxNumChars);
6480
6481 TruncatingIterator end = format_to(it, fmtStr, args_01,
6482 args_02,
6483 args_03,
6484 args_04,
6485 args_05,
6486 args_06,
6487 args_07);
6488
6489 format_to_n_result<t_OUT> result;
6490 result.out = end.underlying();
6491 result.size = end.count();
6492 return result;
6493}
6494#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 7
6495
6496#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 8
6497template <class t_OUT, class t_ARGS_01,
6498 class t_ARGS_02,
6499 class t_ARGS_03,
6500 class t_ARGS_04,
6501 class t_ARGS_05,
6502 class t_ARGS_06,
6503 class t_ARGS_07,
6504 class t_ARGS_08>
6505format_to_n_result<t_OUT>
6506format_to_n(t_OUT out,
6507 typename bsl::iterator_traits<t_OUT>::difference_type maxNumChars,
6508 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
6509 const t_ARGS_01& args_01,
6510 const t_ARGS_02& args_02,
6511 const t_ARGS_03& args_03,
6512 const t_ARGS_04& args_04,
6513 const t_ARGS_05& args_05,
6514 const t_ARGS_06& args_06,
6515 const t_ARGS_07& args_07,
6516 const t_ARGS_08& args_08)
6517{
6518 if (maxNumChars < 0)
6519 maxNumChars = 0;
6520
6521 typedef Format_Imp_TruncatingIterator<
6522 t_OUT,
6523 typename bsl::iterator_traits<t_OUT>::value_type,
6524 typename bsl::iterator_traits<t_OUT>::difference_type>
6525 TruncatingIterator;
6526
6527 TruncatingIterator it(out, maxNumChars);
6528
6529 TruncatingIterator end = format_to(it, fmtStr, args_01,
6530 args_02,
6531 args_03,
6532 args_04,
6533 args_05,
6534 args_06,
6535 args_07,
6536 args_08);
6537
6538 format_to_n_result<t_OUT> result;
6539 result.out = end.underlying();
6540 result.size = end.count();
6541 return result;
6542}
6543#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 8
6544
6545#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 9
6546template <class t_OUT, class t_ARGS_01,
6547 class t_ARGS_02,
6548 class t_ARGS_03,
6549 class t_ARGS_04,
6550 class t_ARGS_05,
6551 class t_ARGS_06,
6552 class t_ARGS_07,
6553 class t_ARGS_08,
6554 class t_ARGS_09>
6555format_to_n_result<t_OUT>
6556format_to_n(t_OUT out,
6557 typename bsl::iterator_traits<t_OUT>::difference_type maxNumChars,
6558 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
6559 const t_ARGS_01& args_01,
6560 const t_ARGS_02& args_02,
6561 const t_ARGS_03& args_03,
6562 const t_ARGS_04& args_04,
6563 const t_ARGS_05& args_05,
6564 const t_ARGS_06& args_06,
6565 const t_ARGS_07& args_07,
6566 const t_ARGS_08& args_08,
6567 const t_ARGS_09& args_09)
6568{
6569 if (maxNumChars < 0)
6570 maxNumChars = 0;
6571
6572 typedef Format_Imp_TruncatingIterator<
6573 t_OUT,
6574 typename bsl::iterator_traits<t_OUT>::value_type,
6575 typename bsl::iterator_traits<t_OUT>::difference_type>
6576 TruncatingIterator;
6577
6578 TruncatingIterator it(out, maxNumChars);
6579
6580 TruncatingIterator end = format_to(it, fmtStr, args_01,
6581 args_02,
6582 args_03,
6583 args_04,
6584 args_05,
6585 args_06,
6586 args_07,
6587 args_08,
6588 args_09);
6589
6590 format_to_n_result<t_OUT> result;
6591 result.out = end.underlying();
6592 result.size = end.count();
6593 return result;
6594}
6595#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 9
6596
6597#if BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 10
6598template <class t_OUT, class t_ARGS_01,
6599 class t_ARGS_02,
6600 class t_ARGS_03,
6601 class t_ARGS_04,
6602 class t_ARGS_05,
6603 class t_ARGS_06,
6604 class t_ARGS_07,
6605 class t_ARGS_08,
6606 class t_ARGS_09,
6607 class t_ARGS_10>
6608format_to_n_result<t_OUT>
6609format_to_n(t_OUT out,
6610 typename bsl::iterator_traits<t_OUT>::difference_type maxNumChars,
6611 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
6612 const t_ARGS_01& args_01,
6613 const t_ARGS_02& args_02,
6614 const t_ARGS_03& args_03,
6615 const t_ARGS_04& args_04,
6616 const t_ARGS_05& args_05,
6617 const t_ARGS_06& args_06,
6618 const t_ARGS_07& args_07,
6619 const t_ARGS_08& args_08,
6620 const t_ARGS_09& args_09,
6621 const t_ARGS_10& args_10)
6622{
6623 if (maxNumChars < 0)
6624 maxNumChars = 0;
6625
6626 typedef Format_Imp_TruncatingIterator<
6627 t_OUT,
6628 typename bsl::iterator_traits<t_OUT>::value_type,
6629 typename bsl::iterator_traits<t_OUT>::difference_type>
6630 TruncatingIterator;
6631
6632 TruncatingIterator it(out, maxNumChars);
6633
6634 TruncatingIterator end = format_to(it, fmtStr, args_01,
6635 args_02,
6636 args_03,
6637 args_04,
6638 args_05,
6639 args_06,
6640 args_07,
6641 args_08,
6642 args_09,
6643 args_10);
6644
6645 format_to_n_result<t_OUT> result;
6646 result.out = end.underlying();
6647 result.size = end.count();
6648 return result;
6649}
6650#endif // BSLFMT_FORMAT_IMP_VARIADIC_LIMIT_B >= 10
6651
6652#else
6653// The generated code below is a workaround for the absence of perfect
6654// forwarding in some compilers.
6655template <class t_OUT, class... t_ARGS>
6656typename bsl::enable_if<
6657 !bsl::is_same<typename bsl::decay<t_OUT>::type, bsl::string *>::value,
6658 t_OUT>::type
6659format_to(t_OUT out,
6660 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
6661 const t_ARGS&... args)
6662{
6663 return vformat_to(out, fmtStr.get(), bslfmt::make_format_args(args...));
6664}
6665
6666template <class t_OUT, class... t_ARGS>
6667typename bsl::enable_if<
6668 !bsl::is_same<typename bsl::decay<t_OUT>::type, bsl::wstring *>::value,
6669 t_OUT>::type
6670format_to(t_OUT out,
6671 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
6672 const t_ARGS&... args)
6673{
6674 return vformat_to(out, fmtStr.get(), bslfmt::make_wformat_args(args...));
6675}
6676
6677template <class... t_ARGS>
6678void format_to(bsl::string *out,
6679 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
6680 const t_ARGS&... args)
6681{
6682 vformat_to(bsl::back_inserter(*out),
6683 fmtStr.get(),
6684 bslfmt::make_format_args(args...));
6685}
6686
6687template <class... t_ARGS>
6688void format_to(bsl::wstring *out,
6689 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
6690 const t_ARGS&... args)
6691{
6692 vformat_to(bsl::back_inserter(*out),
6693 fmtStr.get(),
6694 bslfmt::make_wformat_args(args...));
6695}
6696
6697template <class... t_ARGS>
6698bsl::string format(BSLFMT_FORMAT_STRING_PARAMETER fmtStr, const t_ARGS&...args)
6699{
6700 bsl::string result;
6701 vformat_to(&result, fmtStr.get(), bslfmt::make_format_args(args...));
6702 return result;
6703}
6704
6705template <class... t_ARGS>
6706bsl::wstring format(BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
6707 const t_ARGS&... args)
6708{
6709 bsl::wstring result;
6710 vformat_to(&result, fmtStr.get(), bslfmt::make_wformat_args(args...));
6711 return result;
6712}
6713
6714template <class... t_ARGS>
6715bsl::string format(bsl::allocator<char> alloc,
6716 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
6717 const t_ARGS&... args)
6718{
6719 bsl::string result(alloc);
6720 vformat_to(&result, fmtStr.get(), bslfmt::make_format_args(args...));
6721 return bsl::string(result, alloc);
6722}
6723
6724template <class... t_ARGS>
6725bsl::wstring format(bsl::allocator<wchar_t> alloc,
6726 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
6727 const t_ARGS&... args)
6728{
6729 bsl::wstring result(alloc);
6730 vformat_to(&result, fmtStr.get(), bslfmt::make_wformat_args(args...));
6731 return bsl::wstring(result, alloc);
6732}
6733
6734template <class... t_ARGS>
6735std::size_t formatted_size(BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
6736 const t_ARGS&... args)
6737{
6738 typedef Format_Imp_TruncatingIterator<char *, char, ptrdiff_t>
6739 TruncatingIterator;
6740
6741 TruncatingIterator it(0, 0);
6742 TruncatingIterator end = format_to(it, fmtStr, args...);
6743 return end.count();
6744}
6745
6746template <class... t_ARGS>
6747std::size_t formatted_size(BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
6748 const t_ARGS&... args)
6749{
6750 typedef Format_Imp_TruncatingIterator<wchar_t *, wchar_t, ptrdiff_t>
6751 TruncatingIterator;
6752
6753 TruncatingIterator it(0, 0);
6754 TruncatingIterator end = format_to(it, fmtStr, args...);
6755 return end.count();
6756}
6757
6758
6759template <class t_OUT, class... t_ARGS>
6760format_to_n_result<t_OUT>
6761format_to_n(t_OUT out,
6762 typename bsl::iterator_traits<t_OUT>::difference_type maxNumChars,
6763 BSLFMT_FORMAT_STRING_PARAMETER fmtStr,
6764 const t_ARGS&... args)
6765{
6766 if (maxNumChars < 0)
6767 maxNumChars = 0;
6768
6769 typedef Format_Imp_TruncatingIterator<
6770 t_OUT,
6771 typename bsl::iterator_traits<t_OUT>::value_type,
6772 typename bsl::iterator_traits<t_OUT>::difference_type>
6773 TruncatingIterator;
6774
6775 TruncatingIterator it(out, maxNumChars);
6776
6777 TruncatingIterator end = format_to(it, fmtStr, args...);
6778
6779 format_to_n_result<t_OUT> result;
6780 result.out = end.underlying();
6781 result.size = end.count();
6782 return result;
6783}
6784
6785template <class t_OUT, class... t_ARGS>
6786format_to_n_result<t_OUT>
6787format_to_n(t_OUT out,
6788 typename bsl::iterator_traits<t_OUT>::difference_type maxNumChars,
6789 BSLFMT_FORMAT_WSTRING_PARAMETER fmtStr,
6790 const t_ARGS&... args)
6791{
6792 if (maxNumChars < 0)
6793 maxNumChars = 0;
6794
6795 typedef Format_Imp_TruncatingIterator<
6796 t_OUT,
6797 typename bsl::iterator_traits<t_OUT>::value_type,
6798 typename bsl::iterator_traits<t_OUT>::difference_type>
6799 TruncatingIterator;
6800
6801 TruncatingIterator it(out, maxNumChars);
6802
6803 TruncatingIterator end = format_to(it, fmtStr, args...);
6804
6805 format_to_n_result<t_OUT> result;
6806 result.out = end.underlying();
6807 result.size = end.count();
6808 return result;
6809}
6810// }}} END GENERATED CODE
6811#endif
6812
6813
6814} // close package namespace
6815
6816
6817#undef BSLFMT_FORMAT_STRING_PARAMETER
6818#undef BSLFMT_FORMAT_WSTRING_PARAMETER
6819
6820#else // if ! defined(DEFINED_BSLFMT_FORMAT_IMP_H)
6821# error Not valid except when included from bslfmt_format_imp.h
6822#endif // ! defined(COMPILING_BSLFMT_FORMAT_IMP_H)
6823
6824#endif // ! defined(INCLUDED_BSLFMT_FORMAT_IMP_CPP03)
6825
6826// ----------------------------------------------------------------------------
6827// Copyright 2023 Bloomberg Finance L.P.
6828//
6829// Licensed under the Apache License, Version 2.0 (the "License");
6830// you may not use this file except in compliance with the License.
6831// You may obtain a copy of the License at
6832//
6833// http://www.apache.org/licenses/LICENSE-2.0
6834//
6835// Unless required by applicable law or agreed to in writing, software
6836// distributed under the License is distributed on an "AS IS" BASIS,
6837// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
6838// See the License for the specific language governing permissions and
6839// limitations under the License.
6840// ----------------------------- END-OF-FILE ----------------------------------
6841
6842/** @} */
6843/** @} */
6844/** @} */
bsl::allocator
Definition bslma_bslallocator.h:588
bsl::basic_string_view
Definition bslstl_stringview.h:471
bsl::basic_string_view::iterator
const_iterator iterator
Definition bslstl_stringview.h:482
bsl::basic_string
Definition bslstl_string.h:1252
bslfmt::Format_Imp_TruncatingIterator::operator=
void operator=(t_VALUE_TYPE x)
Definition bslfmt_format_imp.h:671
bslfmt::Format_Imp_TruncatingIterator::difference_type
t_DIFF_TYPE difference_type
Definition bslfmt_format_imp.h:249
bslfmt::Format_Imp_TruncatingIterator::Format_Imp_TruncatingIterator
Format_Imp_TruncatingIterator(t_ITERATOR iterator, t_DIFF_TYPE limit)
Definition bslfmt_format_imp.h:653
bslfmt::Format_Imp_TruncatingIterator::operator*
Format_Imp_TruncatingIterator & operator*()
Definition bslfmt_format_imp.h:664
bslfmt::Format_Imp_TruncatingIterator::value_type
t_VALUE_TYPE value_type
Definition bslfmt_format_imp.h:250
bslfmt::Format_Imp_TruncatingIterator::underlying
t_ITERATOR underlying() const
Return the underlying iterator.
Definition bslfmt_format_imp.h:702
bslfmt::Format_Imp_TruncatingIterator::pointer
void pointer
Definition bslfmt_format_imp.h:252
bslfmt::Format_Imp_TruncatingIterator::reference
void reference
Definition bslfmt_format_imp.h:251
bslfmt::Format_Imp_TruncatingIterator::iterator_category
bsl::output_iterator_tag iterator_category
Definition bslfmt_format_imp.h:248
bslfmt::Format_Imp_TruncatingIterator::operator++
Format_Imp_TruncatingIterator & operator++()
Definition bslfmt_format_imp.h:685
bslfmt::Format_Imp_TruncatingIterator::count
t_DIFF_TYPE count() const
Definition bslfmt_format_imp.h:693
BSLFMT_FORMAT_WSTRING_PARAMETER
#define BSLFMT_FORMAT_WSTRING_PARAMETER
Definition bslfmt_format_imp.h:210
BSLFMT_FORMAT_STRING_PARAMETER
#define BSLFMT_FORMAT_STRING_PARAMETER
Definition bslfmt_format_imp.h:209
BSLS_ASSERT_OPT_UNREACHABLE
#define BSLS_ASSERT_OPT_UNREACHABLE(X)
Definition bsls_assert.h:2065
BSLS_THROW
#define BSLS_THROW(X)
Definition bsls_exceptionutil.h:374
BSLS_KEYWORD_DELETED
#define BSLS_KEYWORD_DELETED
Definition bsls_keyword.h:651
bsl::wstring
basic_string< wchar_t > wstring
Definition bslstl_string.h:845
bsl::end
T::iterator end(T &container)
Definition bslstl_iterator.h:1621
bsl::string
basic_string< char > string
Definition bslstl_string.h:844
bsl::as_const
BSLS_KEYWORD_CONSTEXPR bsl::add_const< TYPE >::type & as_const(TYPE &t) BSLS_KEYWORD_NOEXCEPT
Return a reference offering non-modifiable access to the specified t.
Definition bslstl_utility.h:129
bslfmt
Definition bslfmt_enablestreamedformatter.h:130
bslfmt::vformat
bsl::string vformat(bsl::string_view fmt, format_args args)
Definition bslfmt_format_imp.h:1006
bslfmt::format_to_n
format_to_n_result< t_OUT > format_to_n(t_OUT out, typename bsl::iterator_traits< t_OUT >::difference_type maxNumChars, BSLFMT_FORMAT_STRING_PARAMETER fmtStr, const t_ARGS &... args)
Definition bslfmt_format_imp.h:1148
bslfmt::visit_format_arg
bsl::invoke_result< t_VISITOR &, bsl::monostate & >::type visit_format_arg(t_VISITOR &visitor, basic_format_arg< t_CONTEXT > arg)
Definition bslfmt_format_arg.h:907
bslfmt::format_to
bsl::enable_if<!bsl::is_same< typenamebsl::decay< t_OUT >::type, bsl::string * >::value, t_OUT >::type format_to(t_OUT out, BSLFMT_FORMAT_STRING_PARAMETER fmtStr, const t_ARGS &... args)
Definition bslfmt_format_imp.h:1046
bslfmt::formatted_size
std::size_t formatted_size(BSLFMT_FORMAT_STRING_PARAMETER fmtStr, const t_ARGS &... args)
Definition bslfmt_format_imp.h:1122
bslfmt::make_format_args
Format_ArgsStore< format_context, t_ARGS... > make_format_args(t_ARGS &... fmt_args)
Definition bslfmt_format_args.h:461
bslfmt::format
bsl::string format(BSLFMT_FORMAT_STRING_PARAMETER fmtStr, const t_ARGS &... args)
Definition bslfmt_format_imp.h:1085
bslfmt::format_args
basic_format_args< format_context > format_args
Definition bslfmt_format_args.h:197
bslfmt::vformat_to
t_OUT vformat_to(t_OUT out, bsl::string_view fmtStr, format_args args)
Definition bslfmt_format_imp.h:981
bslfmt::wformat_args
basic_format_args< wformat_context > wformat_args
Definition bslfmt_format_args.h:199
bslfmt::make_wformat_args
Format_ArgsStore< wformat_context, t_ARGS... > make_wformat_args(t_ARGS &... fmt_args)
Definition bslfmt_format_args.h:469
bsl::enable_if
Definition bslmf_enableif.h:530
bsl::formatter
Definition bslfmt_formatterbase.h:426
bsl::is_same
Definition bslmf_issame.h:146
bsl::monostate
Definition bslstl_monostate.h:77
bslfmt::Format_Imp_Processor::process
static Format_ContextOutputIteratorRef< t_CHAR > process(Format_ContextOutputIteratorRef< t_CHAR > out, bsl::basic_string_view< t_CHAR > fmtStr, const basic_format_args< basic_format_context< Format_ContextOutputIteratorRef< t_CHAR >, t_CHAR > > &args)
Definition bslfmt_format_imp.h:953
bslfmt::Format_Imp_Visitor::operator()
void operator()(bsl::monostate) const
Definition bslfmt_format_imp.h:725
bslfmt::Format_Imp_Visitor::Format_Imp_Visitor
Format_Imp_Visitor(basic_format_parse_context< t_CHAR > &pc, basic_format_context< t_OUT, t_CHAR > &fc)
Definition bslfmt_format_imp.h:714
bslfmt::format_to_n_result::out
t_OUT out
Definition bslfmt_format_imp.h:313
bslfmt::format_to_n_result::size
bsl::iterator_traits< t_OUT >::difference_type size
Definition bslfmt_format_imp.h:315