CppCMS
booster/locale/encoding.h
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 BOOSTER_LOCALE_ENCODING_H_INCLUDED
00009 #define BOOSTER_LOCALE_ENCODING_H_INCLUDED
00010 
00011 #include <booster/config.h>
00012 #ifdef BOOSTER_MSVC
00013 #  pragma warning(push)
00014 #  pragma warning(disable : 4275 4251 4231 4660)
00015 #endif
00016 #include <booster/locale/info.h>
00017 #include <booster/locale/encoding_errors.h>
00018 #include <booster/locale/encoding_utf.h>
00019 
00020 
00021 
00022 namespace booster {
00023     namespace locale {
00024 
00028         namespace conv {
00033 
00037             template<typename CharType>
00038             std::basic_string<CharType> to_utf(char const *begin,char const *end,std::string const &charset,method_type how=default_method);
00039 
00043             template<typename CharType>
00044             std::string from_utf(CharType const *begin,CharType const *end,std::string const &charset,method_type how=default_method);
00045 
00051             template<typename CharType>
00052             std::basic_string<CharType> to_utf(char const *begin,char const *end,std::locale const &loc,method_type how=default_method)
00053             {
00054                 return to_utf<CharType>(begin,end,std::use_facet<info>(loc).encoding(),how);
00055             }
00056 
00062             template<typename CharType>
00063             std::string from_utf(CharType const *begin,CharType const *end,std::locale const &loc,method_type how=default_method)
00064             {
00065                 return from_utf(begin,end,std::use_facet<info>(loc).encoding(),how);
00066             }
00067 
00071             
00072             template<typename CharType>
00073             std::basic_string<CharType> to_utf(std::string const &text,std::string const &charset,method_type how=default_method)
00074             {
00075                 return to_utf<CharType>(text.c_str(),text.c_str()+text.size(),charset,how);
00076             }
00077 
00081             template<typename CharType>
00082             std::string from_utf(std::basic_string<CharType> const &text,std::string const &charset,method_type how=default_method)
00083             {
00084                 return from_utf(text.c_str(),text.c_str()+text.size(),charset,how);
00085             }
00086 
00090             template<typename CharType>
00091             std::basic_string<CharType> to_utf(char const *text,std::string const &charset,method_type how=default_method)
00092             {
00093                 char const *text_end = text;
00094                 while(*text_end) 
00095                     text_end++;
00096                 return to_utf<CharType>(text,text_end,charset,how);
00097             }
00098 
00102             template<typename CharType>
00103             std::string from_utf(CharType const *text,std::string const &charset,method_type how=default_method)
00104             {
00105                 CharType const *text_end = text;
00106                 while(*text_end) 
00107                     text_end++;
00108                 return from_utf(text,text_end,charset,how);
00109             }
00110 
00116             template<typename CharType>
00117             std::basic_string<CharType> to_utf(std::string const &text,std::locale const &loc,method_type how=default_method)
00118             {
00119                 return to_utf<CharType>(text.c_str(),text.c_str()+text.size(),loc,how);
00120             }
00121 
00127             template<typename CharType>
00128             std::string from_utf(std::basic_string<CharType> const &text,std::locale const &loc,method_type how=default_method)
00129             {
00130                 return from_utf(text.c_str(),text.c_str()+text.size(),loc,how);
00131             }
00132 
00138             template<typename CharType>
00139             std::basic_string<CharType> to_utf(char const *text,std::locale const &loc,method_type how=default_method)
00140             {
00141                 char const *text_end = text;
00142                 while(*text_end) 
00143                     text_end++;
00144                 return to_utf<CharType>(text,text_end,loc,how);
00145             }
00146 
00152             template<typename CharType>
00153             std::string from_utf(CharType const *text,std::locale const &loc,method_type how=default_method)
00154             {
00155                 CharType const *text_end = text;
00156                 while(*text_end) 
00157                     text_end++;
00158                 return from_utf(text,text_end,loc,how);
00159             }
00160 
00161 
00165             
00166             BOOSTER_API
00167             std::string between(char const *begin,
00168                                 char const *end,
00169                                 std::string const &to_encoding,
00170                                 std::string const &from_encoding,
00171                                 method_type how=default_method);
00172 
00176             
00177             inline
00178             std::string between(char const *text,
00179                                 std::string const &to_encoding,
00180                                 std::string const &from_encoding,
00181                                 method_type how=default_method)
00182             {
00183                 char const *end=text;
00184                 while(*end)
00185                     end++;
00186                 return booster::locale::conv::between(text,end,to_encoding,from_encoding,how);
00187             }
00188 
00192             inline
00193             std::string between(std::string const &text,
00194                                 std::string const &to_encoding,
00195                                 std::string const &from_encoding,
00196                                 method_type how=default_method)
00197             {
00198                 return booster::locale::conv::between(text.c_str(),text.c_str()+text.size(),to_encoding,from_encoding,how);
00199             }
00200           
00202 
00203             template<>
00204             BOOSTER_API std::basic_string<char> to_utf(char const *begin,char const *end,std::string const &charset,method_type how);
00205 
00206             template<>
00207             BOOSTER_API std::string from_utf(char const *begin,char const *end,std::string const &charset,method_type how);
00208 
00209             template<>
00210             BOOSTER_API std::basic_string<wchar_t> to_utf(char const *begin,char const *end,std::string const &charset,method_type how);
00211 
00212             template<>
00213             BOOSTER_API std::string from_utf(wchar_t const *begin,wchar_t const *end,std::string const &charset,method_type how);
00214 
00215             #ifdef BOOSTER_HAS_CHAR16_T
00216             template<>
00217             BOOSTER_API std::basic_string<char16_t> to_utf(char const *begin,char const *end,std::string const &charset,method_type how);
00218 
00219             template<>
00220             BOOSTER_API std::string from_utf(char16_t const *begin,char16_t const *end,std::string const &charset,method_type how);
00221             #endif
00222 
00223             #ifdef BOOSTER_HAS_CHAR32_T
00224             template<>
00225             BOOSTER_API std::basic_string<char32_t> to_utf(char const *begin,char const *end,std::string const &charset,method_type how);
00226 
00227             template<>
00228             BOOSTER_API std::string from_utf(char32_t const *begin,char32_t const *end,std::string const &charset,method_type how);
00229             #endif
00230 
00231 
00233 
00234         } // conv
00235 
00236     } // locale
00237 } // boost
00238 
00239 #ifdef BOOSTER_MSVC
00240 #pragma warning(pop)
00241 #endif
00242 
00243 #endif
00244 
00245 // vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4
00246