locale_classes.h

Go to the documentation of this file.
00001 // Locale support -*- C++ -*-
00002 
00003 // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
00004 // 2006, 2007, 2008, 2009
00005 // Free Software Foundation, Inc.
00006 //
00007 // This file is part of the GNU ISO C++ Library.  This library is free
00008 // software; you can redistribute it and/or modify it under the
00009 // terms of the GNU General Public License as published by the
00010 // Free Software Foundation; either version 3, or (at your option)
00011 // any later version.
00012 
00013 // This library is distributed in the hope that it will be useful,
00014 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00015 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00016 // GNU General Public License for more details.
00017 
00018 // Under Section 7 of GPL version 3, you are granted additional
00019 // permissions described in the GCC Runtime Library Exception, version
00020 // 3.1, as published by the Free Software Foundation.
00021 
00022 // You should have received a copy of the GNU General Public License and
00023 // a copy of the GCC Runtime Library Exception along with this program;
00024 // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
00025 // <http://www.gnu.org/licenses/>.
00026 
00027 /** @file locale_classes.h
00028  *  This is an internal header file, included by other library headers.
00029  *  You should not attempt to use it directly.
00030  */
00031 
00032 //
00033 // ISO C++ 14882: 22.1  Locales
00034 //
00035 
00036 #ifndef _LOCALE_CLASSES_H
00037 #define _LOCALE_CLASSES_H 1
00038 
00039 #pragma GCC system_header
00040 
00041 #include <bits/localefwd.h>
00042 #include <string>
00043 #include <ext/atomicity.h>
00044 
00045 _GLIBCXX_BEGIN_NAMESPACE(std)
00046 
00047   // 22.1.1 Class locale
00048   /**
00049    *  @brief  Container class for localization functionality.
00050    *
00051    *  The locale class is first a class wrapper for C library locales.  It is
00052    *  also an extensible container for user-defined localization.  A locale is
00053    *  a collection of facets that implement various localization features such
00054    *  as money, time, and number printing.
00055    *
00056    *  Constructing C++ locales does not change the C library locale.
00057    *
00058    *  This library supports efficient construction and copying of locales
00059    *  through a reference counting implementation of the locale class.
00060   */
00061   class locale
00062   {
00063   public:
00064     // Types:
00065     /// Definition of locale::category.
00066     typedef int category;
00067 
00068     // Forward decls and friends:
00069     class facet;
00070     class id;
00071     class _Impl;
00072 
00073     friend class facet;
00074     friend class _Impl;
00075 
00076     template<typename _Facet>
00077       friend bool
00078       has_facet(const locale&) throw();
00079 
00080     template<typename _Facet>
00081       friend const _Facet&
00082       use_facet(const locale&);
00083 
00084     template<typename _Cache>
00085       friend struct __use_cache;
00086 
00087     //@{
00088     /**
00089      *  @brief  Category values.
00090      *
00091      *  The standard category values are none, ctype, numeric, collate, time,
00092      *  monetary, and messages.  They form a bitmask that supports union and
00093      *  intersection.  The category all is the union of these values.
00094      *
00095      *  NB: Order must match _S_facet_categories definition in locale.cc
00096     */
00097     static const category none      = 0;
00098     static const category ctype     = 1L << 0;
00099     static const category numeric   = 1L << 1;
00100     static const category collate   = 1L << 2;
00101     static const category time      = 1L << 3;
00102     static const category monetary  = 1L << 4;
00103     static const category messages  = 1L << 5;
00104     static const category all       = (ctype | numeric | collate |
00105                        time  | monetary | messages);
00106     //@}
00107 
00108     // Construct/copy/destroy:
00109 
00110     /**
00111      *  @brief  Default constructor.
00112      *
00113      *  Constructs a copy of the global locale.  If no locale has been
00114      *  explicitly set, this is the "C" locale.
00115     */
00116     locale() throw();
00117 
00118     /**
00119      *  @brief  Copy constructor.
00120      *
00121      *  Constructs a copy of @a other.
00122      *
00123      *  @param  other  The locale to copy.
00124     */
00125     locale(const locale& __other) throw();
00126 
00127     /**
00128      *  @brief  Named locale constructor.
00129      *
00130      *  Constructs a copy of the named C library locale.
00131      *
00132      *  @param  s  Name of the locale to construct.
00133      *  @throw  std::runtime_error if s is null or an undefined locale.
00134     */
00135     explicit
00136     locale(const char* __s);
00137 
00138     /**
00139      *  @brief  Construct locale with facets from another locale.
00140      *
00141      *  Constructs a copy of the locale @a base.  The facets specified by @a
00142      *  cat are replaced with those from the locale named by @a s.  If base is
00143      *  named, this locale instance will also be named.
00144      *
00145      *  @param  base  The locale to copy.
00146      *  @param  s  Name of the locale to use facets from.
00147      *  @param  cat  Set of categories defining the facets to use from s.
00148      *  @throw  std::runtime_error if s is null or an undefined locale.
00149     */
00150     locale(const locale& __base, const char* __s, category __cat);
00151 
00152     /**
00153      *  @brief  Construct locale with facets from another locale.
00154      *
00155      *  Constructs a copy of the locale @a base.  The facets specified by @a
00156      *  cat are replaced with those from the locale @a add.  If @a base and @a
00157      *  add are named, this locale instance will also be named.
00158      *
00159      *  @param  base  The locale to copy.
00160      *  @param  add  The locale to use facets from.
00161      *  @param  cat  Set of categories defining the facets to use from add.
00162     */
00163     locale(const locale& __base, const locale& __add, category __cat);
00164 
00165     /**
00166      *  @brief  Construct locale with another facet.
00167      *
00168      *  Constructs a copy of the locale @a other.  The facet @f is added to
00169      *  @other, replacing an existing facet of type Facet if there is one.  If
00170      *  @f is null, this locale is a copy of @a other.
00171      *
00172      *  @param  other  The locale to copy.
00173      *  @param  f  The facet to add in.
00174     */
00175     template<typename _Facet>
00176       locale(const locale& __other, _Facet* __f);
00177 
00178     /// Locale destructor.
00179     ~locale() throw();
00180 
00181     /**
00182      *  @brief  Assignment operator.
00183      *
00184      *  Set this locale to be a copy of @a other.
00185      *
00186      *  @param  other  The locale to copy.
00187      *  @return  A reference to this locale.
00188     */
00189     const locale&
00190     operator=(const locale& __other) throw();
00191 
00192     /**
00193      *  @brief  Construct locale with another facet.
00194      *
00195      *  Constructs and returns a new copy of this locale.  Adds or replaces an
00196      *  existing facet of type Facet from the locale @a other into the new
00197      *  locale.
00198      *
00199      *  @param  Facet  The facet type to copy from other
00200      *  @param  other  The locale to copy from.
00201      *  @return  Newly constructed locale.
00202      *  @throw  std::runtime_error if other has no facet of type Facet.
00203     */
00204     template<typename _Facet>
00205       locale
00206       combine(const locale& __other) const;
00207 
00208     // Locale operations:
00209     /**
00210      *  @brief  Return locale name.
00211      *  @return  Locale name or "*" if unnamed.
00212     */
00213     string
00214     name() const;
00215 
00216     /**
00217      *  @brief  Locale equality.
00218      *
00219      *  @param  other  The locale to compare against.
00220      *  @return  True if other and this refer to the same locale instance, are
00221      *       copies, or have the same name.  False otherwise.
00222     */
00223     bool
00224     operator==(const locale& __other) const throw ();
00225 
00226     /**
00227      *  @brief  Locale inequality.
00228      *
00229      *  @param  other  The locale to compare against.
00230      *  @return  ! (*this == other)
00231     */
00232     bool
00233     operator!=(const locale& __other) const throw ()
00234     { return !(this->operator==(__other)); }
00235 
00236     /**
00237      *  @brief  Compare two strings according to collate.
00238      *
00239      *  Template operator to compare two strings using the compare function of
00240      *  the collate facet in this locale.  One use is to provide the locale to
00241      *  the sort function.  For example, a vector v of strings could be sorted
00242      *  according to locale loc by doing:
00243      *  @code
00244      *  std::sort(v.begin(), v.end(), loc);
00245      *  @endcode
00246      *
00247      *  @param  s1  First string to compare.
00248      *  @param  s2  Second string to compare.
00249      *  @return  True if collate<Char> facet compares s1 < s2, else false.
00250     */
00251     template<typename _Char, typename _Traits, typename _Alloc>
00252       bool
00253       operator()(const basic_string<_Char, _Traits, _Alloc>& __s1,
00254          const basic_string<_Char, _Traits, _Alloc>& __s2) const;
00255 
00256     // Global locale objects:
00257     /**
00258      *  @brief  Set global locale
00259      *
00260      *  This function sets the global locale to the argument and returns a
00261      *  copy of the previous global locale.  If the argument has a name, it
00262      *  will also call std::setlocale(LC_ALL, loc.name()).
00263      *
00264      *  @param  locale  The new locale to make global.
00265      *  @return  Copy of the old global locale.
00266     */
00267     static locale
00268     global(const locale&);
00269 
00270     /**
00271      *  @brief  Return reference to the "C" locale.
00272     */
00273     static const locale&
00274     classic();
00275 
00276   private:
00277     // The (shared) implementation
00278     _Impl*      _M_impl;
00279 
00280     // The "C" reference locale
00281     static _Impl*       _S_classic;
00282 
00283     // Current global locale
00284     static _Impl*   _S_global;
00285 
00286     // Names of underlying locale categories.
00287     // NB: locale::global() has to know how to modify all the
00288     // underlying categories, not just the ones required by the C++
00289     // standard.
00290     static const char* const* const _S_categories;
00291 
00292     // Number of standard categories. For C++, these categories are
00293     // collate, ctype, monetary, numeric, time, and messages. These
00294     // directly correspond to ISO C99 macros LC_COLLATE, LC_CTYPE,
00295     // LC_MONETARY, LC_NUMERIC, and LC_TIME. In addition, POSIX (IEEE
00296     // 1003.1-2001) specifies LC_MESSAGES.
00297     // In addition to the standard categories, the underlying
00298     // operating system is allowed to define extra LC_*
00299     // macros. For GNU systems, the following are also valid:
00300     // LC_PAPER, LC_NAME, LC_ADDRESS, LC_TELEPHONE, LC_MEASUREMENT,
00301     // and LC_IDENTIFICATION.
00302     enum { _S_categories_size = 6 + _GLIBCXX_NUM_CATEGORIES };
00303 
00304 #ifdef __GTHREADS
00305     static __gthread_once_t _S_once;
00306 #endif
00307 
00308     explicit
00309     locale(_Impl*) throw();
00310 
00311     static void
00312     _S_initialize();
00313 
00314     static void
00315     _S_initialize_once() throw ();
00316 
00317     static category
00318     _S_normalize_category(category);
00319 
00320     void
00321     _M_coalesce(const locale& __base, const locale& __add, category __cat);
00322   };
00323 
00324 
00325   // 22.1.1.1.2  Class locale::facet
00326   /**
00327    *  @brief  Localization functionality base class.
00328    *
00329    *  The facet class is the base class for a localization feature, such as
00330    *  money, time, and number printing.  It provides common support for facets
00331    *  and reference management.
00332    *
00333    *  Facets may not be copied or assigned.
00334   */
00335   class locale::facet
00336   {
00337   private:
00338     friend class locale;
00339     friend class locale::_Impl;
00340 
00341     mutable _Atomic_word        _M_refcount;
00342 
00343     // Contains data from the underlying "C" library for the classic locale.
00344     static __c_locale                   _S_c_locale;
00345 
00346     // String literal for the name of the classic locale.
00347     static const char           _S_c_name[2];
00348 
00349 #ifdef __GTHREADS
00350     static __gthread_once_t     _S_once;
00351 #endif
00352 
00353     static void
00354     _S_initialize_once();
00355 
00356   protected:
00357     /**
00358      *  @brief  Facet constructor.
00359      *
00360      *  This is the constructor provided by the standard.  If refs is 0, the
00361      *  facet is destroyed when the last referencing locale is destroyed.
00362      *  Otherwise the facet will never be destroyed.
00363      *
00364      *  @param refs  The initial value for reference count.
00365     */
00366     explicit
00367     facet(size_t __refs = 0) throw() : _M_refcount(__refs ? 1 : 0)
00368     { }
00369 
00370     /// Facet destructor.
00371     virtual
00372     ~facet();
00373 
00374     static void
00375     _S_create_c_locale(__c_locale& __cloc, const char* __s,
00376                __c_locale __old = 0);
00377 
00378     static __c_locale
00379     _S_clone_c_locale(__c_locale& __cloc) throw ();
00380 
00381     static void
00382     _S_destroy_c_locale(__c_locale& __cloc);
00383 
00384     static __c_locale
00385     _S_lc_ctype_c_locale(__c_locale __cloc, const char* __s);
00386 
00387     // Returns data from the underlying "C" library data for the
00388     // classic locale.
00389     static __c_locale
00390     _S_get_c_locale();
00391 
00392     _GLIBCXX_CONST static const char*
00393     _S_get_c_name() throw ();
00394 
00395   private:
00396     void
00397     _M_add_reference() const throw()
00398     { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }
00399 
00400     void
00401     _M_remove_reference() const throw()
00402     {
00403       if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1)
00404     {
00405       __try
00406         { delete this; }
00407       __catch(...)
00408         { }
00409     }
00410     }
00411 
00412     facet(const facet&);  // Not defined.
00413 
00414     facet&
00415     operator=(const facet&);  // Not defined.
00416   };
00417 
00418 
00419   // 22.1.1.1.3 Class locale::id
00420   /**
00421    *  @brief  Facet ID class.
00422    *
00423    *  The ID class provides facets with an index used to identify them.
00424    *  Every facet class must define a public static member locale::id, or be
00425    *  derived from a facet that provides this member, otherwise the facet
00426    *  cannot be used in a locale.  The locale::id ensures that each class
00427    *  type gets a unique identifier.
00428   */
00429   class locale::id
00430   {
00431   private:
00432     friend class locale;
00433     friend class locale::_Impl;
00434 
00435     template<typename _Facet>
00436       friend const _Facet&
00437       use_facet(const locale&);
00438 
00439     template<typename _Facet>
00440       friend bool
00441       has_facet(const locale&) throw ();
00442 
00443     // NB: There is no accessor for _M_index because it may be used
00444     // before the constructor is run; the effect of calling a member
00445     // function (even an inline) would be undefined.
00446     mutable size_t      _M_index;
00447 
00448     // Last id number assigned.
00449     static _Atomic_word     _S_refcount;
00450 
00451     void
00452     operator=(const id&);  // Not defined.
00453 
00454     id(const id&);  // Not defined.
00455 
00456   public:
00457     // NB: This class is always a static data member, and thus can be
00458     // counted on to be zero-initialized.
00459     /// Constructor.
00460     id() { }
00461 
00462     size_t
00463     _M_id() const throw ();
00464   };
00465 
00466 
00467   // Implementation object for locale.
00468   class locale::_Impl
00469   {
00470   public:
00471     // Friends.
00472     friend class locale;
00473     friend class locale::facet;
00474 
00475     template<typename _Facet>
00476       friend bool
00477       has_facet(const locale&) throw();
00478 
00479     template<typename _Facet>
00480       friend const _Facet&
00481       use_facet(const locale&);
00482 
00483     template<typename _Cache>
00484       friend struct __use_cache;
00485 
00486   private:
00487     // Data Members.
00488     _Atomic_word            _M_refcount;
00489     const facet**           _M_facets;
00490     size_t              _M_facets_size;
00491     const facet**           _M_caches;
00492     char**              _M_names;
00493     static const locale::id* const  _S_id_ctype[];
00494     static const locale::id* const  _S_id_numeric[];
00495     static const locale::id* const  _S_id_collate[];
00496     static const locale::id* const  _S_id_time[];
00497     static const locale::id* const  _S_id_monetary[];
00498     static const locale::id* const  _S_id_messages[];
00499     static const locale::id* const* const _S_facet_categories[];
00500 
00501     void
00502     _M_add_reference() throw()
00503     { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }
00504 
00505     void
00506     _M_remove_reference() throw()
00507     {
00508       if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1)
00509     {
00510       __try
00511         { delete this; }
00512       __catch(...)
00513         { }
00514     }
00515     }
00516 
00517     _Impl(const _Impl&, size_t);
00518     _Impl(const char*, size_t);
00519     _Impl(size_t) throw();
00520 
00521    ~_Impl() throw();
00522 
00523     _Impl(const _Impl&);  // Not defined.
00524 
00525     void
00526     operator=(const _Impl&);  // Not defined.
00527 
00528     bool
00529     _M_check_same_name()
00530     {
00531       bool __ret = true;
00532       if (_M_names[1])
00533     // We must actually compare all the _M_names: can be all equal!
00534     for (size_t __i = 0; __ret && __i < _S_categories_size - 1; ++__i)
00535       __ret = __builtin_strcmp(_M_names[__i], _M_names[__i + 1]) == 0;
00536       return __ret;
00537     }
00538 
00539     void
00540     _M_replace_categories(const _Impl*, category);
00541 
00542     void
00543     _M_replace_category(const _Impl*, const locale::id* const*);
00544 
00545     void
00546     _M_replace_facet(const _Impl*, const locale::id*);
00547 
00548     void
00549     _M_install_facet(const locale::id*, const facet*);
00550 
00551     template<typename _Facet>
00552       void
00553       _M_init_facet(_Facet* __facet)
00554       { _M_install_facet(&_Facet::id, __facet); }
00555 
00556     void
00557     _M_install_cache(const facet*, size_t);
00558   };
00559 
00560 
00561   /**
00562    *  @brief  Test for the presence of a facet.
00563    *
00564    *  has_facet tests the locale argument for the presence of the facet type
00565    *  provided as the template parameter.  Facets derived from the facet
00566    *  parameter will also return true.
00567    *
00568    *  @param  Facet  The facet type to test the presence of.
00569    *  @param  locale  The locale to test.
00570    *  @return  true if locale contains a facet of type Facet, else false.
00571   */
00572   template<typename _Facet>
00573     bool
00574     has_facet(const locale& __loc) throw();
00575 
00576   /**
00577    *  @brief  Return a facet.
00578    *
00579    *  use_facet looks for and returns a reference to a facet of type Facet
00580    *  where Facet is the template parameter.  If has_facet(locale) is true,
00581    *  there is a suitable facet to return.  It throws std::bad_cast if the
00582    *  locale doesn't contain a facet of type Facet.
00583    *
00584    *  @param  Facet  The facet type to access.
00585    *  @param  locale  The locale to use.
00586    *  @return  Reference to facet of type Facet.
00587    *  @throw  std::bad_cast if locale doesn't contain a facet of type Facet.
00588   */
00589   template<typename _Facet>
00590     const _Facet&
00591     use_facet(const locale& __loc);
00592 
00593 
00594   /**
00595    *  @brief  Facet for localized string comparison.
00596    *
00597    *  This facet encapsulates the code to compare strings in a localized
00598    *  manner.
00599    *
00600    *  The collate template uses protected virtual functions to provide
00601    *  the actual results.  The public accessors forward the call to
00602    *  the virtual functions.  These virtual functions are hooks for
00603    *  developers to implement the behavior they require from the
00604    *  collate facet.
00605   */
00606   template<typename _CharT>
00607     class collate : public locale::facet
00608     {
00609     public:
00610       // Types:
00611       //@{
00612       /// Public typedefs
00613       typedef _CharT            char_type;
00614       typedef basic_string<_CharT>  string_type;
00615       //@}
00616 
00617     protected:
00618       // Underlying "C" library locale information saved from
00619       // initialization, needed by collate_byname as well.
00620       __c_locale            _M_c_locale_collate;
00621 
00622     public:
00623       /// Numpunct facet id.
00624       static locale::id         id;
00625 
00626       /**
00627        *  @brief  Constructor performs initialization.
00628        *
00629        *  This is the constructor provided by the standard.
00630        *
00631        *  @param refs  Passed to the base facet class.
00632       */
00633       explicit
00634       collate(size_t __refs = 0)
00635       : facet(__refs), _M_c_locale_collate(_S_get_c_locale())
00636       { }
00637 
00638       /**
00639        *  @brief  Internal constructor. Not for general use.
00640        *
00641        *  This is a constructor for use by the library itself to set up new
00642        *  locales.
00643        *
00644        *  @param cloc  The "C" locale.
00645        *  @param refs  Passed to the base facet class.
00646       */
00647       explicit
00648       collate(__c_locale __cloc, size_t __refs = 0)
00649       : facet(__refs), _M_c_locale_collate(_S_clone_c_locale(__cloc))
00650       { }
00651 
00652       /**
00653        *  @brief  Compare two strings.
00654        *
00655        *  This function compares two strings and returns the result by calling
00656        *  collate::do_compare().
00657        *
00658        *  @param lo1  Start of string 1.
00659        *  @param hi1  End of string 1.
00660        *  @param lo2  Start of string 2.
00661        *  @param hi2  End of string 2.
00662        *  @return  1 if string1 > string2, -1 if string1 < string2, else 0.
00663       */
00664       int
00665       compare(const _CharT* __lo1, const _CharT* __hi1,
00666           const _CharT* __lo2, const _CharT* __hi2) const
00667       { return this->do_compare(__lo1, __hi1, __lo2, __hi2); }
00668 
00669       /**
00670        *  @brief  Transform string to comparable form.
00671        *
00672        *  This function is a wrapper for strxfrm functionality.  It takes the
00673        *  input string and returns a modified string that can be directly
00674        *  compared to other transformed strings.  In the "C" locale, this
00675        *  function just returns a copy of the input string.  In some other
00676        *  locales, it may replace two chars with one, change a char for
00677        *  another, etc.  It does so by returning collate::do_transform().
00678        *
00679        *  @param lo  Start of string.
00680        *  @param hi  End of string.
00681        *  @return  Transformed string_type.
00682       */
00683       string_type
00684       transform(const _CharT* __lo, const _CharT* __hi) const
00685       { return this->do_transform(__lo, __hi); }
00686 
00687       /**
00688        *  @brief  Return hash of a string.
00689        *
00690        *  This function computes and returns a hash on the input string.  It
00691        *  does so by returning collate::do_hash().
00692        *
00693        *  @param lo  Start of string.
00694        *  @param hi  End of string.
00695        *  @return  Hash value.
00696       */
00697       long
00698       hash(const _CharT* __lo, const _CharT* __hi) const
00699       { return this->do_hash(__lo, __hi); }
00700 
00701       // Used to abstract out _CharT bits in virtual member functions, below.
00702       int
00703       _M_compare(const _CharT*, const _CharT*) const throw ();
00704 
00705       size_t
00706       _M_transform(_CharT*, const _CharT*, size_t) const throw ();
00707 
00708   protected:
00709       /// Destructor.
00710       virtual
00711       ~collate()
00712       { _S_destroy_c_locale(_M_c_locale_collate); }
00713 
00714       /**
00715        *  @brief  Compare two strings.
00716        *
00717        *  This function is a hook for derived classes to change the value
00718        *  returned.  @see compare().
00719        *
00720        *  @param lo1  Start of string 1.
00721        *  @param hi1  End of string 1.
00722        *  @param lo2  Start of string 2.
00723        *  @param hi2  End of string 2.
00724        *  @return  1 if string1 > string2, -1 if string1 < string2, else 0.
00725       */
00726       virtual int
00727       do_compare(const _CharT* __lo1, const _CharT* __hi1,
00728          const _CharT* __lo2, const _CharT* __hi2) const;
00729 
00730       /**
00731        *  @brief  Transform string to comparable form.
00732        *
00733        *  This function is a hook for derived classes to change the value
00734        *  returned.
00735        *
00736        *  @param lo1  Start of string 1.
00737        *  @param hi1  End of string 1.
00738        *  @param lo2  Start of string 2.
00739        *  @param hi2  End of string 2.
00740        *  @return  1 if string1 > string2, -1 if string1 < string2, else 0.
00741       */
00742       virtual string_type
00743       do_transform(const _CharT* __lo, const _CharT* __hi) const;
00744 
00745       /**
00746        *  @brief  Return hash of a string.
00747        *
00748        *  This function computes and returns a hash on the input string.  This
00749        *  function is a hook for derived classes to change the value returned.
00750        *
00751        *  @param lo  Start of string.
00752        *  @param hi  End of string.
00753        *  @return  Hash value.
00754       */
00755       virtual long
00756       do_hash(const _CharT* __lo, const _CharT* __hi) const;
00757     };
00758 
00759   template<typename _CharT>
00760     locale::id collate<_CharT>::id;
00761 
00762   // Specializations.
00763   template<>
00764     int
00765     collate<char>::_M_compare(const char*, const char*) const throw ();
00766 
00767   template<>
00768     size_t
00769     collate<char>::_M_transform(char*, const char*, size_t) const throw ();
00770 
00771 #ifdef _GLIBCXX_USE_WCHAR_T
00772   template<>
00773     int
00774     collate<wchar_t>::_M_compare(const wchar_t*, const wchar_t*) const throw ();
00775 
00776   template<>
00777     size_t
00778     collate<wchar_t>::_M_transform(wchar_t*, const wchar_t*, size_t) const throw ();
00779 #endif
00780 
00781   /// class collate_byname [22.2.4.2].
00782   template<typename _CharT>
00783     class collate_byname : public collate<_CharT>
00784     {
00785     public:
00786       //@{
00787       /// Public typedefs
00788       typedef _CharT               char_type;
00789       typedef basic_string<_CharT> string_type;
00790       //@}
00791 
00792       explicit
00793       collate_byname(const char* __s, size_t __refs = 0)
00794       : collate<_CharT>(__refs)
00795       {
00796     if (__builtin_strcmp(__s, "C") != 0
00797         && __builtin_strcmp(__s, "POSIX") != 0)
00798       {
00799         this->_S_destroy_c_locale(this->_M_c_locale_collate);
00800         this->_S_create_c_locale(this->_M_c_locale_collate, __s);
00801       }
00802       }
00803 
00804     protected:
00805       virtual
00806       ~collate_byname() { }
00807     };
00808 
00809 _GLIBCXX_END_NAMESPACE
00810 
00811 #ifndef _GLIBCXX_EXPORT_TEMPLATE
00812 # include <bits/locale_classes.tcc>
00813 #endif
00814 
00815 #endif

Generated on 11 Jan 2010 for libstdc++ by  doxygen 1.6.1