libstdc++
locale_classes.h
Go to the documentation of this file.
1 // Locale support -*- C++ -*-
2 
3 // Copyright (C) 1997-2015 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  private:
432  void
433  _M_add_reference() const throw()
434  { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }
435 
436  void
437  _M_remove_reference() const throw()
438  {
439  // Be race-detector-friendly. For more info see bits/c++config.
440  _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_refcount);
441  if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1)
442  {
443  _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_refcount);
444  __try
445  { delete this; }
446  __catch(...)
447  { }
448  }
449  }
450 
451  facet(const facet&); // Not defined.
452 
453  facet&
454  operator=(const facet&); // Not defined.
455 
456  const facet* _M_sso_shim(const id*) const;
457  const facet* _M_cow_shim(const id*) const;
458 
459  protected:
460  class __shim; // For internal use only.
461  };
462 
463 
464  // 22.1.1.1.3 Class locale::id
465  /**
466  * @brief Facet ID class.
467  * @ingroup locales
468  *
469  * The ID class provides facets with an index used to identify them.
470  * Every facet class must define a public static member locale::id, or be
471  * derived from a facet that provides this member, otherwise the facet
472  * cannot be used in a locale. The locale::id ensures that each class
473  * type gets a unique identifier.
474  */
476  {
477  private:
478  friend class locale;
479  friend class locale::_Impl;
480 
481  template<typename _Facet>
482  friend const _Facet&
483  use_facet(const locale&);
484 
485  template<typename _Facet>
486  friend bool
487  has_facet(const locale&) throw();
488 
489  // NB: There is no accessor for _M_index because it may be used
490  // before the constructor is run; the effect of calling a member
491  // function (even an inline) would be undefined.
492  mutable size_t _M_index;
493 
494  // Last id number assigned.
495  static _Atomic_word _S_refcount;
496 
497  void
498  operator=(const id&); // Not defined.
499 
500  id(const id&); // Not defined.
501 
502  public:
503  // NB: This class is always a static data member, and thus can be
504  // counted on to be zero-initialized.
505  /// Constructor.
506  id() { }
507 
508  size_t
509  _M_id() const throw();
510  };
511 
512 
513  // Implementation object for locale.
514  class locale::_Impl
515  {
516  public:
517  // Friends.
518  friend class locale;
519  friend class locale::facet;
520 
521  template<typename _Facet>
522  friend bool
523  has_facet(const locale&) throw();
524 
525  template<typename _Facet>
526  friend const _Facet&
527  use_facet(const locale&);
528 
529  template<typename _Cache>
530  friend struct __use_cache;
531 
532  private:
533  // Data Members.
534  _Atomic_word _M_refcount;
535  const facet** _M_facets;
536  size_t _M_facets_size;
537  const facet** _M_caches;
538  char** _M_names;
539  static const locale::id* const _S_id_ctype[];
540  static const locale::id* const _S_id_numeric[];
541  static const locale::id* const _S_id_collate[];
542  static const locale::id* const _S_id_time[];
543  static const locale::id* const _S_id_monetary[];
544  static const locale::id* const _S_id_messages[];
545  static const locale::id* const* const _S_facet_categories[];
546 
547  void
548  _M_add_reference() throw()
549  { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }
550 
551  void
552  _M_remove_reference() throw()
553  {
554  // Be race-detector-friendly. For more info see bits/c++config.
555  _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_refcount);
556  if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1)
557  {
558  _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_refcount);
559  __try
560  { delete this; }
561  __catch(...)
562  { }
563  }
564  }
565 
566  _Impl(const _Impl&, size_t);
567  _Impl(const char*, size_t);
568  _Impl(size_t) throw();
569 
570  ~_Impl() throw();
571 
572  _Impl(const _Impl&); // Not defined.
573 
574  void
575  operator=(const _Impl&); // Not defined.
576 
577  bool
578  _M_check_same_name()
579  {
580  bool __ret = true;
581  if (_M_names[1])
582  // We must actually compare all the _M_names: can be all equal!
583  for (size_t __i = 0; __ret && __i < _S_categories_size - 1; ++__i)
584  __ret = __builtin_strcmp(_M_names[__i], _M_names[__i + 1]) == 0;
585  return __ret;
586  }
587 
588  void
589  _M_replace_categories(const _Impl*, category);
590 
591  void
592  _M_replace_category(const _Impl*, const locale::id* const*);
593 
594  void
595  _M_replace_facet(const _Impl*, const locale::id*);
596 
597  void
598  _M_install_facet(const locale::id*, const facet*);
599 
600  template<typename _Facet>
601  void
602  _M_init_facet(_Facet* __facet)
603  { _M_install_facet(&_Facet::id, __facet); }
604 
605  template<typename _Facet>
606  void
607  _M_init_facet_unchecked(_Facet* __facet)
608  {
609  __facet->_M_add_reference();
610  _M_facets[_Facet::id._M_id()] = __facet;
611  }
612 
613  void
614  _M_install_cache(const facet*, size_t);
615 
616  void _M_init_extra(facet**);
617  void _M_init_extra(void*, void*, const char*, const char*);
618  };
619 
620 
621  /**
622  * @brief Facet for localized string comparison.
623  *
624  * This facet encapsulates the code to compare strings in a localized
625  * manner.
626  *
627  * The collate template uses protected virtual functions to provide
628  * the actual results. The public accessors forward the call to
629  * the virtual functions. These virtual functions are hooks for
630  * developers to implement the behavior they require from the
631  * collate facet.
632  */
633  template<typename _CharT>
634  class _GLIBCXX_NAMESPACE_CXX11 collate : public locale::facet
635  {
636  public:
637  // Types:
638  //@{
639  /// Public typedefs
640  typedef _CharT char_type;
642  //@}
643 
644  protected:
645  // Underlying "C" library locale information saved from
646  // initialization, needed by collate_byname as well.
647  __c_locale _M_c_locale_collate;
648 
649  public:
650  /// Numpunct facet id.
651  static locale::id id;
652 
653  /**
654  * @brief Constructor performs initialization.
655  *
656  * This is the constructor provided by the standard.
657  *
658  * @param __refs Passed to the base facet class.
659  */
660  explicit
661  collate(size_t __refs = 0)
662  : facet(__refs), _M_c_locale_collate(_S_get_c_locale())
663  { }
664 
665  /**
666  * @brief Internal constructor. Not for general use.
667  *
668  * This is a constructor for use by the library itself to set up new
669  * locales.
670  *
671  * @param __cloc The C locale.
672  * @param __refs Passed to the base facet class.
673  */
674  explicit
675  collate(__c_locale __cloc, size_t __refs = 0)
676  : facet(__refs), _M_c_locale_collate(_S_clone_c_locale(__cloc))
677  { }
678 
679  /**
680  * @brief Compare two strings.
681  *
682  * This function compares two strings and returns the result by calling
683  * collate::do_compare().
684  *
685  * @param __lo1 Start of string 1.
686  * @param __hi1 End of string 1.
687  * @param __lo2 Start of string 2.
688  * @param __hi2 End of string 2.
689  * @return 1 if string1 > string2, -1 if string1 < string2, else 0.
690  */
691  int
692  compare(const _CharT* __lo1, const _CharT* __hi1,
693  const _CharT* __lo2, const _CharT* __hi2) const
694  { return this->do_compare(__lo1, __hi1, __lo2, __hi2); }
695 
696  /**
697  * @brief Transform string to comparable form.
698  *
699  * This function is a wrapper for strxfrm functionality. It takes the
700  * input string and returns a modified string that can be directly
701  * compared to other transformed strings. In the C locale, this
702  * function just returns a copy of the input string. In some other
703  * locales, it may replace two chars with one, change a char for
704  * another, etc. It does so by returning collate::do_transform().
705  *
706  * @param __lo Start of string.
707  * @param __hi End of string.
708  * @return Transformed string_type.
709  */
710  string_type
711  transform(const _CharT* __lo, const _CharT* __hi) const
712  { return this->do_transform(__lo, __hi); }
713 
714  /**
715  * @brief Return hash of a string.
716  *
717  * This function computes and returns a hash on the input string. It
718  * does so by returning collate::do_hash().
719  *
720  * @param __lo Start of string.
721  * @param __hi End of string.
722  * @return Hash value.
723  */
724  long
725  hash(const _CharT* __lo, const _CharT* __hi) const
726  { return this->do_hash(__lo, __hi); }
727 
728  // Used to abstract out _CharT bits in virtual member functions, below.
729  int
730  _M_compare(const _CharT*, const _CharT*) const throw();
731 
732  size_t
733  _M_transform(_CharT*, const _CharT*, size_t) const throw();
734 
735  protected:
736  /// Destructor.
737  virtual
739  { _S_destroy_c_locale(_M_c_locale_collate); }
740 
741  /**
742  * @brief Compare two strings.
743  *
744  * This function is a hook for derived classes to change the value
745  * returned. @see compare().
746  *
747  * @param __lo1 Start of string 1.
748  * @param __hi1 End of string 1.
749  * @param __lo2 Start of string 2.
750  * @param __hi2 End of string 2.
751  * @return 1 if string1 > string2, -1 if string1 < string2, else 0.
752  */
753  virtual int
754  do_compare(const _CharT* __lo1, const _CharT* __hi1,
755  const _CharT* __lo2, const _CharT* __hi2) const;
756 
757  /**
758  * @brief Transform string to comparable form.
759  *
760  * This function is a hook for derived classes to change the value
761  * returned.
762  *
763  * @param __lo Start.
764  * @param __hi End.
765  * @return transformed string.
766  */
767  virtual string_type
768  do_transform(const _CharT* __lo, const _CharT* __hi) const;
769 
770  /**
771  * @brief Return hash of a string.
772  *
773  * This function computes and returns a hash on the input string. This
774  * function is a hook for derived classes to change the value returned.
775  *
776  * @param __lo Start of string.
777  * @param __hi End of string.
778  * @return Hash value.
779  */
780  virtual long
781  do_hash(const _CharT* __lo, const _CharT* __hi) const;
782  };
783 
784  template<typename _CharT>
785  locale::id collate<_CharT>::id;
786 
787  // Specializations.
788  template<>
789  int
790  collate<char>::_M_compare(const char*, const char*) const throw();
791 
792  template<>
793  size_t
794  collate<char>::_M_transform(char*, const char*, size_t) const throw();
795 
796 #ifdef _GLIBCXX_USE_WCHAR_T
797  template<>
798  int
799  collate<wchar_t>::_M_compare(const wchar_t*, const wchar_t*) const throw();
800 
801  template<>
802  size_t
803  collate<wchar_t>::_M_transform(wchar_t*, const wchar_t*, size_t) const throw();
804 #endif
805 
806  /// class collate_byname [22.2.4.2].
807  template<typename _CharT>
808  class _GLIBCXX_NAMESPACE_CXX11 collate_byname : public collate<_CharT>
809  {
810  public:
811  //@{
812  /// Public typedefs
813  typedef _CharT char_type;
815  //@}
816 
817  explicit
818  collate_byname(const char* __s, size_t __refs = 0)
819  : collate<_CharT>(__refs)
820  {
821  if (__builtin_strcmp(__s, "C") != 0
822  && __builtin_strcmp(__s, "POSIX") != 0)
823  {
824  this->_S_destroy_c_locale(this->_M_c_locale_collate);
825  this->_S_create_c_locale(this->_M_c_locale_collate, __s);
826  }
827  }
828 
829 #if __cplusplus >= 201103L
830  explicit
831  collate_byname(const string& __s, size_t __refs = 0)
832  : collate_byname(__s.c_str(), __refs) { }
833 #endif
834 
835  protected:
836  virtual
837  ~collate_byname() { }
838  };
839 
840 _GLIBCXX_END_NAMESPACE_VERSION
841 } // namespace
842 
843 # include <bits/locale_classes.tcc>
844 
845 #endif
basic_string< _CharT > string_type
Public typedefs.
~locale()
Locale destructor.
string_type transform(const _CharT *__lo, const _CharT *__hi) const
Transform string to comparable form.
locale(const std::string &__s)
Named locale constructor.
collate(size_t __refs=0)
Constructor performs initialization.
static const category none
Category values.
_GLIBCXX_DEFAULT_ABI_TAG string name() const
Return locale name.
int compare(const _CharT *__lo1, const _CharT *__hi1, const _CharT *__lo2, const _CharT *__hi2) const
Compare two strings.
collate(__c_locale __cloc, size_t __refs=0)
Internal constructor. Not for general use.
static const category all
Category values.
Container class for localization functionality.The locale class is first a class wrapper for C librar...
static const category collate
Category values.
long hash(const _CharT *__lo, const _CharT *__hi) const
Return hash of a string.
virtual ~facet()
Facet destructor.
class collate_byname [22.2.4.2].
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...
int category
Definition of locale::category.
facet(size_t __refs=0)
Facet constructor.
bool operator==(const locale &__other) const
Locale equality.
static const category monetary
Category values.
bool operator()(const basic_string< _Char, _Traits, _Alloc > &__s1, const basic_string< _Char, _Traits, _Alloc > &__s2) const
Compare two strings according to collate.
static locale::id id
Numpunct facet id.
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...
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...
Facet for localized string comparison.
static const category numeric
Category values.
static locale global(const locale &__loc)
Set global locale.
_Siter_base< _Iterator >::iterator_type __base(_Iterator __it)
Definition: functions.h:558
locale()
Default constructor.
locale combine(const locale &__other) const
Construct locale with another facet.
locale(const locale &__base, const std::string &__s, category __cat)
Construct locale with facets from another locale.
id()
Constructor.
_CharT char_type
Public typedefs.
Localization functionality base class.The facet class is the base class for a localization feature...
static const locale & classic()
Return reference to the C locale.
_CharT char_type
Public typedefs.
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...
basic_string< _CharT > string_type
Public typedefs.
Primary class template ctype facet.This template class defines classification and conversion function...
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...
static const category time
Category values.