libstdc++
locale_classes.h
Go to the documentation of this file.
1 // Locale support -*- C++ -*-
2 
3 // Copyright (C) 1997-2016 Free Software Foundation, Inc.
4 //
5 // This file is part of the GNU ISO C++ Library. This library is free
6 // software; you can redistribute it and/or modify it under the
7 // terms of the GNU General Public License as published by the
8 // Free Software Foundation; either version 3, or (at your option)
9 // any later version.
10 
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 // GNU General Public License for more details.
15 
16 // Under Section 7 of GPL version 3, you are granted additional
17 // permissions described in the GCC Runtime Library Exception, version
18 // 3.1, as published by the Free Software Foundation.
19 
20 // You should have received a copy of the GNU General Public License and
21 // a copy of the GCC Runtime Library Exception along with this program;
22 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23 // <http://www.gnu.org/licenses/>.
24 
25 /** @file bits/locale_classes.h
26  * This is an internal header file, included by other library headers.
27  * Do not attempt to use it directly. @headername{locale}
28  */
29 
30 //
31 // ISO C++ 14882: 22.1 Locales
32 //
33 
34 #ifndef _LOCALE_CLASSES_H
35 #define _LOCALE_CLASSES_H 1
36 
37 #pragma GCC system_header
38 
39 #include <bits/localefwd.h>
40 #include <string>
41 #include <ext/atomicity.h>
42 
43 namespace std _GLIBCXX_VISIBILITY(default)
44 {
45 _GLIBCXX_BEGIN_NAMESPACE_VERSION
46 
47  // 22.1.1 Class locale
48  /**
49  * @brief Container class for localization functionality.
50  * @ingroup locales
51  *
52  * The locale class is first a class wrapper for C library locales. It is
53  * also an extensible container for user-defined localization. A locale is
54  * a collection of facets that implement various localization features such
55  * as money, time, and number printing.
56  *
57  * Constructing C++ locales does not change the C library locale.
58  *
59  * This library supports efficient construction and copying of locales
60  * through a reference counting implementation of the locale class.
61  */
62  class locale
63  {
64  public:
65  // Types:
66  /// Definition of locale::category.
67  typedef int category;
68 
69  // Forward decls and friends:
70  class facet;
71  class id;
72  class _Impl;
73 
74  friend class facet;
75  friend class _Impl;
76 
77  template<typename _Facet>
78  friend bool
79  has_facet(const locale&) throw();
80 
81  template<typename _Facet>
82  friend const _Facet&
83  use_facet(const locale&);
84 
85  template<typename _Cache>
86  friend struct __use_cache;
87 
88  //@{
89  /**
90  * @brief Category values.
91  *
92  * The standard category values are none, ctype, numeric, collate, time,
93  * monetary, and messages. They form a bitmask that supports union and
94  * intersection. The category all is the union of these values.
95  *
96  * NB: Order must match _S_facet_categories definition in locale.cc
97  */
98  static const category none = 0;
99  static const category ctype = 1L << 0;
100  static const category numeric = 1L << 1;
101  static const category collate = 1L << 2;
102  static const category time = 1L << 3;
103  static const category monetary = 1L << 4;
104  static const category messages = 1L << 5;
105  static const category all = (ctype | numeric | collate |
106  time | monetary | messages);
107  //@}
108 
109  // Construct/copy/destroy:
110 
111  /**
112  * @brief Default constructor.
113  *
114  * Constructs a copy of the global locale. If no locale has been
115  * explicitly set, this is the C locale.
116  */
117  locale() throw();
118 
119  /**
120  * @brief Copy constructor.
121  *
122  * Constructs a copy of @a other.
123  *
124  * @param __other The locale to copy.
125  */
126  locale(const locale& __other) throw();
127 
128  /**
129  * @brief Named locale constructor.
130  *
131  * Constructs a copy of the named C library locale.
132  *
133  * @param __s Name of the locale to construct.
134  * @throw std::runtime_error if __s is null or an undefined locale.
135  */
136  explicit
137  locale(const char* __s);
138 
139  /**
140  * @brief Construct locale with facets from another locale.
141  *
142  * Constructs a copy of the locale @a base. The facets specified by @a
143  * cat are replaced with those from the locale named by @a s. If base is
144  * named, this locale instance will also be named.
145  *
146  * @param __base The locale to copy.
147  * @param __s Name of the locale to use facets from.
148  * @param __cat Set of categories defining the facets to use from __s.
149  * @throw std::runtime_error if __s is null or an undefined locale.
150  */
151  locale(const locale& __base, const char* __s, category __cat);
152 
153 #if __cplusplus >= 201103L
154  /**
155  * @brief Named locale constructor.
156  *
157  * Constructs a copy of the named C library locale.
158  *
159  * @param __s Name of the locale to construct.
160  * @throw std::runtime_error if __s is an undefined locale.
161  */
162  explicit
163  locale(const std::string& __s) : locale(__s.c_str()) { }
164 
165  /**
166  * @brief Construct locale with facets from another locale.
167  *
168  * Constructs a copy of the locale @a base. The facets specified by @a
169  * cat are replaced with those from the locale named by @a s. If base is
170  * named, this locale instance will also be named.
171  *
172  * @param __base The locale to copy.
173  * @param __s Name of the locale to use facets from.
174  * @param __cat Set of categories defining the facets to use from __s.
175  * @throw std::runtime_error if __s is an undefined locale.
176  */
177  locale(const locale& __base, const std::string& __s, category __cat)
178  : locale(__base, __s.c_str(), __cat) { }
179 #endif
180 
181  /**
182  * @brief Construct locale with facets from another locale.
183  *
184  * Constructs a copy of the locale @a base. The facets specified by @a
185  * cat are replaced with those from the locale @a add. If @a base and @a
186  * add are named, this locale instance will also be named.
187  *
188  * @param __base The locale to copy.
189  * @param __add The locale to use facets from.
190  * @param __cat Set of categories defining the facets to use from add.
191  */
192  locale(const locale& __base, const locale& __add, category __cat);
193 
194  /**
195  * @brief Construct locale with another facet.
196  *
197  * Constructs a copy of the locale @a __other. The facet @a __f
198  * is added to @a __other, replacing an existing facet of type
199  * Facet if there is one. If @a __f is null, this locale is a
200  * copy of @a __other.
201  *
202  * @param __other The locale to copy.
203  * @param __f The facet to add in.
204  */
205  template<typename _Facet>
206  locale(const locale& __other, _Facet* __f);
207 
208  /// Locale destructor.
209  ~locale() throw();
210 
211  /**
212  * @brief Assignment operator.
213  *
214  * Set this locale to be a copy of @a other.
215  *
216  * @param __other The locale to copy.
217  * @return A reference to this locale.
218  */
219  const locale&
220  operator=(const locale& __other) throw();
221 
222  /**
223  * @brief Construct locale with another facet.
224  *
225  * Constructs and returns a new copy of this locale. Adds or replaces an
226  * existing facet of type Facet from the locale @a other into the new
227  * locale.
228  *
229  * @tparam _Facet The facet type to copy from other
230  * @param __other The locale to copy from.
231  * @return Newly constructed locale.
232  * @throw std::runtime_error if __other has no facet of type _Facet.
233  */
234  template<typename _Facet>
235  locale
236  combine(const locale& __other) const;
237 
238  // Locale operations:
239  /**
240  * @brief Return locale name.
241  * @return Locale name or "*" if unnamed.
242  */
243  _GLIBCXX_DEFAULT_ABI_TAG
244  string
245  name() const;
246 
247  /**
248  * @brief Locale equality.
249  *
250  * @param __other The locale to compare against.
251  * @return True if other and this refer to the same locale instance, are
252  * copies, or have the same name. False otherwise.
253  */
254  bool
255  operator==(const locale& __other) const throw();
256 
257  /**
258  * @brief Locale inequality.
259  *
260  * @param __other The locale to compare against.
261  * @return ! (*this == __other)
262  */
263  bool
264  operator!=(const locale& __other) const throw()
265  { return !(this->operator==(__other)); }
266 
267  /**
268  * @brief Compare two strings according to collate.
269  *
270  * Template operator to compare two strings using the compare function of
271  * the collate facet in this locale. One use is to provide the locale to
272  * the sort function. For example, a vector v of strings could be sorted
273  * according to locale loc by doing:
274  * @code
275  * std::sort(v.begin(), v.end(), loc);
276  * @endcode
277  *
278  * @param __s1 First string to compare.
279  * @param __s2 Second string to compare.
280  * @return True if collate<_Char> facet compares __s1 < __s2, else false.
281  */
282  template<typename _Char, typename _Traits, typename _Alloc>
283  bool
285  const basic_string<_Char, _Traits, _Alloc>& __s2) const;
286 
287  // Global locale objects:
288  /**
289  * @brief Set global locale
290  *
291  * This function sets the global locale to the argument and returns a
292  * copy of the previous global locale. If the argument has a name, it
293  * will also call std::setlocale(LC_ALL, loc.name()).
294  *
295  * @param __loc The new locale to make global.
296  * @return Copy of the old global locale.
297  */
298  static locale
299  global(const locale& __loc);
300 
301  /**
302  * @brief Return reference to the C locale.
303  */
304  static const locale&
305  classic();
306 
307  private:
308  // The (shared) implementation
309  _Impl* _M_impl;
310 
311  // The "C" reference locale
312  static _Impl* _S_classic;
313 
314  // Current global locale
315  static _Impl* _S_global;
316 
317  // Names of underlying locale categories.
318  // NB: locale::global() has to know how to modify all the
319  // underlying categories, not just the ones required by the C++
320  // standard.
321  static const char* const* const _S_categories;
322 
323  // Number of standard categories. For C++, these categories are
324  // collate, ctype, monetary, numeric, time, and messages. These
325  // directly correspond to ISO C99 macros LC_COLLATE, LC_CTYPE,
326  // LC_MONETARY, LC_NUMERIC, and LC_TIME. In addition, POSIX (IEEE
327  // 1003.1-2001) specifies LC_MESSAGES.
328  // In addition to the standard categories, the underlying
329  // operating system is allowed to define extra LC_*
330  // macros. For GNU systems, the following are also valid:
331  // LC_PAPER, LC_NAME, LC_ADDRESS, LC_TELEPHONE, LC_MEASUREMENT,
332  // and LC_IDENTIFICATION.
333  enum { _S_categories_size = 6 + _GLIBCXX_NUM_CATEGORIES };
334 
335 #ifdef __GTHREADS
336  static __gthread_once_t _S_once;
337 #endif
338 
339  explicit
340  locale(_Impl*) throw();
341 
342  static void
343  _S_initialize();
344 
345  static void
346  _S_initialize_once() throw();
347 
348  static category
349  _S_normalize_category(category);
350 
351  void
352  _M_coalesce(const locale& __base, const locale& __add, category __cat);
353 
354 #if _GLIBCXX_USE_CXX11_ABI
355  static const id* const _S_twinned_facets[];
356 #endif
357  };
358 
359 
360  // 22.1.1.1.2 Class locale::facet
361  /**
362  * @brief Localization functionality base class.
363  * @ingroup locales
364  *
365  * The facet class is the base class for a localization feature, such as
366  * money, time, and number printing. It provides common support for facets
367  * and reference management.
368  *
369  * Facets may not be copied or assigned.
370  */
372  {
373  private:
374  friend class locale;
375  friend class locale::_Impl;
376 
377  mutable _Atomic_word _M_refcount;
378 
379  // Contains data from the underlying "C" library for the classic locale.
380  static __c_locale _S_c_locale;
381 
382  // String literal for the name of the classic locale.
383  static const char _S_c_name[2];
384 
385 #ifdef __GTHREADS
386  static __gthread_once_t _S_once;
387 #endif
388 
389  static void
390  _S_initialize_once();
391 
392  protected:
393  /**
394  * @brief Facet constructor.
395  *
396  * This is the constructor provided by the standard. If refs is 0, the
397  * facet is destroyed when the last referencing locale is destroyed.
398  * Otherwise the facet will never be destroyed.
399  *
400  * @param __refs The initial value for reference count.
401  */
402  explicit
403  facet(size_t __refs = 0) throw() : _M_refcount(__refs ? 1 : 0)
404  { }
405 
406  /// Facet destructor.
407  virtual
408  ~facet();
409 
410  static void
411  _S_create_c_locale(__c_locale& __cloc, const char* __s,
412  __c_locale __old = 0);
413 
414  static __c_locale
415  _S_clone_c_locale(__c_locale& __cloc) throw();
416 
417  static void
418  _S_destroy_c_locale(__c_locale& __cloc);
419 
420  static __c_locale
421  _S_lc_ctype_c_locale(__c_locale __cloc, const char* __s);
422 
423  // Returns data from the underlying "C" library data for the
424  // classic locale.
425  static __c_locale
426  _S_get_c_locale();
427 
428  _GLIBCXX_CONST static const char*
429  _S_get_c_name() throw();
430 
431 #if __cplusplus < 201103L
432  private:
433  facet(const facet&); // Not defined.
434 
435  facet&
436  operator=(const facet&); // Not defined.
437 #else
438  facet(const facet&) = delete;
439 
440  facet&
441  operator=(const facet&) = delete;
442 #endif
443 
444  private:
445  void
446  _M_add_reference() const throw()
447  { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }
448 
449  void
450  _M_remove_reference() const throw()
451  {
452  // Be race-detector-friendly. For more info see bits/c++config.
453  _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_refcount);
454  if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1)
455  {
456  _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_refcount);
457  __try
458  { delete this; }
459  __catch(...)
460  { }
461  }
462  }
463 
464  class __shim;
465 
466  const facet* _M_sso_shim(const id*) const;
467  const facet* _M_cow_shim(const id*) const;
468  };
469 
470 
471  // 22.1.1.1.3 Class locale::id
472  /**
473  * @brief Facet ID class.
474  * @ingroup locales
475  *
476  * The ID class provides facets with an index used to identify them.
477  * Every facet class must define a public static member locale::id, or be
478  * derived from a facet that provides this member, otherwise the facet
479  * cannot be used in a locale. The locale::id ensures that each class
480  * type gets a unique identifier.
481  */
483  {
484  private:
485  friend class locale;
486  friend class locale::_Impl;
487 
488  template<typename _Facet>
489  friend const _Facet&
490  use_facet(const locale&);
491 
492  template<typename _Facet>
493  friend bool
494  has_facet(const locale&) throw();
495 
496  // NB: There is no accessor for _M_index because it may be used
497  // before the constructor is run; the effect of calling a member
498  // function (even an inline) would be undefined.
499  mutable size_t _M_index;
500 
501  // Last id number assigned.
502  static _Atomic_word _S_refcount;
503 
504  void
505  operator=(const id&); // Not defined.
506 
507  id(const id&); // Not defined.
508 
509  public:
510  // NB: This class is always a static data member, and thus can be
511  // counted on to be zero-initialized.
512  /// Constructor.
513  id() { }
514 
515  size_t
516  _M_id() const throw();
517  };
518 
519 
520  // Implementation object for locale.
521  class locale::_Impl
522  {
523  public:
524  // Friends.
525  friend class locale;
526  friend class locale::facet;
527 
528  template<typename _Facet>
529  friend bool
530  has_facet(const locale&) throw();
531 
532  template<typename _Facet>
533  friend const _Facet&
534  use_facet(const locale&);
535 
536  template<typename _Cache>
537  friend struct __use_cache;
538 
539  private:
540  // Data Members.
541  _Atomic_word _M_refcount;
542  const facet** _M_facets;
543  size_t _M_facets_size;
544  const facet** _M_caches;
545  char** _M_names;
546  static const locale::id* const _S_id_ctype[];
547  static const locale::id* const _S_id_numeric[];
548  static const locale::id* const _S_id_collate[];
549  static const locale::id* const _S_id_time[];
550  static const locale::id* const _S_id_monetary[];
551  static const locale::id* const _S_id_messages[];
552  static const locale::id* const* const _S_facet_categories[];
553 
554  void
555  _M_add_reference() throw()
556  { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }
557 
558  void
559  _M_remove_reference() throw()
560  {
561  // Be race-detector-friendly. For more info see bits/c++config.
562  _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_refcount);
563  if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1)
564  {
565  _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_refcount);
566  __try
567  { delete this; }
568  __catch(...)
569  { }
570  }
571  }
572 
573  _Impl(const _Impl&, size_t);
574  _Impl(const char*, size_t);
575  _Impl(size_t) throw();
576 
577  ~_Impl() throw();
578 
579  _Impl(const _Impl&); // Not defined.
580 
581  void
582  operator=(const _Impl&); // Not defined.
583 
584  bool
585  _M_check_same_name()
586  {
587  bool __ret = true;
588  if (_M_names[1])
589  // We must actually compare all the _M_names: can be all equal!
590  for (size_t __i = 0; __ret && __i < _S_categories_size - 1; ++__i)
591  __ret = __builtin_strcmp(_M_names[__i], _M_names[__i + 1]) == 0;
592  return __ret;
593  }
594 
595  void
596  _M_replace_categories(const _Impl*, category);
597 
598  void
599  _M_replace_category(const _Impl*, const locale::id* const*);
600 
601  void
602  _M_replace_facet(const _Impl*, const locale::id*);
603 
604  void
605  _M_install_facet(const locale::id*, const facet*);
606 
607  template<typename _Facet>
608  void
609  _M_init_facet(_Facet* __facet)
610  { _M_install_facet(&_Facet::id, __facet); }
611 
612  template<typename _Facet>
613  void
614  _M_init_facet_unchecked(_Facet* __facet)
615  {
616  __facet->_M_add_reference();
617  _M_facets[_Facet::id._M_id()] = __facet;
618  }
619 
620  void
621  _M_install_cache(const facet*, size_t);
622 
623  void _M_init_extra(facet**);
624  void _M_init_extra(void*, void*, const char*, const char*);
625  };
626 
627 
628  /**
629  * @brief Facet for localized string comparison.
630  *
631  * This facet encapsulates the code to compare strings in a localized
632  * manner.
633  *
634  * The collate template uses protected virtual functions to provide
635  * the actual results. The public accessors forward the call to
636  * the virtual functions. These virtual functions are hooks for
637  * developers to implement the behavior they require from the
638  * collate facet.
639  */
640  template<typename _CharT>
641  class _GLIBCXX_NAMESPACE_CXX11 collate : public locale::facet
642  {
643  public:
644  // Types:
645  //@{
646  /// Public typedefs
647  typedef _CharT char_type;
649  //@}
650 
651  protected:
652  // Underlying "C" library locale information saved from
653  // initialization, needed by collate_byname as well.
654  __c_locale _M_c_locale_collate;
655 
656  public:
657  /// Numpunct facet id.
658  static locale::id id;
659 
660  /**
661  * @brief Constructor performs initialization.
662  *
663  * This is the constructor provided by the standard.
664  *
665  * @param __refs Passed to the base facet class.
666  */
667  explicit
668  collate(size_t __refs = 0)
669  : facet(__refs), _M_c_locale_collate(_S_get_c_locale())
670  { }
671 
672  /**
673  * @brief Internal constructor. Not for general use.
674  *
675  * This is a constructor for use by the library itself to set up new
676  * locales.
677  *
678  * @param __cloc The C locale.
679  * @param __refs Passed to the base facet class.
680  */
681  explicit
682  collate(__c_locale __cloc, size_t __refs = 0)
683  : facet(__refs), _M_c_locale_collate(_S_clone_c_locale(__cloc))
684  { }
685 
686  /**
687  * @brief Compare two strings.
688  *
689  * This function compares two strings and returns the result by calling
690  * collate::do_compare().
691  *
692  * @param __lo1 Start of string 1.
693  * @param __hi1 End of string 1.
694  * @param __lo2 Start of string 2.
695  * @param __hi2 End of string 2.
696  * @return 1 if string1 > string2, -1 if string1 < string2, else 0.
697  */
698  int
699  compare(const _CharT* __lo1, const _CharT* __hi1,
700  const _CharT* __lo2, const _CharT* __hi2) const
701  { return this->do_compare(__lo1, __hi1, __lo2, __hi2); }
702 
703  /**
704  * @brief Transform string to comparable form.
705  *
706  * This function is a wrapper for strxfrm functionality. It takes the
707  * input string and returns a modified string that can be directly
708  * compared to other transformed strings. In the C locale, this
709  * function just returns a copy of the input string. In some other
710  * locales, it may replace two chars with one, change a char for
711  * another, etc. It does so by returning collate::do_transform().
712  *
713  * @param __lo Start of string.
714  * @param __hi End of string.
715  * @return Transformed string_type.
716  */
717  string_type
718  transform(const _CharT* __lo, const _CharT* __hi) const
719  { return this->do_transform(__lo, __hi); }
720 
721  /**
722  * @brief Return hash of a string.
723  *
724  * This function computes and returns a hash on the input string. It
725  * does so by returning collate::do_hash().
726  *
727  * @param __lo Start of string.
728  * @param __hi End of string.
729  * @return Hash value.
730  */
731  long
732  hash(const _CharT* __lo, const _CharT* __hi) const
733  { return this->do_hash(__lo, __hi); }
734 
735  // Used to abstract out _CharT bits in virtual member functions, below.
736  int
737  _M_compare(const _CharT*, const _CharT*) const throw();
738 
739  size_t
740  _M_transform(_CharT*, const _CharT*, size_t) const throw();
741 
742  protected:
743  /// Destructor.
744  virtual
746  { _S_destroy_c_locale(_M_c_locale_collate); }
747 
748  /**
749  * @brief Compare two strings.
750  *
751  * This function is a hook for derived classes to change the value
752  * returned. @see compare().
753  *
754  * @param __lo1 Start of string 1.
755  * @param __hi1 End of string 1.
756  * @param __lo2 Start of string 2.
757  * @param __hi2 End of string 2.
758  * @return 1 if string1 > string2, -1 if string1 < string2, else 0.
759  */
760  virtual int
761  do_compare(const _CharT* __lo1, const _CharT* __hi1,
762  const _CharT* __lo2, const _CharT* __hi2) const;
763 
764  /**
765  * @brief Transform string to comparable form.
766  *
767  * This function is a hook for derived classes to change the value
768  * returned.
769  *
770  * @param __lo Start.
771  * @param __hi End.
772  * @return transformed string.
773  */
774  virtual string_type
775  do_transform(const _CharT* __lo, const _CharT* __hi) const;
776 
777  /**
778  * @brief Return hash of a string.
779  *
780  * This function computes and returns a hash on the input string. This
781  * function is a hook for derived classes to change the value returned.
782  *
783  * @param __lo Start of string.
784  * @param __hi End of string.
785  * @return Hash value.
786  */
787  virtual long
788  do_hash(const _CharT* __lo, const _CharT* __hi) const;
789  };
790 
791  template<typename _CharT>
793 
794  // Specializations.
795  template<>
796  int
797  collate<char>::_M_compare(const char*, const char*) const throw();
798 
799  template<>
800  size_t
801  collate<char>::_M_transform(char*, const char*, size_t) const throw();
802 
803 #ifdef _GLIBCXX_USE_WCHAR_T
804  template<>
805  int
806  collate<wchar_t>::_M_compare(const wchar_t*, const wchar_t*) const throw();
807 
808  template<>
809  size_t
810  collate<wchar_t>::_M_transform(wchar_t*, const wchar_t*, size_t) const throw();
811 #endif
812 
813  /// class collate_byname [22.2.4.2].
814  template<typename _CharT>
815  class _GLIBCXX_NAMESPACE_CXX11 collate_byname : public collate<_CharT>
816  {
817  public:
818  //@{
819  /// Public typedefs
820  typedef _CharT char_type;
822  //@}
823 
824  explicit
825  collate_byname(const char* __s, size_t __refs = 0)
826  : collate<_CharT>(__refs)
827  {
828  if (__builtin_strcmp(__s, "C") != 0
829  && __builtin_strcmp(__s, "POSIX") != 0)
830  {
831  this->_S_destroy_c_locale(this->_M_c_locale_collate);
832  this->_S_create_c_locale(this->_M_c_locale_collate, __s);
833  }
834  }
835 
836 #if __cplusplus >= 201103L
837  explicit
838  collate_byname(const string& __s, size_t __refs = 0)
839  : collate_byname(__s.c_str(), __refs) { }
840 #endif
841 
842  protected:
843  virtual
844  ~collate_byname() { }
845  };
846 
847 _GLIBCXX_END_NAMESPACE_VERSION
848 } // namespace
849 
850 # include <bits/locale_classes.tcc>
851 
852 #endif
virtual ~collate()
Destructor.
static const locale & classic()
Return reference to the C locale.
Container class for localization functionality.The locale class is first a class wrapper for C librar...
friend const _Facet & use_facet(const locale &)
Return a facet.use_facet looks for and returns a reference to a facet of type Facet where Facet is th...
bool operator==(const locale &__other) const
Locale equality.
id()
Constructor.
const _CharT * c_str() const noexcept
Return const pointer to null-terminated contents.
class collate_byname [22.2.4.2].
friend bool has_facet(const locale &)
Test for the presence of a facet.has_facet tests the locale argument for the presence of the facet ty...
locale(const std::string &__s)
Named locale constructor.
collate(size_t __refs=0)
Constructor performs initialization.
basic_string< _CharT > string_type
Public typedefs.
static locale global(const locale &__loc)
Set global locale.
Primary class template ctype facet.This template class defines classification and conversion function...
ISO C++ entities toplevel namespace is std.
static const category all
Category values.
_CharT char_type
Public typedefs.
basic_string< _CharT > string_type
Public typedefs.
locale combine(const locale &__other) const
Construct locale with another facet.
_GLIBCXX_DEFAULT_ABI_TAG string name() const
Return locale name.
string_type transform(const _CharT *__lo, const _CharT *__hi) const
Transform string to comparable form.
Facet ID class.The ID class provides facets with an index used to identify them. Every facet class mu...
Primary class template messages.This facet encapsulates the code to retrieve messages from message ca...
const locale & operator=(const locale &__other)
Assignment operator.
collate(__c_locale __cloc, size_t __refs=0)
Internal constructor. Not for general use.
locale(const locale &__base, const std::string &__s, category __cat)
Construct locale with facets from another locale.
bool operator!=(const locale &__other) const
Locale inequality.
Facet for localized string comparison.
static locale::id id
Numpunct facet id.
facet(size_t __refs=0)
Facet constructor.
bool operator()(const basic_string< _Char, _Traits, _Alloc > &__s1, const basic_string< _Char, _Traits, _Alloc > &__s2) const
Compare two strings according to collate.
static const category none
Category values.
~locale()
Locale destructor.
_CharT char_type
Public typedefs.
static const category time
Category values.
long hash(const _CharT *__lo, const _CharT *__hi) const
Return hash of a string.
static const category monetary
Category values.
Localization functionality base class.The facet class is the base class for a localization feature...
locale()
Default constructor.
int category
Definition of locale::category.
static const category numeric
Category values.
int compare(const _CharT *__lo1, const _CharT *__hi1, const _CharT *__lo2, const _CharT *__hi2) const
Compare two strings.