home | help 
std::regex_...up_classname(3)  C++ Standard Libary std::regex_...up_classname(3)

NAME
     std::regex_traits::lookup_classname - std::regex_traits::lookup_classname

Synopsis
	template< class ForwardIt >

	char_class_type lookup_classname( ForwardIt first,
					  ForwardIt last,

					  bool icase = false ) const;

	If  the  character sequence [first, last) represents the name of a valid
     character
	class in the currently imbued locale (that is, the string between [: and
     :] in
	regular expressions), returns the  implementation-defined  value  repre-
     senting this
	character class. Otherwise, returns zero.

	If  the  parameter  icase is true, the character class ignores character
     case, e.g. the
	regex [:lower:] with std::regex_constants::icase generates a call to
	std::regex_traits<>::lookup_classname() with  [first,  last)  indicating
     the string
	"lower"  and  icase  ==  true. This call returns the same bitmask as the
     call generated
	by the regex [:alpha:] with icase == false.

	The following narrow and wide character class names  are  always  recog-
     nized by
	std::regex_traits<char> and std::regex_traits<wchar_t> respectively, and
     the
	classifications  returned (with icase == false) correspond to the match-
     ing
	classifications obtained by the std::ctype facet of the  imbued  locale,
     as follows:

			 Character class name	  std::ctype classification
			 Narrow        Wide
		       "alnum"	   L"alnum"	std::ctype_base::alnum
		       "alpha"	   L"alpha"	std::ctype_base::alpha
		       "blank"	   L"blank"	std::ctype_base::blank
		       "cntrl"	   L"cntrl"	std::ctype_base::cntrl
		       "digit"	   L"digit"	std::ctype_base::digit
		       "graph"	   L"graph"	std::ctype_base::graph
		       "lower"	   L"lower"	std::ctype_base::lower
		       "print"	   L"print"	std::ctype_base::print
		       "punct"	   L"punct"	std::ctype_base::punct
		       "space"	   L"space"	std::ctype_base::space
		       "upper"	   L"upper"	std::ctype_base::upper
		       "xdigit"    L"xdigit"	std::ctype_base::xdigit
		       "d"	   L"d" 	std::ctype_base::digit
		       "s"	   L"s" 	std::ctype_base::space
		       "w"	   L"w" 	std::ctype_base::alnum
						with '_' optionally added

	The  classification  returned for the string "w" may be exactly the same
     as "alnum",
	in which case isctype() adds '_' explicitly.

	Additional classifications such as "jdigit" or "jkanji" may be	provided
     by
	system-supplied locales (in which case they are also accessible through
	std::wctype).

Parameters
	first, last - a pair of iterators which determines the sequence of char-
     acters that
		      represents a name of a character class
	icase	     -	if true, ignores the upper/lower case distinction in the
     character
		      classification

Type requirements
	-
	ForwardIt must meet the requirements of LegacyForwardIterator.

Return value
	The bitmask representing the character classification determined by  the
     given
	character class, or char_class_type() if the class is unknown.

Example
	Demonstrates  a custom regex traits implementation of lookup_classname()
     / isctype():

     // Run this code

      #include <cwctype>
      #include <iostream>
      #include <locale>
      #include <regex>

      //  This	custom	regex	traits	 uses	wctype/iswctype   to   implement
     lookup_classname/isctype.
      struct wctype_traits : std::regex_traits<wchar_t>
      {
	  using char_class_type = std::wctype_t;

	  template<class It>
	  char_class_type  lookup_classname(It	first,	It  last,  bool = false)
     const
	  {
	      return std::wctype(std::string(first, last).c_str());
	  }

	  bool isctype(wchar_t c, char_class_type f) const
	  {
	      return std::iswctype(c, f);
	  }
      };

      int main()
      {
	  std::locale::global(std::locale("ja_JP.utf8"));
	  std::wcout.sync_with_stdio(false);
	  std::wcout.imbue(std::locale());

	  std::wsmatch m;
	  std::wstring in = L"ec"a(R)e<degree>.a(R)aa|a.a<<";
	  // matches all characters (they are classified as alnum)
	  std::regex_search(in, m, std::wregex(L"([[:alnum:]]+)"));
	  std::wcout   <<   "alnums:   "   <<	m[1]   <<   '\n';   //	  prints
     "ec"a(R)e<degree>.a(R)aa|a.a<<"
	  // matches only the katakana
	  std::regex_search(in, m,
			    std::basic_regex<wchar_t,			     wc-
     type_traits>(L"([[:jkata:]]+)"));
	  std::wcout << "katakana: " << m[1] << '\n'; // prints "aa|a.a<<"
      }

Output:
      alnums: ec"a(R)e<degree>.a(R)aa|a.a<<
      katakana: aa|a.a<<

See also
	isctype indicates membership in a character class
		(public member function)
	wctype	looks up a character classification category in  the  current  C
     locale
		(function)

http://cppreference.com 	   2024.06.10	   std::regex_...up_classname(3)
home | help