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/config.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 CharType>
    class converter;

#ifdef BOOST_LOCALE_DOXYGEN
    template<typename Char>
    class BOOST_LOCALE_DECL converter : public converter_base, public std::locale::facet {
    public:
        static std::locale::id id;

        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;
    };
#else

    template<>
    class BOOST_LOCALE_DECL converter<char> : public converter_base, public std::locale::facet {
    public:
        static std::locale::id id;

        converter(size_t refs = 0) : std::locale::facet(refs) {}
        ~converter();
        virtual std::string convert(conversion_type how, const char* begin, const char* end, int flags = 0) const = 0;
    };

    template<>
    class BOOST_LOCALE_DECL converter<wchar_t> : public converter_base, public std::locale::facet {
    public:
        static std::locale::id id;
        converter(size_t refs = 0) : std::locale::facet(refs) {}
        ~converter();
        virtual std::wstring
        convert(conversion_type how, const wchar_t* begin, const wchar_t* end, int flags = 0) const = 0;
    };

#    ifdef BOOST_LOCALE_ENABLE_CHAR16_T
    template<>
    class BOOST_LOCALE_DECL converter<char16_t> : public converter_base, public std::locale::facet {
    public:
        static std::locale::id id;
        converter(size_t refs = 0) : std::locale::facet(refs) {}
        ~converter();
        virtual std::u16string
        convert(conversion_type how, const char16_t* begin, const char16_t* end, int flags = 0) const = 0;
    };
#    endif

#    ifdef BOOST_LOCALE_ENABLE_CHAR32_T
    template<>
    class BOOST_LOCALE_DECL converter<char32_t> : public converter_base, public std::locale::facet {
    public:
        static std::locale::id id;
        converter(size_t refs = 0) : std::locale::facet(refs) {}
        ~converter();
        virtual std::u32string
        convert(conversion_type how, const char32_t* begin, const char32_t* end, int flags = 0) const = 0;
    };
#    endif

#endif

    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