[[charT c] [charT] [Default constructor (must be trivial).]]
[[charT c(c1)] [charT] [Copy constructor (must be trivial).]]
[[c1 = c2] [charT] [Assignment operator (must be trivial).]]
[[c1 == c2] [bool] [true if c1 has the same value as c2.]]
[[c1 != c2] [bool] [true if c1 and c2 are not equal.]]
[[c1 < c2] [bool] [true if the value of c1 is less than c2.]]
[[c1 > c2] [bool] [true if the value of c1 is greater than c2.]]
[[c1 <= c2] [bool] [true if c1 is less than or equal to c2.]]
[[c1 >= c2] [bool] [true if c1 is greater than or equal to c2.]]
[[intmax_t i = c1] [int ] [charT must be convertible to an integral type.
Note: type charT is not required to support this operation, if the traits class used supports the full Boost-specific interface, rather than the minimal standardised-interface (see traits class requirements below).]]
[[charT c(i);] [charT] [charT must be constructable from an integral type.]]
]
[endsect]
[section:traits_concept Traits Class Requirements]
There are two sets of requirements for the `traits` template argument to
[A bitmask type representing a particular character classification. Multiple values of this type can be bitwise-or'ed together to obtain a new valid value.]]
[Returns a character such that for any character d that is to be considered equivalent to c then v.translate(c) == v.translate(d).]]
[[v.translate_nocase(c)]
[X::char_type]
[For all characters C that are to be considered equivalent to c when comparisons are to be performed without regard to case, then v.translate_nocase(c) == v.translate_nocase(C).]]
[[v.transform(F1, F2)]
[X::string_type]
[Returns a sort key for the character sequence designated by the iterator range \[F1, F2) such that if
the character sequence \[G1, G2) sorts before the character sequence \[H1, H2) then
v.transform(G1, G2) < v.transform(H1, H2). ]]
[[v.transform_primary(F1, F2)]
[X::string_type]
[Returns a sort key for the character sequence designated by the iterator range \[F1, F2) such that if the
character sequence \[G1, G2) sorts before the character sequence \[H1, H2) when character case is not considered
then v.transform_primary(G1, G2) < v.transform_primary(H1, H2).]]
[[v.lookup_classname(F1, F2)]
[X::char_class_type]
[Converts the character sequence designated by the iterator range \[F1,F2) into a bitmask type that can subsequently
be passed to isctype. Values returned from lookup_classname can be safely bitwise or'ed together. Returns 0 if the
character sequence is not the name of a character class recognized by X. The value returned shall be independent
of the case of the characters in the sequence.]]
[[v.lookup_collatename(F1, F2)]
[X::string_type]
[Returns a sequence of characters that represents the collating element consisting of the character sequence designated
by the iterator range \[F1, F2). Returns an empty string if the character sequence is not a valid collating element.]]
[[v.isctype(c, v.lookup_classname (F1, F2))][bool][Returns true if character c is a member of the character class designated by the iterator range \[F1, F2), false otherwise.]]
[Returns the value represented by the digit c in base I if the character c is a valid digit in base I; otherwise returns -1. \[Note: the value of I will only be 8, 10, or 16. -end note\]]]
[[Expression][Result][Assertion / Note Pre / Post condition]]
[[X::boost_extensions_tag][An unspecified type.][When present, all of the extensions listed in this table must be present.]]
[[v.syntax_type(c)][regex_constants::syntax_type][Returns a symbolic value of type regex_constants::syntax_type that signifies the meaning of character c within the regular expression grammar.]]
[[v.escape_syntax_type(c)][regex_constants::escape_syntax_type][Returns a symbolic value of type regex_constants::escape_syntax_type, that signifies the meaning of character c within the regular expression grammar, when c has been preceded by an escape character. Precondition: if b is the character preceding c in the expression being parsed then: `v.syntax_type(b) == syntax_escape`]]
[[v.translate(c, b)][X::char_type][Returns a character d such that: for any character d that is to be considered equivalent to c then `v.translate(c,false)==v.translate(d,false)`. Likewise for all characters C that are to be considered equivalent to c when comparisons are to be performed without regard to case, then `v.translate(c,true)==v.translate(C,true)`.]]
[[v.toi(I1, I2, i)][An integer type capable of holding either a charT or an int.][Behaves as follows: if `p == q` or if `*p` is not a digit character then returns -1. Otherwise performs formatted numeric input on the sequence \[p,q) and returns the result as an int. Postcondition: either p == q or *p is a non-digit character.]]
[[v.error_string(I)][std::string][Returns a human readable error string for the error condition i, where i is one of the values enumerated by type regex_constants::error_type. If the value /I/ is not recognized then returns the string "Unknown error" or a localized equivalent.]]
