_locale.h

Go to the documentation of this file.

 
#ifndef _RWSTD_LOC_LOCALE_INCLUDED
#define _RWSTD_LOC_LOCALE_INCLUDED
 
 
#include <string>
 
#include <loc/_facet.h>
#include <rw/_defs.h>
 
 
_RWSTD_NAMESPACE (__rw) { 
 
enum __rw_locale_category {
    __rw_cat_none     = 0x0100,
    __rw_cat_collate  = 0x0200,
    __rw_cat_ctype    = 0x0400,
    __rw_cat_monetary = 0x0800,
    __rw_cat_numeric  = 0x1000,
    __rw_cat_time     = 0x2000,
    __rw_cat_messages = 0x4000,
    __rw_cat_all      = 0x7e00
};
 
 
class _RWSTD_EXPORT __rw_locale;
 
inline const __rw_facet*
__rw_get_std_facet (const _STD::locale&, __rw_facet::_C_facet_type,
                    __rw_facet::_C_ctor_t*);
 
inline const __rw_facet*
__rw_get_facet_by_id (const _STD::locale&,
                      const __rw_facet_id&,
                      const __rw_facet*);
 
// called from has_facet and use_facet to strips top level
// const-qualifier from the type of Facet
template <class _Facet>
inline const __rw_facet*
__rw_get_facet (const _STD::locale&, const _Facet*);
 
}   // namespace __rw
 
 
_RWSTD_NAMESPACE (std) {
 
 
// 22.1.2, p1
template <class _Facet>
inline const _Facet&
use_facet (const locale &__loc _RWSTD_DUMMY_ARG (const _Facet* = 0))
{
    // Facet could be a const SomeFacet; strip the const qualifier
    // and, for non-standard facets, use dynamic_cast to make sure
    // that the dynamic type of `pfacet' is the same as Facet
    const _RW::__rw_facet* const __pfacet =
        _RW::__rw_get_facet (__loc, (_Facet*)0);
 
    _RWSTD_REQUIRES (__pfacet,
                     (_RWSTD_ERROR_BAD_CAST,
                      _RWSTD_FUNC ("use_facet (const locale&)")));
 
    return *_RWSTD_STATIC_CAST (const _Facet*, __pfacet);
}
 
 
// 22.1.2, p5
template <class _Facet>
inline bool
has_facet (const locale &__loc _RWSTD_DUMMY_ARG (const _Facet* = 0))
{
    // Facet could be a const SomeFacet; strip the const qualifier 
    const _RW::__rw_facet* const __pfacet =
        _RW::__rw_get_facet (__loc, (_Facet*)0);
 
    return 0 != __pfacet;
}
 
 
// forward declare standard facets before referencing them below
_EXPORT template <class _InternT, class _ExternT, class _StateT>
class codecvt;
 
_EXPORT template <class _CharT>
class collate;
 
_EXPORT template <class _CharT>
class ctype;
 
_EXPORT template <class _CharT, class _Iter>
struct money_get;
 
_EXPORT template <class _CharT, class _Iter>
struct money_put;
 
_EXPORT template <class _CharT, bool _Intl>
struct moneypunct;
 
_EXPORT template <class _CharT, class _Iter>
struct num_get;
 
_EXPORT template <class _CharT, class _Iter>
struct num_put;
 
_EXPORT template <class _CharT>
struct numpunct;
 
_EXPORT template <class _CharT, class _Iter>
class time_get;
 
_EXPORT template <class _CharT, class _Iter>
struct time_put;
 
_EXPORT template <class _CharT>
class messages;
 
 
// 22.1.1
struct _RWSTD_CLASS_EXPORT locale
{
    // 22.1.1.1.1, p1
    typedef int category;
 
    // 22.1.1.1.2
    typedef _RW::__rw_facet facet;
 
    // 22.1.1.1.3
    typedef _RW::__rw_facet_id id;
 
    // values (including none) must not conflict with any LC_XXX constants
    _RWSTD_STATIC_CONST (category, none     = _RW::__rw_cat_none);
    _RWSTD_STATIC_CONST (category, collate  = _RW::__rw_cat_collate);
    _RWSTD_STATIC_CONST (category, ctype    = _RW::__rw_cat_ctype);
    _RWSTD_STATIC_CONST (category, monetary = _RW::__rw_cat_monetary);
    _RWSTD_STATIC_CONST (category, numeric  = _RW::__rw_cat_numeric);
    _RWSTD_STATIC_CONST (category, time     = _RW::__rw_cat_time);
    _RWSTD_STATIC_CONST (category, messages = _RW::__rw_cat_messages);
    _RWSTD_STATIC_CONST (category, all      = _RW::__rw_cat_all);
 
    // 22.1.1.2, p1
    _RWSTD_MEMBER_EXPORT locale () _THROWS (());
 
    // 22.1.1.2, p3
    _RWSTD_MEMBER_EXPORT locale (const locale&) _THROWS (());
 
    // 22.1.1.2, p6
    _RWSTD_MEMBER_EXPORT explicit locale (const char*);
 
    // 22.1.1.2, p9
    _RWSTD_MEMBER_EXPORT locale (const locale&, const char*, category);
 
    // 22.1.1.2, p12
    template <class _Facet>
    locale (const locale&, _Facet*);
 
#ifndef _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE
 
    // 22.1.1.3, p1
    template <class _Facet>
    locale combine (const locale&) const;
 
#endif   // _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE
 
    // 22.1.1.4, p3
    template <class _CharT, class _Traits, class _Allocator>
    bool operator() (const basic_string<_CharT, _Traits, _Allocator>&,
                     const basic_string<_CharT, _Traits, _Allocator>&) const;
 
    // 22.1.1.2, p14
    _RWSTD_MEMBER_EXPORT locale (const locale&, const locale&, category);
 
    // 22.1.1.2, p16
    _RWSTD_MEMBER_EXPORT ~locale() _THROWS (());
 
    // 22.1.1.2, p4
    _RWSTD_MEMBER_EXPORT const locale& operator= (const locale&) _THROWS (());
 
    // 22.1.1.3, p5
    _RWSTD_MEMBER_EXPORT string name () const;
 
    // 22.1.1.4, p1
    _RWSTD_MEMBER_EXPORT bool operator== (const locale&) const;
 
    // 22.1.1.4, p2
    _RWSTD_MEMBER_EXPORT bool operator!= (const locale &__rhs) const {
        return !(*this == __rhs);
    }
 
    // 22.1.1.5, p1
    _RWSTD_MEMBER_EXPORT static locale global (const locale&);
 
    // 22.1.1.5, p4
    _RWSTD_MEMBER_EXPORT static const locale& classic ();
 
private:
 
    _RWSTD_MEMBER_EXPORT explicit locale (_RW::__rw_locale &__rhs) 
        _THROWS (())
        : _C_body (&__rhs) { }
 
    _RWSTD_MEMBER_EXPORT locale (_RW::__rw_locale&, const facet*);
 
    _RW::__rw_locale *_C_body;     // reference-counted body
 
#if    defined (__SUNPRO_CC) && __SUNPRO_CC <= 0x540
 
   // working around a SunPro member access control bug (see PR #25910)
public:
 
#endif   // SunPro <= 5.4
 
    // (try to) retrieve a facet from a locale given an id
    // may initialize the id if it isn't initialized yet
    _RWSTD_MEMBER_EXPORT const facet*
    _C_get_facet (const id&) const;
 
    _RWSTD_MEMBER_EXPORT const facet*
    _C_get_std_facet (facet::_C_facet_type, facet::_C_ctor_t*) const;
 
    friend class  _RW::__rw_locale;
    friend struct _RW::__rw_access;
 
    // function arguments below are qualified to work around
    // a SunPro 5.5 and prior bug (PR #28626)
    friend const facet*
    _RW::__rw_get_std_facet (const _STD::locale&,
                             _RW::__rw_facet::_C_facet_type,
                             _RW::__rw_facet::_C_ctor_t*);
 
    friend const _RW::__rw_facet*
    _RW::__rw_get_facet_by_id (const _STD::locale&,
                               const _RW::__rw_facet_id&,
                               const _RW::__rw_facet*);
};
 
}   // namespace std
 
 
_RWSTD_NAMESPACE (__rw) {
 
inline const __rw_facet*
__rw_get_facet_by_id (const _STD::locale &__loc,
                      const __rw_facet_id      &__id,
                      const __rw_facet*)
{
    // initialize Facet::id and retrieve facet if it's installed
    return __loc._C_get_facet (__id);
}
 
 
template <class _Facet>
inline const __rw_facet*
__rw_get_facet (const _STD::locale &__loc, const _Facet *__dummy)
{
    // resolves either to one of the overloads of __rw_get_facet_by_id
    // defined for the set of standard facets or the overload for the base
    // locale::facet* if _Facet is not derived from any of the former
    const __rw_facet* const __pfacet =
        __rw_get_facet_by_id (__loc, _Facet::id, __dummy);
 
    return _RWSTD_DYNAMIC_CAST (const _Facet*, __pfacet);
}
 
 
inline const __rw_facet*
__rw_get_std_facet (const _STD::locale  &__loc,
                    __rw_facet::_C_facet_type  __type,
                    __rw_facet::_C_ctor_t     *__ctor)
{
    // expose an implementation detail of locale body for efficiency
    struct _Facets {
        __rw_facet *__facets [__rw_facet::_C_last_type / 2];
    };
 
    const _Facets* const __pfacets =
        _RWSTD_REINTERPRET_CAST (const _Facets*, __loc._C_body);
 
    _RWSTD_ASSERT (0 != __pfacets);
 
    const __rw_facet *__facet = __pfacets->__facets [__type >> 1];
 
    if (!__facet)
        __facet = __loc._C_get_std_facet (__type, __ctor);
 
#if !defined (__HP_aCC) || _RWSTD_HP_aCC_MINOR > 3800
 
    // working around an HP aCC ICE (PR #28838)
    _RWSTD_ASSERT (0 != __facet);
 
#endif   // HP aCC
 
    return __facet;
}
 
 
// functions' type must be __rw_facet::_C_ctor_t
// i.e., as if they were declared as follows:
//     __rw_facet::_C_ctor_t __rw_ct_ctype;
// the declaration above causes a Compaq C++ 6.5 ICE (PR #30188)
_RWSTD_EXPORT __rw_facet* __rw_ct_ctype (_RWSTD_SIZE_T, const char*);
_RWSTD_EXPORT __rw_facet* __rw_ct_numpunct (_RWSTD_SIZE_T, const char*);
_RWSTD_EXPORT __rw_facet* __rw_ct_num_get (_RWSTD_SIZE_T, const char*);
_RWSTD_EXPORT __rw_facet* __rw_ct_num_put (_RWSTD_SIZE_T, const char*);
 
 
#define _RWSTD_OVERLOAD_GET_FACET(F)                 \
    _RWSTD_EXPORT const __rw_facet*                  \
    __rw_get_facet_by_id (const _STD::locale&,       \
                          const __rw_facet_id&, const F*)
 
#define _Facet(name, T, U)   _STD::name<T, U >
 
#define _InIter(T)    _STD::istreambuf_iterator< T, _STD::char_traits<T > >
#define _OutIter(T)   _STD::ostreambuf_iterator< T, _STD::char_traits<T > >
 
// convenience typedefs to allow them to be used as macro arguments
typedef _STD::codecvt<char, char, _RWSTD_MBSTATE_T>    __rw_codecvt_c;
typedef _Facet (moneypunct, char, false)               __rw_mpunct_c_0;
typedef _Facet (moneypunct, char, true)                __rw_mpunct_c_1;
typedef _Facet (money_get, char, _InIter (char))       __rw_mget_c;
typedef _Facet (money_put, char, _OutIter (char))      __rw_mput_c;
typedef _Facet (num_get, char, _InIter (char))         __rw_nget_c;
typedef _Facet (num_put, char, _OutIter (char))        __rw_nput_c;
typedef _Facet (time_get, char, _InIter (char))        __rw_tget_c;
typedef _Facet (time_put, char, _OutIter (char))       __rw_tput_c;
 
 
// inline definitions of heavily used use_facet specializations
// for iostream efficiency
 
_RWSTD_SPECIALIZED_FUNCTION
inline const __rw_facet*
__rw_get_facet (const _STD::locale &__loc, const _STD::ctype<char>*)
{
    return __rw_get_std_facet (__loc, __rw_facet::_C_ctype,
                               __rw_ct_ctype);
}
 
 
_RWSTD_SPECIALIZED_FUNCTION
inline const __rw_facet*
__rw_get_facet (const _STD::locale &__loc, const _STD::numpunct<char>*)
{
    return __rw_get_std_facet (__loc, __rw_facet::_C_numpunct,
                               __rw_ct_numpunct);
}
 
 
_RWSTD_SPECIALIZED_FUNCTION
inline const __rw_facet*
__rw_get_facet (const _STD::locale &__loc, const __rw_nget_c*)
{
    return __rw_get_std_facet (__loc, __rw_facet::_C_num_get,
                               __rw_ct_num_get);
}
 
 
_RWSTD_SPECIALIZED_FUNCTION
inline const __rw_facet*
__rw_get_facet (const _STD::locale &__loc, const __rw_nput_c*)
{
    return __rw_get_std_facet (__loc, __rw_facet::_C_num_put,
                               __rw_ct_num_put);
}
 
 
// declarations of __rw_get_facet_by_id overloads
_RWSTD_OVERLOAD_GET_FACET (_STD::ctype<char>);
_RWSTD_OVERLOAD_GET_FACET (__rw_codecvt_c);
_RWSTD_OVERLOAD_GET_FACET (_STD::collate<char>);
_RWSTD_OVERLOAD_GET_FACET (__rw_mget_c);
_RWSTD_OVERLOAD_GET_FACET (__rw_mput_c);
_RWSTD_OVERLOAD_GET_FACET (__rw_mpunct_c_0);
_RWSTD_OVERLOAD_GET_FACET (__rw_mpunct_c_1);
_RWSTD_OVERLOAD_GET_FACET (__rw_nget_c);
_RWSTD_OVERLOAD_GET_FACET (__rw_nput_c);
_RWSTD_OVERLOAD_GET_FACET (_STD::numpunct<char>);
_RWSTD_OVERLOAD_GET_FACET (__rw_tget_c);
_RWSTD_OVERLOAD_GET_FACET (__rw_tput_c);
_RWSTD_OVERLOAD_GET_FACET (_STD::messages<char>);
 
#ifndef _RWSTD_NO_WCHAR_T
 
typedef _STD::codecvt<wchar_t, char, _RWSTD_MBSTATE_T>    __rw_codecvt_w;
typedef _Facet (moneypunct, wchar_t, false)               __rw_mpunct_w_0;
typedef _Facet (moneypunct, wchar_t, true)                __rw_mpunct_w_1;
typedef _Facet (money_get, wchar_t, _InIter (wchar_t))    __rw_mget_w;
typedef _Facet (money_put, wchar_t, _OutIter (wchar_t))   __rw_mput_w;
typedef _Facet (num_get, wchar_t, _InIter (wchar_t))      __rw_nget_w;
typedef _Facet (num_put, wchar_t, _OutIter (wchar_t))     __rw_nput_w;
typedef _Facet (time_get, wchar_t, _InIter (wchar_t))     __rw_tget_w;
typedef _Facet (time_put, wchar_t, _OutIter (wchar_t))    __rw_tput_w;
 
_RWSTD_OVERLOAD_GET_FACET (_STD::ctype<wchar_t>);
_RWSTD_OVERLOAD_GET_FACET (__rw_codecvt_w);
_RWSTD_OVERLOAD_GET_FACET (_STD::collate<wchar_t>);
_RWSTD_OVERLOAD_GET_FACET (__rw_mget_w);
_RWSTD_OVERLOAD_GET_FACET (__rw_mput_w);
_RWSTD_OVERLOAD_GET_FACET (__rw_mpunct_w_0);
_RWSTD_OVERLOAD_GET_FACET (__rw_mpunct_w_1);
_RWSTD_OVERLOAD_GET_FACET (__rw_nget_w);
_RWSTD_OVERLOAD_GET_FACET (__rw_nput_w);
_RWSTD_OVERLOAD_GET_FACET (_STD::numpunct<wchar_t>);
_RWSTD_OVERLOAD_GET_FACET (__rw_tget_w);
_RWSTD_OVERLOAD_GET_FACET (__rw_tput_w);
_RWSTD_OVERLOAD_GET_FACET (_STD::messages<wchar_t>);
 
#endif   // _RWSTD_NO_WCHAR_T
 
// clean up
#undef _RWSTD_OVERLOAD_GET_FACET
#undef _Facet
#undef _InIter
#undef _OutIter
 
 
}   // namespace __rw
 
 
_RWSTD_NAMESPACE (std) {
 
 
template <class _Facet>
inline locale::locale (const locale &__rhs, _Facet *__facet)
    : _C_body (0)
{
    // initialize facet's member id to point to Facet::id
    if (__facet && !__facet->_C_pid) {
        // unusual cast (to size_t** rather than size_t*&)
        // done to work around an HP aCC 3.3x bug
        *_RWSTD_CONST_CAST (_RWSTD_SIZE_T**, &__facet->_C_pid) =
            &_Facet::id._C_id;
    }
 
    // uninitialized Facet::id will be initialized by has_facet<>()
 
    // prevent passing `facet' the ctor if it is installed in `rhs'
    // to potentially avoid creating a whole new locale body
    if (_RW::__rw_get_facet (__rhs, (_Facet*)0) == __facet)
        __facet = 0;
 
    *this = locale (*__rhs._C_body, __facet);
}
 
 
#ifndef _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE
 
template <class _Facet>
inline locale locale::combine (const locale &__rhs) const
{
    // unitialized Facet::id will be initialized by has_facet<>()
 
    _RWSTD_REQUIRES (has_facet<_Facet>(__rhs),
                     (_RWSTD_ERROR_FACET_NOT_FOUND,
                      _RWSTD_FUNC ("locale::combine (const locale&)"),
                      _Facet::id._C_id, __rhs.name ().c_str ()));
 
    return locale (*this, &use_facet<_Facet>(__rhs));
}
 
#endif   // _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE
 
 
template <class _CharT, class _Traits, class _Allocator>
inline bool
locale::operator() (const basic_string<_CharT, _Traits, _Allocator> &__x,
                    const basic_string<_CharT, _Traits, _Allocator> &__y) const
{
    // qualify collate to distinguish it from locale::collate
    return use_facet<_STD::collate<_CharT> >(*this)
        .compare (__x.data (), __x.data () + __x.length (),
                  __y.data (), __y.data () + __y.length ()) < 0;
}
 
 
}   // namespace std
 
 
#endif   // _RWSTD_LOC_LOCALE_INCLUDED