ALib C++ Library
Library Version: 2510 R0
Documentation generated by doxygen
Loading...
Searching...
No Matches
formatterpythonstyle.inl
Go to the documentation of this file.
1//==================================================================================================
2/// \file
3/// This header-file is part of module \alib_format of the \aliblong.
4///
5/// \emoji :copyright: 2013-2025 A-Worx GmbH, Germany.
6/// Published under \ref mainpage_license "Boost Software License".
7//==================================================================================================
9 //==============================================================================================
10 /// Implements a \alib{format;Formatter} according to the
11 /// \https{formatting standards of the Python language,docs.python.org/3.5/library/string.html#format-string-syntax}.
12 ///
13 /// \note
14 /// Inherited, public fields of parent class \b FormatterStdImpl provide important possibilities
15 /// for changing the formatting behavior of instances of this class. Therefore, do not forget
16 /// to consult the \ref alib::format::FormatterStdImpl "parent classes documentation".
17 ///
18 /// In general, the original \b Python specification is covered quite well. However, there are
19 /// some differences, some things are not possible (considering python being a scripting language)
20 /// but then there are also found some very helpful extensions to that standard. Instead of repeating
21 /// a complete documentation, please refer to the
22 /// \https{Python Documentation,docs.python.org/3.5/library/string.html#format-string-syntax}
23 /// as the foundation and then take note of the following list of differences, extensions and
24 /// general hints:
25 ///
26 /// - <b>General Notes:</b>
27 /// \b Python defines a placeholder field as follows
28 ///
29 /// "{" [field_name] ["!" conversion] [":" format_spec] "}"
30 ///
31 ///
32 /// - This formatter is <b>less strict</b> in respect to the order of the format symbols. E.g.
33 /// it allows <c>{:11.5,}</c> where Python allows only <c>{:11,.5}</c>
34 ///
35 /// - With this class being derived from
36 /// \ref alib::format::FormatterStdImpl "FormatterStdImpl", features of the parent are
37 /// available to this formatter as well. This is especially true and sometimes useful in respect to
38 /// setting default values number formatting. For example, this allows modifying all number output
39 /// without explicitly repeating the settings in each placeholder of format strings. Other options
40 /// for example the grouping characters used with hexadecimal numbers, cannot be even changed
41 /// with the <b>Python Style</b> formatting options. The only way of doing so is modifying the
42 /// properties of the formatter object before the format operation.
43 ///
44 /// - Nested replacements in format specification fields are (by nature of this implementation
45 /// language) \b not supported.
46 ///
47 /// <p>
48 /// - <b>Positional arguments and field name:</b>
49 /// - By the nature of the implementation language (<em>C++, no introspection</em>) of this class,
50 /// \b field_name can \b not be the name of an identifier, an attribute name or an array element
51 /// index. It can only be a positional argument index, hence a number that chooses a different
52 /// index in the provided argument list.<br>
53 /// However, the use of field names is often a requirement in use cases that offer configurable
54 /// format string setup to the "end user". Therefore, there are two alternatives to cope
55 /// with the limitation:
56 /// - In simple cases, it is possible to just add all optionally needed data in the argument list,
57 /// document their index position and let the user use positional argument notation to choose
58 /// the right value from the list.
59 /// - More elegant however, is the use of class
60 /// \ref alib::format::PropertyFormatter "PropertyFormatter"
61 /// which extends the format specification by custom identifiers which control the placement
62 /// of corresponding data in the format argument list. This class uses a translator table from
63 /// identifier strings to custom callback functions. This way, much more than just simple
64 /// field names are allowed.
65 ///
66 /// - When using positional arguments in a format string placeholders, the Python formatter
67 /// implementation does not allow to switch from <b>automatic field indexing</b> to explicit
68 /// indexing. This \b %Aib implementation does allow it. The automatic index (aka no positional
69 /// argument is given for a next placeholder) always starts with index \c 0 and is incremented
70 /// each time automatic indexing is used. Occurrences of explict indexing have no influence
71 /// on the automatic indexing.
72 ///
73 ///
74 /// <p>
75 /// - <b>Binary, Hexadecimal and Octal Numbers:</b>
76 /// - Binary, hexadecimal and octal output is <b>cut in size</b> (!) when a field width is given that
77 /// is smaller than the resulting amount of digits of the number arguments provided.
78 /// \note This implies that a value written might not be equal to the value given.
79 /// This is not a bug but a design decision. The rationale behind this is that with this
80 /// behavior, there is no need to mask lower digits when passing the arguments to the
81 /// format invocation. In other words, the formatter "assumes" that the given field width
82 /// indicates that only a corresponding number of lower digits are of interest.
83 ///
84 /// - If no width is given and the argument contains a boxed pointer, then the platform-dependent
85 /// full output width of pointer types is used.
86 ///
87 /// - The number <b>grouping option</b> (<c>','</c>) can also be used with binary, hexadecimal and octal
88 /// output.
89 /// The types support different grouping separators for nibbles, bytes, 16-bit and 32-bit words.
90 /// Changing the separator symbols, is not possible with the format fields of the format strings
91 /// (if it was, this would become very incompatible to Python standards). Changes have to be made
92 /// before the format operation by modifying field
93 /// \alib{format;FormatterStdImpl::AlternativeNumberFormat;FormatterStdImpl::AlternativeNumberFormat}
94 /// which is provided through parent class \b %FormatterStdImpl.
95 ///
96 /// - Alternative form (\c '#') adds prefixes as specified in members
97 /// - \alib{strings;TNumberFormat::BinLiteralPrefix;BinLiteralPrefix},
98 /// - \alib{strings;TNumberFormat::HexLiteralPrefix;HexLiteralPrefix}, and
99 /// - \alib{strings;TNumberFormat::OctLiteralPrefix;OctLiteralPrefix}.
100 ///
101 /// For upper case formats, those are taken from field
102 /// \alib{format;FormatterStdImpl::DefaultNumberFormat;FormatterStdImpl::DefaultNumberFormat},
103 /// for lower case formats from
104 /// \alib{format;FormatterStdImpl::AlternativeNumberFormat;FormatterStdImpl::AlternativeNumberFormat}.
105 /// However, in alignment with the \b Python specification, \b both default to lower case
106 /// literals \c "0b", \c "0o" and \c "0x". All defaults may be changed by the user.
107 ///
108 ///
109 /// <p>
110 /// - <b>Floating point values:</b>
111 /// - If floating point values are provided without a type specification in the format string, then
112 /// all values of
113 /// \alib{format;FormatterStdImpl::DefaultNumberFormat;FormatterStdImpl::DefaultNumberFormat}
114 /// are used to format the number
115 /// - For lower case floating point format types (\c 'f' and \c 'e'), the values specified in
116 /// attributes \b %ExponentSeparator, \b %NANLiteral and \b %INFLiteral of object
117 /// \alib{format;FormatterStdImpl::AlternativeNumberFormat;FormatterStdImpl::AlternativeNumberFormat}
118 /// are used. For upper case types (\c 'F' and \c 'E') the corresponding attributes in
119 /// \alib{format;FormatterStdImpl::DefaultNumberFormat;FormatterStdImpl::DefaultNumberFormat} apply.
120 /// - Fixed point formats (\c 'f' and 'F' types) are not supported to use an arbitrary length.
121 /// See class \alib{strings;TNumberFormat;NumberFormat} for the limits.
122 /// Also, very high values and values close to zero may be converted to scientific format.
123 /// Finally, if flag \alib{strings;NumberFormatFlags;ForceScientific} field
124 /// \alib{strings::NumberFormat;Flags} in member #DefaultNumberFormat is \c true, types
125 /// \c 'f' and 'F' behave like types \c 'e' and 'E'.
126 /// - When both, a \p{width} and a \p{precision} is given, then the \p{precision} determines the
127 /// fractional part, even if the type is \b 'g' or \b 'G'. This is different than specified with
128 /// Python formatter, which uses \p{precision} as the overall width in case of types
129 /// \b 'g' or \b 'G'.
130 /// - The 'general format' type for floats, specified with \c 'g' or \c 'G' in the python
131 /// implementation limits the precision of the fractional part, even if \p{precision} is not
132 /// further specified. This implementation does limit the precision only if type is \c 'f'
133 /// or \c 'F'.
134 ///
135 /// <p>
136 /// - <b>%String Conversion:</b><br>
137 /// If \e type \c 's' (or no \e type) is given in the \b format_spec of the replacement field,
138 /// a string representation of the given argument is used.
139 /// In \b Java and \b C# such representation is received by invoking <c>Object.[t|T]oString()</c>.
140 /// Consequently, to support string representations of custom types, in these languages
141 /// the corresponding <b>[t|T]oString()</b> methods of the type have to be implemented.
142 ///
143 /// In C++ the arguments are "boxed" into objects of type
144 /// \ref alib::boxing::Box "Box". For the string representation, the formatter invokes
145 /// box-function \alib{boxing;FAppend}. A default implementation exists which
146 /// for custom types appends the type name and the memory address of the object in hexadecimal
147 /// format. To support custom string representations (for custom types), this box-function
148 /// needs to be implemented for the type in question. Information and sample code on how to do this
149 /// is found in the documentation of \alib_boxing , chapter
150 /// \ref alib_boxing_strings_fappend "10.3 Box-Function FAppend".
151 ///
152 /// - <b>Hash-Value Output:</b><br>
153 /// In extension (and deviation) of the Python specification, format specification type \c 'h' and
154 /// its upper case version \c 'H' is implemented. The hash-values of the argument object is
155 /// written in hexadecimal format. Options of the type are identical to those of \c 'x',
156 /// respectively \c 'X'.
157 ///
158 /// In the C++ language implementation of \alib, instead of hash-values of objects, the pointer
159 /// found in method \alib{boxing;Box::Data} is printed. In case of boxed class-types and default
160 /// default boxing mechanics are used with such class types, this will show the memory address of
161 /// the given instance.
162 ///
163 /// - <b>Boolean output:</b><br>
164 /// In extension (and deviation) of the Python specification, format specification type \c 'B'
165 /// is implemented. The word \b "true" is written if the given value represents a boolean \c true
166 /// value, \b "false" otherwise.
167 ///
168 /// In the C++ language implementation of \alib, the argument is evaluated to boolean by invoking
169 /// box-function \alib{boxing;FIsTrue}.
170 ///
171 /// <p>
172 /// - <b>%Custom %Format Specifications:</b><br>
173 /// With \c Python formatting syntax, placeholders have the following syntax:
174 ///
175 /// "{" [field_name] ["!" conversion] [":" format_spec] "}"
176 ///
177 /// The part that follows the colon is called \b format_spec. \b Python passes this portion of the
178 /// placeholder to a built-in function \c format(). Now, each type may interpret this string in a
179 /// type specific way. But most built-in \b Python types do it along what they call the
180 /// \https{"Format Specification Mini Language",docs.python.org/3.5/library/string.html#format-specification-mini-language}.
181 ///
182 /// With this implementation, the approach is very similar. The only difference is that the
183 /// "Format Specification Mini Language" is implemented for standard types right within this class.
184 /// But before processing \b format_spec, this class will check if the argument type assigned to
185 /// the placeholder disposes of a custom implementation of box function \alib{format;FFormat}.
186 /// If so, this function is invoked and string \b format_spec is passed for custom processing.
187 ///
188 /// Information and sample code on how to adopt custom types to support this interface is
189 /// found in the Programmer's Manual of this module, with chapter
190 /// \ref alib_format_custom_types_fformat.
191 ///
192 /// For example, \alib class \alib{time;DateTime} supports custom formatting with box-function
193 /// \alib{format;FFormat_DateTime} which uses helper-class
194 /// \alib{strings::util;CalendarDateTime} that provides a very common specific mini language
195 /// for \alib{strings::util::CalendarDateTime;Format;formatting date and time values}.
196 ///
197 /// <p>
198 /// - <b>Conversions:</b><br>
199 /// In the \b Python placeholder syntax specification:
200 ///
201 /// "{" [field_name] ["!" conversion] [":" format_spec] "}"
202 ///
203 /// symbol \c '!' if used before the colon <c>':'</c> defines
204 /// what is called the <b>conversion</b>. With \b Python, three options are given:
205 /// \c '!s' which calls \c str() on the value, \c '!r' which calls \c repr() and \c '!a' which
206 /// calls \c ascii(). This is of course not applicable to this formatter. As a replacement,
207 /// this class extends the original specification of that conversion using \c '!'.
208 /// The following provides a list of conversions supported. The names given can be abbreviated
209 /// at any point and ignore letter case, e.g., \c !Upper can be \c !UP or just \c !u.
210 /// In addition, multiple conversions can be given by concatenating them, each repeating
211 /// character \c '!'.<br>
212 /// The conversions supported are:
213 ///
214 /// - <b>!Upper</b><br>
215 /// Converts the contents of the field to upper case.
216 ///
217 /// - <b>!Lower</b><br>
218 /// Converts the contents of the field to lower case.
219 ///
220 /// - <b>!Quote[O[C]]</b><br>
221 /// Puts quote characters around the field.
222 /// Note that these characters are not respecting any optional given field width but instead
223 /// are added to such.
224 /// An alias name for \!Quote is given with \b !Str. As the alias can be abbreviated to \b !s,
225 /// this provides compatibility with the \b Python specification.
226 ///
227 /// In extension to the python syntax specification, one or two optional characters might be
228 /// given after the (optionally abreviated) terms "Quote" respectively "str".
229 /// If one character is given, this is used as the open and closing character. If two are given,
230 /// the first is used as the open character, the second as the closing one.
231 /// For example <b>{!Q'}</b> uses single quotes, or <b>{!Q[]}</b> uses rectangular brackets.
232 /// Bracket types <b>'{'</b> and <b>'}'</b> cannot be used with this conversion.
233 /// To surround a placeholder's contents in this bracket type, add <b>{{</b> and <b>}}</b>
234 /// around the placeholder - resulting in <b>{{{}}}</b>!.
235 ///
236 /// - <b>!ESC[<|>]</b><br>
237 /// In its default behavior or if \c '<' is specified, certain characters are converted to escape
238 /// sequences.
239 /// If \c '>' is given, escape sequences are converted to their (ascii) value.
240 /// See \alib{strings;TEscape;Escape} for details about the conversion
241 /// that is performed.<br>
242 /// An alias name for \b !ESC< is given with \b !a which provides compatibility
243 /// with the \b Python specification.
244 /// \note If \b !ESC< is used in combination with \b !Quote, then \b !ESC< should be the first
245 /// conversion specifier. Otherwise, the quotes inserted might be escaped as well.
246 ///
247 /// - <b>!Fill[Cc]</b><br>
248 /// Inserts as many characters as denoted by the integer type argument.
249 /// By default the fill character is space <c>' '</c>. It can be changed with optional character
250 /// 'C' plus the character wanted.
251 ///
252 /// - <b>!Tab[Cc][NNN]</b><br>
253 /// Inserts fill characters to extend the length of the string to be a multiple of a tab width.
254 /// By default the fill character is space <c>' '</c>. It can be changed with optional character
255 /// 'C' plus the character wanted. The tab width defaults to \c 8. It can be changed by adding
256 /// an unsigned decimal number.
257 ///
258 /// - <b>!ATab[[Cc][NNN]|Reset]</b><br>
259 /// Inserts an "automatic tabulator stop". These are tabulator positions that are stored
260 /// internally and are automatically extended at the moment the actual contents exceeds the
261 /// currently stored tab-position. An arbitrary number of auto tab stop and field width
262 /// (see <b>!AWith</b> below) values is maintained by the formatter.
263 ///
264 /// Which each new invocation of \alib{format;Formatter},
265 /// the first auto value is chosen and with each use of \c !ATab or \c !AWidth, the next value is
266 /// used.<br>
267 /// However the stored values are cleared, whenever \b %Format is invoked on a non-acquired
268 /// formatter! This means, to preserve the auto-positions across multiple format invocations,
269 /// a formatter has to be acquired explicitly before the format operations and released
270 /// afterwards.
271 ///
272 /// Alternatively to this, the positions currently stored with the formatter can be reset with
273 /// providing argument \c Reset in the format string.
274 ///
275 /// By default, the fill character is space <c>' '</c>. It can be changed with optional character
276 /// 'C' plus the character wanted. The optional number provided gives the growth value by which
277 /// the tab will grow if its position is exceeded. This value defaults to \c 3.
278 ///
279 /// Both, auto tab and auto width conversions may be used to increase readability of multiple
280 /// output lines. Of course, output is not completely tabular, only if those values that result
281 /// in the biggest sizes are formatted first. If a perfect tabular output is desired, the data
282 /// to be formatted may be processed twice: Once to temporary buffer which is disposed and then
283 /// a second time to the desired output \b %AString.
284 ///
285 /// - <b>!AWidth[NNN|Reset]</b><br>
286 /// Increases field width with repetitive invocations of format whenever a field value did not
287 /// fit to the actually stored width. Optional decimal number \b NNN is added as a padding value.
288 /// for more information, see <b>!ATab</b> above.
289 ///
290 /// - <b>!Xtinguish</b><br>
291 /// Does not print anything. This is useful if format strings are externalized, e.g defined
292 /// in \alib{camp::Camp;GetResourcePool;library resources}. Modifications of such resources
293 /// might use this conversion to suppress the display of arguments (which usually are
294 /// hard-coded).
295 ///
296 /// - <b>!Replace<search><replace></b><br>
297 /// Searches string \p{search} and replaces with \p{replace}. Both values have to be given
298 /// enclosed by characters \c '<' and \c '>'. In the special case that \p{search} is empty
299 /// (<c><></c>), string \p{replace} will be inserted if the field argument is an empty
300 /// string.
301 ///
302 ///\I{##########################################################################################}
303 /// # Reference Documentation #
304 /// @throws <b>alib::format::FMTExceptions</b>
305 /// - \alib{format::FMTExceptions;ArgumentIndexOutOfBounds}
306 /// - \alib{format::FMTExceptions;IncompatibleTypeCode}
307 /// - \alib{format::FMTExceptions;MissingClosingBracket}
308 /// - \alib{format::FMTExceptions;MissingPrecisionValuePS}
309 /// - \alib{format::FMTExceptions;DuplicateTypeCode}
310 /// - \alib{format::FMTExceptions;UnknownTypeCode}
311 /// - \alib{format::FMTExceptions;ExclamationMarkExpected}
312 /// - \alib{format::FMTExceptions;UnknownConversionPS}
313 /// - \alib{format::FMTExceptions;PrecisionSpecificationWithInteger}
314 //==============================================================================================
316 {
317 // #############################################################################################
318 // Protected fields
319 // #############################################################################################
320 protected:
321 /// Set of extended placeholder attributes, needed for this type of formatter in
322 /// addition to parent's \alib{format::FormatterStdImpl;PlaceholderAttributes}.
324 {
325 /// The portion of the replacement field that represents the conversion specification.
326 /// This specification is given at the beginning of the replacement field, starting with
327 /// \c '!'.
329
330 /// The position where the conversion was read. This is set to \c -1 in #resetPlaceholder.
332
333
334 /// The value read from the precision field. This is set to \c -1 in #resetPlaceholder.
336
337 /// The position where the precision was read. This is set to \c -1 in #resetPlaceholder.
339
340 /// The default precision if not given.
341 /// This is set to \c 6 in #resetPlaceholder, but is changed when specific.
343 };
344
345 /// The extended placeholder attributes.
347
348 // #############################################################################################
349 // Public fields
350 // #############################################################################################
351 public:
352 /// Storage of sizes for auto-tabulator feature <b>{!ATab}</b> and auto field width feature
353 /// <b>{!AWidth}</b>
355
356 /// The default instance of field #Sizes. This might be replaced with an external object.
358
359 // #############################################################################################
360 // Constructor/Destructor
361 // #############################################################################################
362 public:
363 //==========================================================================================
364 /// Constructs this formatter.
365 /// Inherited field #DefaultNumberFormat is initialized to meet the formatting defaults of
366 /// Python.
367 //==========================================================================================
370
371 //==========================================================================================
372 /// Clones and returns a copy of this formatter.
373 ///
374 /// If the formatter attached to field
375 /// \alib{format;Formatter::Next} is of type \b %FormatterStdImpl, then that
376 /// formatter is copied as well.
377 ///
378 /// @returns An object of type \b %FormatterPythonStyle and with the same custom settings
379 /// than this.
380 //==========================================================================================
381 ALIB_DLL virtual
382 SPFormatter Clone() override;
383
384 //==========================================================================================
385 /// Resets #AutoSizes.
386 /// @return An internally allocated container of boxes that may be used to collect
387 /// formatter arguments.
388 //==========================================================================================
389 virtual BoxesMA& Reset() override
390 {
391 Sizes->Reset();
392 return Formatter::Reset();
393 }
394
395
396 // #############################################################################################
397 // Implementation of FormatterStdImpl interface
398 // #############################################################################################
399 protected:
400 //==========================================================================================
401 /// Sets the actual auto tab stop index to \c 0.
402 //==========================================================================================
403 virtual void initializeFormat() override
404 {
405 Sizes->Restart();
406 }
407
408
409
410 //==========================================================================================
411 /// Invokes parent implementation and then applies some changes to reflect what is defined as
412 /// default in the Python string format specification.
413 //==========================================================================================
415 virtual void resetPlaceholder() override;
416
417 //==========================================================================================
418 /// Searches for \c '{' which is not '{{'.
419 ///
420 /// @return The index found, -1 if not found.
421 //==========================================================================================
423 virtual integer findPlaceholder() override;
424
425 //==========================================================================================
426 /// Parses placeholder field in python notation. The portion \p{format_spec} is not
427 /// parsed but stored in member
428 /// \alib{format::FormatterStdImpl::PlaceholderAttributes;FormatSpec}.
429 ///
430 /// @return \c true on success, \c false on errors.
431 //==========================================================================================
433 virtual bool parsePlaceholder() override;
434
435 //==========================================================================================
436 /// Parses the format specification for standard types as specified in
437 /// \https{"Format Specification Mini Language",docs.python.org/3.5/library/string.html#format-specification-mini-language}.
438 ///
439 /// @return \c true on success, \c false on errors.
440 //==========================================================================================
442 virtual bool parseStdFormatSpec() override;
443
444 //==========================================================================================
445 /// Implementation of abstract method
446 /// \alib{format;FormatterStdImpl::writeStringPortion}.<br>
447 /// While writing, replaces \c "{{" with \c "{" and \c "}}" with \c "}" as well as
448 /// standard codes like \c "\\n", \c "\\r" or \c "\\t" with corresponding ascii codes.
449 ///
450 /// @param length The number of characters to write.
451 //==========================================================================================
453 virtual void writeStringPortion( integer length ) override;
454
455 //==========================================================================================
456 /// Processes "conversions" which are specified with \c '!'.
457 ///
458 /// @param startIdx The index of the start of the field written in #targetString.
459 /// \c -1 indicates pre-phase.
460 /// @param target The target string, only if different from field #targetString, which
461 /// indicates intermediate phase.
462 /// @return \c false, if the placeholder should be skipped (nothing is written for it).
463 /// \c true otherwise.
464 //==========================================================================================
466 virtual bool preAndPostProcess( integer startIdx,
467 AString* target ) override;
468
469
470 //==========================================================================================
471 /// Makes some attribute adjustments and invokes standard implementation
472 /// @return \c true if OK, \c false if replacement should be aborted.
473 //==========================================================================================
475 virtual bool checkStdFieldAgainstArgument() override;
476 };
477} // namespace [alib::format]
478
479ALIB_EXPORT namespace alib {
480/// Type alias in namespace \b alib.
482}
virtual ALIB_DLL integer findPlaceholder() override
virtual void initializeFormat() override
Sets the actual auto tab stop index to 0.
virtual ALIB_DLL void writeStringPortion(integer length) override
virtual ALIB_DLL void resetPlaceholder() override
virtual ALIB_DLL bool parseStdFormatSpec() override
virtual ALIB_DLL bool preAndPostProcess(integer startIdx, AString *target) override
virtual ALIB_DLL bool checkStdFieldAgainstArgument() override
AutoSizes SizesDefaultInstance
The default instance of field Sizes. This might be replaced with an external object.
PlaceholderAttributesPS placeholderPS
The extended placeholder attributes.
virtual ALIB_DLL SPFormatter Clone() override
virtual ALIB_DLL bool parsePlaceholder() override
FormatterStdImpl(const String &formatterClassName)
virtual BoxesMA & Reset()
#define ALIB_DLL
Definition alib.inl:496
#define ALIB_EXPORT
Definition alib.inl:488
format::FormatterPythonStyle FormatterPythonStyle
Type alias in namespace alib.
strings::TAString< character, lang::HeapAllocator > AString
Type alias in namespace alib.
lang::integer integer
Type alias in namespace alib.
Definition integers.inl:149
strings::util::AutoSizes AutoSizes
Type alias in namespace alib.
boxing::TBoxes< MonoAllocator > BoxesMA
Type alias in namespace alib.
Definition boxes.inl:245
containers::SharedPtr< format::Formatter > SPFormatter
Definition formatter.inl:42
strings::TSubstring< character > Substring
Type alias in namespace alib.
int ConversionPos
The position where the conversion was read. This is set to -1 in resetPlaceholder.
int PrecisionPos
The position where the precision was read. This is set to -1 in resetPlaceholder.
int Precision
The value read from the precision field. This is set to -1 in resetPlaceholder.