std::regex_traits< _Ch_type >(3)                      Library Functions Manual

NAME
       std::regex_traits< _Ch_type > - Describes aspects of a regular
       expression.


SYNOPSIS
       #include <regex>

   Public Types
       typedef _RegexMask char_class_type
       typedef _Ch_type char_type
       typedef std::locale locale_type
       typedef std::basic_string< char_type > string_type

   Public Member Functions
       regex_traits ()
           Constructs a default traits object.
       locale_type getloc () const
           Gets a copy of the current locale in use by the regex_traits
           object.
       locale_type imbue (locale_type __loc)
           Imbues the regex_traits object with a copy of a new locale.
       bool isctype (_Ch_type __c, char_class_type __f) const
           Determines if c is a member of an identified class.
       template<typename _Fwd_iter > char_class_type lookup_classname
           (_Fwd_iter __first, _Fwd_iter __last, bool __icase=false) const
           Maps one or more characters to a named character classification.
       template<typename _Fwd_iter > string_type lookup_collatename (_Fwd_iter
           __first, _Fwd_iter __last) const
           Gets a collation element by name.
       template<typename _Fwd_iter > string_type transform (_Fwd_iter __first,
           _Fwd_iter __last) const
           Gets a sort key for a character sequence.
       template<typename _Fwd_iter > string_type transform_primary (_Fwd_iter
           __first, _Fwd_iter __last) const
           Gets a sort key for a character sequence, independent of case.
       char_type translate (char_type __c) const
           Performs the identity translation.
       char_type translate_nocase (char_type __c) const
           Translates a character into a case-insensitive equivalent.
       int value (_Ch_type __ch, int __radix) const
           Converts a digit to an int.

   Static Public Member Functions
       static std::size_t length (const char_type *__p)
           Gives the length of a C-style string starting at __p.

   Protected Attributes
       locale_type _M_locale

Detailed Description
   template<typename _Ch_type>
       class std::regex_traits< _Ch_type >"Describes aspects of a regular
       expression.

       A regular expression traits class that satisfies the requirements of
       section [28.7].

       The class regex is parameterized around a set of related types and
       functions used to complete the definition of its semantics. This class
       satisfies the requirements of such a traits class.

       Since
           C++11

Constructor & Destructor Documentation
   template<typename _Ch_type > std::regex_traits< _Ch_type >::regex_traits ()
       [inline]
       Constructs a default traits object.

Member Function Documentation
   template<typename _Ch_type > locale_type std::regex_traits< _Ch_type
       >::getloc () const [inline]
       Gets a copy of the current locale in use by the regex_traits object.

       Referenced by std::regex_traits< _CharType >::isctype().

   template<typename _Ch_type > locale_type std::regex_traits< _Ch_type
       >::imbue (locale_type __loc) [inline]
       Imbues the regex_traits object with a copy of a new locale.

       Parameters
           __loc A locale.

       Returns
           a copy of the previous locale in use by the regex_traits object.

       Note
           Calling imbue with a different locale than the one currently in use
           invalidates all cached data held by *this.

       References std::forward().

   template<typename _Ch_type > bool std::regex_traits< _Ch_type >::isctype
       (_Ch_type __c, char_class_type __f) const
       Determines if c is a member of an identified class.

       Parameters
           __c a character.
           __f a class type (as returned from lookup_classname).

       Returns
           true if the character __c is a member of the classification
           represented by __f, false otherwise.

       Exceptions
           std::bad_cast if the current locale does not have a ctype facet.

       References std::forward().

   template<typename _Ch_type > static std::size_t std::regex_traits< _Ch_type
       >::length (const char_type * __p) [inline],  [static]
       Gives the length of a C-style string starting at __p.

       Parameters
           __p a pointer to the start of a character sequence.

       Returns
           the number of characters between *__p and the first default-
           initialized value of type char_type. In other words, uses the C-
           string algorithm for determining the length of a sequence of
           characters.

       References std::basic_string< _CharT, _Traits, _Alloc >::length().

   template<typename _Ch_type > template<typename _Fwd_iter > regex_traits<
       _Ch_type >::char_class_type std::regex_traits< _Ch_type
       >::lookup_classname (_Fwd_iter __first, _Fwd_iter __last, bool __icase
       = false) const
       Maps one or more characters to a named character classification.

       Parameters
           __first beginning of the character sequence.
           __last one-past-the-end of the character sequence.
           __icase ignores the case of the classification name.

       Returns
           an unspecified value that represents the character classification
           named by the character sequence designated by the iterator range
           [__first, __last). If icase is true, the returned mask identifies
           the classification regardless of the case of the characters to be
           matched (for example, [[:lower:]] is the same as [[:alpha:]]),
           otherwise a case-dependent classification is returned. The value
           returned shall be independent of the case of the characters in the
           character sequence. If the name is not recognized then returns a
           value that compares equal to 0.

       At least the following names (or their wide-character equivalent) are
       supported.

       o d

       o w

       o s

       o alnum

       o alpha

       o blank

       o cntrl

       o digit

       o graph

       o lower

       o print

       o punct

       o space

       o upper

       o xdigit

       References std::forward().

   template<typename _Ch_type > template<typename _Fwd_iter > regex_traits<
       _Ch_type >::string_type std::regex_traits< _Ch_type
       >::lookup_collatename (_Fwd_iter __first, _Fwd_iter __last) const
       Gets a collation element by name.

       Parameters
           __first beginning of the collation element name.
           __last one-past-the-end of the collation element name.

       Returns
           a sequence of one or more characters that represents the collating
           element consisting of the character sequence designated by the
           iterator range [__first, __last). Returns an empty string if the
           character sequence is not a valid collating element.

       References std::forward().

   template<typename _Ch_type > template<typename _Fwd_iter > string_type
       std::regex_traits< _Ch_type >::transform (_Fwd_iter __first, _Fwd_iter
       __last) const [inline]
       Gets a sort key for a character sequence.

       Parameters
           __first beginning of the character sequence.
           __last one-past-the-end of the character sequence.

       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).

       What this really does is provide a more efficient way to compare a
       string to multiple other strings in locales with fancy collation rules
       and equivalence classes.

       Returns
           a locale-specific sort key equivalent to the input range.

       Exceptions
           std::bad_cast if the current locale does not have a collate facet.

       References std::forward().

       Referenced by std::regex_traits< _Ch_type >::transform_primary().

   template<typename _Ch_type > template<typename _Fwd_iter > string_type
       std::regex_traits< _Ch_type >::transform_primary (_Fwd_iter __first,
       _Fwd_iter __last) const [inline]
       Gets a sort key for a character sequence, independent of case.

       Parameters
           __first beginning of the character sequence.
           __last one-past-the-end of the character sequence.

       Effects: if typeid(use_facet<collate<_Ch_type> >) ==
       typeid(collate_byname<_Ch_type>) and the form of the sort key returned
       by collate_byname<_Ch_type>::transform(__first, __last) is known and
       can be converted into a primary sort key then returns that key,
       otherwise returns an empty string.

       Todo
           Implement this function correctly.

       References std::forward(), and std::regex_traits< _Ch_type
       >::transform().

   template<typename _Ch_type > char_type std::regex_traits< _Ch_type
       >::translate (char_type __c) const [inline]
       Performs the identity translation.

       Parameters
           __c A character to the locale-specific character set.

       Returns
           __c.

   template<typename _Ch_type > char_type std::regex_traits< _Ch_type
       >::translate_nocase (char_type __c) const [inline]
       Translates a character into a case-insensitive equivalent.

       Parameters
           __c A character to the locale-specific character set.

       Returns
           the locale-specific lower-case equivalent of __c.

       Exceptions
           std::bad_cast if the imbued locale does not support the ctype
           facet.

       References std::forward().

   template<typename _Ch_type > int std::regex_traits< _Ch_type >::value
       (_Ch_type __ch, int __radix) const
       Converts a digit to an int.

       Parameters
           __ch a character representing a digit.
           __radix the radix if the numeric conversion (limited to 8, 10, or
           16).

       Returns
           the value represented by the digit __ch in base radix if the
           character __ch is a valid digit in base radix; otherwise returns
           -1.

       References std::forward(), std::hex(), and std::oct().


Author
       Generated automatically by Doxygen for libstdc++ from the source code.

                                   libstdc++  std::regex_traits< _Ch_type >(3)