conversion.hpp

//
// Copyright (c) 2009-2011 Artyom Beilis (Tonkikh)
//
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
 
#ifndef BOOST_LOCALE_CONVERTER_HPP_INCLUDED
#define BOOST_LOCALE_CONVERTER_HPP_INCLUDED
 
#include <boost/locale/detail/facet_id.hpp>
#include <boost/locale/detail/is_supported_char.hpp>
#include <boost/locale/util/string.hpp>
#include <locale>
 
#ifdef BOOST_MSVC
#    pragma warning(push)
#    pragma warning(disable : 4275 4251 4231 4660)
#endif
 
namespace boost { namespace locale {
 
 
    class converter_base {
    public:
        enum conversion_type {
            normalization, 
            upper_case,    
            lower_case,    
            case_folding,  
            title_case     
        };
    };
 
    template<typename Char>
    class BOOST_SYMBOL_VISIBLE converter : public converter_base,
                                           public std::locale::facet,
                                           public detail::facet_id<converter<Char>> {
        BOOST_LOCALE_ASSERT_IS_SUPPORTED(Char);
 
    public:
        converter(size_t refs = 0) : std::locale::facet(refs) {}
        virtual std::basic_string<Char>
        convert(conversion_type how, const Char* begin, const Char* end, int flags = 0) const = 0;
    };
 
    enum norm_type {
        norm_nfd,                
        norm_nfc,                
        norm_nfkd,               
        norm_nfkc,               
        norm_default = norm_nfc, 
    };
 
    template<typename CharType>
    std::basic_string<CharType> normalize(const CharType* begin,
                                          const CharType* end,
                                          norm_type n = norm_default,
                                          const std::locale& loc = std::locale())
    {
        return std::use_facet<converter<CharType>>(loc).convert(converter_base::normalization, begin, end, n);
    }
 
    template<typename CharType>
    std::basic_string<CharType> normalize(const std::basic_string<CharType>& str,
                                          norm_type n = norm_default,
                                          const std::locale& loc = std::locale())
    {
        return normalize(str.data(), str.data() + str.size(), n, loc);
    }
 
    template<typename CharType>
    std::basic_string<CharType>
    normalize(const CharType* str, norm_type n = norm_default, const std::locale& loc = std::locale())
    {
        return normalize(str, util::str_end(str), n, loc);
    }
 
 
    template<typename CharType>
    std::basic_string<CharType>
    to_upper(const CharType* begin, const CharType* end, const std::locale& loc = std::locale())
    {
        return std::use_facet<converter<CharType>>(loc).convert(converter_base::upper_case, begin, end);
    }
 
    template<typename CharType>
    std::basic_string<CharType> to_upper(const std::basic_string<CharType>& str, const std::locale& loc = std::locale())
    {
        return to_upper(str.data(), str.data() + str.size(), loc);
    }
 
    template<typename CharType>
    std::basic_string<CharType> to_upper(const CharType* str, const std::locale& loc = std::locale())
    {
        return to_upper(str, util::str_end(str), loc);
    }
 
 
    template<typename CharType>
    std::basic_string<CharType>
    to_lower(const CharType* begin, const CharType* end, const std::locale& loc = std::locale())
    {
        return std::use_facet<converter<CharType>>(loc).convert(converter_base::lower_case, begin, end);
    }
 
    template<typename CharType>
    std::basic_string<CharType> to_lower(const std::basic_string<CharType>& str, const std::locale& loc = std::locale())
    {
        return to_lower(str.data(), str.data() + str.size(), loc);
    }
 
    template<typename CharType>
    std::basic_string<CharType> to_lower(const CharType* str, const std::locale& loc = std::locale())
    {
        return to_lower(str, util::str_end(str), loc);
    }
 
 
    template<typename CharType>
    std::basic_string<CharType>
    to_title(const CharType* begin, const CharType* end, const std::locale& loc = std::locale())
    {
        return std::use_facet<converter<CharType>>(loc).convert(converter_base::title_case, begin, end);
    }
 
    template<typename CharType>
    std::basic_string<CharType> to_title(const std::basic_string<CharType>& str, const std::locale& loc = std::locale())
    {
        return to_title(str.data(), str.data() + str.size(), loc);
    }
 
    template<typename CharType>
    std::basic_string<CharType> to_title(const CharType* str, const std::locale& loc = std::locale())
    {
        return to_title(str, util::str_end(str), loc);
    }
 
 
    template<typename CharType>
    std::basic_string<CharType>
    fold_case(const CharType* begin, const CharType* end, const std::locale& loc = std::locale())
    {
        return std::use_facet<converter<CharType>>(loc).convert(converter_base::case_folding, begin, end);
    }
 
    template<typename CharType>
    std::basic_string<CharType> fold_case(const std::basic_string<CharType>& str,
                                          const std::locale& loc = std::locale())
    {
        return fold_case(str.data(), str.data() + str.size(), loc);
    }
 
    template<typename CharType>
    std::basic_string<CharType> fold_case(const CharType* str, const std::locale& loc = std::locale())
    {
        return fold_case(str, util::str_end(str), loc);
    }
 
}} // namespace boost::locale
 
#ifdef BOOST_MSVC
#    pragma warning(pop)
#endif
 
 
#endif