| Boost.Locale

- Main Page
- Modules
- Namespaces
- Classes
- Files
- Examples

- File List

boost/locale/conversion.hpp

    00001 //
    00002 //  Copyright (c) 2009-2011 Artyom Beilis (Tonkikh)
    00003 //
    00004 //  Distributed under the Boost Software License, Version 1.0. (See
    00005 //  accompanying file LICENSE_1_0.txt or copy at
    00006 //  http://www.boost.org/LICENSE_1_0.txt)
    00007 //
    00008 #ifndef BOOST_LOCALE_CONVERTER_HPP_INCLUDED
    00009 #define BOOST_LOCALE_CONVERTER_HPP_INCLUDED
    00010
    00011 #include <boost/locale/config.hpp>
    00012 #ifdef BOOST_MSVC
    00013 #  pragma warning(push)
    00014 #  pragma warning(disable : 4275 4251 4231 4660)
    00015 #endif
    00016 #include <locale>
    00017
    00018
    00019 namespace boost {
    00020     namespace locale {
    00021
    00028
    00029
    00033         class converter_base {
    00034         public:
    00038             typedef enum {
    00039                 normalization,
    00040                 upper_case,
    00041                 lower_case,
    00042                 case_folding,
    00043                 title_case
    00044             } conversion_type;
    00045         };
    00046
    00047         template<typename CharType>
    00048         class converter;
    00049
    00050         #ifdef BOOST_LOCALE_DOXYGEN
    00051
    00052
    00053
    00054
    00055
    00056
    00057         template<typename Char>
    00058         class BOOST_LOCALE_DECL converter: public converter_base, public std::locale::facet {
    00059         public:
    00061             static std::locale::id id;
    00062
    00064             converter(size_t refs = 0) : std::locale::facet(refs)
    00065             {
    00066             }
    00071             virtual std::basic_string<Char> convert(conversion_type how,Char const *begin,Char const *end,int flags = 0) const = 0;
    00072 #if defined (__SUNPRO_CC) && defined (_RWSTD_VER)
    00073             std::locale::id& __get_id (void) const { return id; }
    00074 #endif
    00075         };
    00076         #else
    00077
    00078         template<>
    00079         class BOOST_LOCALE_DECL converter<char> : public converter_base, public std::locale::facet {
    00080         public:
    00081             static std::locale::id id;
    00082
    00083             converter(size_t refs = 0) : std::locale::facet(refs)
    00084             {
    00085             }
    00086             virtual std::string convert(conversion_type how,char const *begin,char const *end,int flags = 0) const = 0;
    00087 #if defined (__SUNPRO_CC) && defined (_RWSTD_VER)
    00088             std::locale::id& __get_id (void) const { return id; }
    00089 #endif
    00090         };
    00091
    00092         template<>
    00093         class BOOST_LOCALE_DECL converter<wchar_t> : public converter_base, public std::locale::facet {
    00094         public:
    00095             static std::locale::id id;
    00096             converter(size_t refs = 0) : std::locale::facet(refs)
    00097             {
    00098             }
    00099              virtual std::wstring convert(conversion_type how,wchar_t const *begin,wchar_t const *end,int flags = 0) const = 0;
    00100 #if defined (__SUNPRO_CC) && defined (_RWSTD_VER)
    00101             std::locale::id& __get_id (void) const { return id; }
    00102 #endif
    00103         };
    00104
    00105         #ifdef BOOST_HAS_CHAR16_T
    00106         template<>
    00107         class BOOST_LOCALE_DECL converter<char16_t> : public converter_base, public std::locale::facet {
    00108         public:
    00109             static std::locale::id id;
    00110             converter(size_t refs = 0) : std::locale::facet(refs)
    00111             {
    00112             }
    00113             virtual std::u16string convert(conversion_type how,char16_t const *begin,char16_t const *end,int flags = 0) const = 0;
    00114 #if defined (__SUNPRO_CC) && defined (_RWSTD_VER)
    00115             std::locale::id& __get_id (void) const { return id; }
    00116 #endif
    00117         };
    00118         #endif
    00119
    00120         #ifdef BOOST_HAS_CHAR32_T
    00121         template<>
    00122         class BOOST_LOCALE_DECL converter<char32_t> : public converter_base, public std::locale::facet {
    00123         public:
    00124             static std::locale::id id;
    00125             converter(size_t refs = 0) : std::locale::facet(refs)
    00126             {
    00127             }
    00128             virtual std::u32string convert(conversion_type how,char32_t const *begin,char32_t const *end,int flags = 0) const = 0;
    00129 #if defined (__SUNPRO_CC) && defined (_RWSTD_VER)
    00130             std::locale::id& __get_id (void) const { return id; }
    00131 #endif
    00132         };
    00133         #endif
    00134
    00135         #endif
    00136
    00140
    00141         typedef enum {
    00142             norm_nfd,
    00143             norm_nfc,
    00144             norm_nfkd,
    00145             norm_nfkc,
    00146             norm_default = norm_nfc,
    00147         } norm_type;
    00148
    00158         template<typename CharType>
    00159         std::basic_string<CharType> normalize(std::basic_string<CharType> const &str,norm_type n=norm_default,std::locale const &loc=std::locale())
    00160         {
    00161             return std::use_facet<converter<CharType> >(loc).convert(converter_base::normalization,str.data(),str.data() + str.size(),n);
    00162         }
    00163
    00173         template<typename CharType>
    00174         std::basic_string<CharType> normalize(CharType const *str,norm_type n=norm_default,std::locale const &loc=std::locale())
    00175         {
    00176             CharType const *end=str;
    00177             while(*end)
    00178                 end++;
    00179             return std::use_facet<converter<CharType> >(loc).convert(converter_base::normalization,str,end,n);
    00180         }
    00181
    00191         template<typename CharType>
    00192         std::basic_string<CharType> normalize(  CharType const *begin,
    00193                                                 CharType const *end,
    00194                                                 norm_type n=norm_default,
    00195                                                 std::locale const &loc=std::locale())
    00196         {
    00197             return std::use_facet<converter<CharType> >(loc).convert(converter_base::normalization,begin,end,n);
    00198         }
    00199
    00201
    00207
    00208         template<typename CharType>
    00209         std::basic_string<CharType> to_upper(std::basic_string<CharType> const &str,std::locale const &loc=std::locale())
    00210         {
    00211             return std::use_facet<converter<CharType> >(loc).convert(converter_base::upper_case,str.data(),str.data()+str.size());
    00212         }
    00213
    00219         template<typename CharType>
    00220         std::basic_string<CharType> to_upper(CharType const *str,std::locale const &loc=std::locale())
    00221         {
    00222             CharType const *end=str;
    00223             while(*end)
    00224                 end++;
    00225             return std::use_facet<converter<CharType> >(loc).convert(converter_base::upper_case,str,end);
    00226         }
    00227
    00233         template<typename CharType>
    00234         std::basic_string<CharType> to_upper(CharType const *begin,CharType const *end,std::locale const &loc=std::locale())
    00235         {
    00236             return std::use_facet<converter<CharType> >(loc).convert(converter_base::upper_case,begin,end);
    00237         }
    00238
    00240
    00246
    00247         template<typename CharType>
    00248         std::basic_string<CharType> to_lower(std::basic_string<CharType> const &str,std::locale const &loc=std::locale())
    00249         {
    00250             return std::use_facet<converter<CharType> >(loc).convert(converter_base::lower_case,str.data(),str.data()+str.size());
    00251         }
    00252
    00258         template<typename CharType>
    00259         std::basic_string<CharType> to_lower(CharType const *str,std::locale const &loc=std::locale())
    00260         {
    00261             CharType const *end=str;
    00262             while(*end)
    00263                 end++;
    00264             return std::use_facet<converter<CharType> >(loc).convert(converter_base::lower_case,str,end);
    00265         }
    00266
    00272         template<typename CharType>
    00273         std::basic_string<CharType> to_lower(CharType const *begin,CharType const *end,std::locale const &loc=std::locale())
    00274         {
    00275             return std::use_facet<converter<CharType> >(loc).convert(converter_base::lower_case,begin,end);
    00276         }
    00278
    00284
    00285         template<typename CharType>
    00286         std::basic_string<CharType> to_title(std::basic_string<CharType> const &str,std::locale const &loc=std::locale())
    00287         {
    00288             return std::use_facet<converter<CharType> >(loc).convert(converter_base::title_case,str.data(),str.data()+str.size());
    00289         }
    00290
    00296         template<typename CharType>
    00297         std::basic_string<CharType> to_title(CharType const *str,std::locale const &loc=std::locale())
    00298         {
    00299             CharType const *end=str;
    00300             while(*end)
    00301                 end++;
    00302             return std::use_facet<converter<CharType> >(loc).convert(converter_base::title_case,str,end);
    00303         }
    00304
    00310         template<typename CharType>
    00311         std::basic_string<CharType> to_title(CharType const *begin,CharType const *end,std::locale const &loc=std::locale())
    00312         {
    00313             return std::use_facet<converter<CharType> >(loc).convert(converter_base::title_case,begin,end);
    00314         }
    00315
    00317
    00323
    00324         template<typename CharType>
    00325         std::basic_string<CharType> fold_case(std::basic_string<CharType> const &str,std::locale const &loc=std::locale())
    00326         {
    00327             return std::use_facet<converter<CharType> >(loc).convert(converter_base::case_folding,str.data(),str.data()+str.size());
    00328         }
    00329
    00335         template<typename CharType>
    00336         std::basic_string<CharType> fold_case(CharType const *str,std::locale const &loc=std::locale())
    00337         {
    00338             CharType const *end=str;
    00339             while(*end)
    00340                 end++;
    00341             return std::use_facet<converter<CharType> >(loc).convert(converter_base::case_folding,str,end);
    00342         }
    00343
    00349         template<typename CharType>
    00350         std::basic_string<CharType> fold_case(CharType const *begin,CharType const *end,std::locale const &loc=std::locale())
    00351         {
    00352             return std::use_facet<converter<CharType> >(loc).convert(converter_base::case_folding,begin,end);
    00353         }
    00354
    00358     } // locale
    00359
    00360 } // boost
    00361
    00362 #ifdef BOOST_MSVC
    00363 #pragma warning(pop)
    00364 #endif
    00365
    00366
    00367 #endif
    00368
    00378
    00379 // vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4
    00380