message.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_MESSAGE_HPP_INCLUDED
#define BOOST_LOCALE_MESSAGE_HPP_INCLUDED

#include <boost/locale/formatting.hpp>
#include <boost/locale/util/string.hpp>
#include <locale>
#include <memory>
#include <set>
#include <string>

#ifdef BOOST_MSVC
#    pragma warning(push)
#    pragma warning(disable : 4275 4251 4231 4660)
#endif

// glibc < 2.3.4 declares those as macros if compiled with optimization turned on
#ifdef gettext
#    undef gettext
#    undef ngettext
#    undef dgettext
#    undef dngettext
#endif

namespace boost { namespace locale {


    template<typename CharType>
    struct base_message_format;


    template<typename CharType>
    class BOOST_SYMBOL_VISIBLE message_format : public base_message_format<CharType> {
    public:
        typedef CharType char_type;
        typedef std::basic_string<CharType> string_type;

        message_format(size_t refs = 0) : base_message_format<CharType>(refs) {}

        virtual const char_type* get(int domain_id, const char_type* context, const char_type* id) const = 0;

        virtual const char_type*
        get(int domain_id, const char_type* context, const char_type* single_id, int n) const = 0;

        virtual int domain(const std::string& domain) const = 0;

        virtual const char_type* convert(const char_type* msg, string_type& buffer) const = 0;

    protected:
        virtual ~message_format() = default;
    };


    namespace detail {
        inline bool is_us_ascii_char(char c)
        {
            // works for null terminated strings regardless char "signedness"
            return 0 < c && c < 0x7F;
        }
        inline bool is_us_ascii_string(const char* msg)
        {
            while(*msg) {
                if(!is_us_ascii_char(*msg++))
                    return false;
            }
            return true;
        }

        template<typename CharType>
        struct string_cast_traits {
            static const CharType* cast(const CharType* msg, std::basic_string<CharType>& /*unused*/) { return msg; }
        };

        template<>
        struct string_cast_traits<char> {
            static const char* cast(const char* msg, std::string& buffer)
            {
                if(is_us_ascii_string(msg))
                    return msg;
                buffer.reserve(strlen(msg));
                char c;
                while((c = *msg++) != 0) {
                    if(is_us_ascii_char(c))
                        buffer += c;
                }
                return buffer.c_str();
            }
        };
    } // namespace detail


    template<typename CharType>
    class basic_message {
    public:
        typedef CharType char_type;                       
        typedef std::basic_string<char_type> string_type; 
        typedef message_format<char_type> facet_type;     

        basic_message() : n_(0), c_id_(0), c_context_(0), c_plural_(0) {}

        explicit basic_message(const char_type* id) : n_(0), c_id_(id), c_context_(0), c_plural_(0) {}

        explicit basic_message(const char_type* single, const char_type* plural, int n) :
            n_(n), c_id_(single), c_context_(0), c_plural_(plural)
        {}

        explicit basic_message(const char_type* context, const char_type* id) :
            n_(0), c_id_(id), c_context_(context), c_plural_(0)
        {}

        explicit basic_message(const char_type* context, const char_type* single, const char_type* plural, int n) :
            n_(n), c_id_(single), c_context_(context), c_plural_(plural)
        {}

        explicit basic_message(const string_type& id) : n_(0), c_id_(0), c_context_(0), c_plural_(0), id_(id) {}

        explicit basic_message(const string_type& single, const string_type& plural, int number) :
            n_(number), c_id_(0), c_context_(0), c_plural_(0), id_(single), plural_(plural)
        {}

        explicit basic_message(const string_type& context, const string_type& id) :
            n_(0), c_id_(0), c_context_(0), c_plural_(0), id_(id), context_(context)
        {}

        explicit basic_message(const string_type& context,
                               const string_type& single,
                               const string_type& plural,
                               int number) :
            n_(number),
            c_id_(0), c_context_(0), c_plural_(0), id_(single), context_(context), plural_(plural)
        {}

        basic_message(const basic_message& other) = default;
        basic_message(basic_message&& other) = default;

        basic_message& operator=(const basic_message& other) = default;
        basic_message& operator=(basic_message&& other) = default;

        void swap(basic_message& other)
        {
            std::swap(n_, other.n_);
            std::swap(c_id_, other.c_id_);
            std::swap(c_context_, other.c_context_);
            std::swap(c_plural_, other.c_plural_);

            id_.swap(other.id_);
            context_.swap(other.context_);
            plural_.swap(other.plural_);
        }

        operator string_type() const { return str(); }

        string_type str() const
        {
            std::locale loc;
            return str(loc, 0);
        }

        string_type str(const std::locale& locale) const { return str(locale, 0); }

        string_type str(const std::locale& locale, const std::string& domain_id) const
        {
            int id = 0;
            if(std::has_facet<facet_type>(locale))
                id = std::use_facet<facet_type>(locale).domain(domain_id);
            return str(locale, id);
        }

        string_type str(const std::string& domain_id) const
        {
            int id = 0;
            std::locale loc;
            if(std::has_facet<facet_type>(loc))
                id = std::use_facet<facet_type>(loc).domain(domain_id);
            return str(loc, id);
        }

        string_type str(const std::locale& loc, int id) const
        {
            string_type buffer;
            const char_type* ptr = write(loc, id, buffer);
            if(ptr == buffer.c_str())
                return buffer;
            else
                buffer = ptr;
            return buffer;
        }

        void write(std::basic_ostream<char_type>& out) const
        {
            const std::locale& loc = out.getloc();
            int id = ios_info::get(out).domain_id();
            string_type buffer;
            out << write(loc, id, buffer);
        }

    private:
        const char_type* plural() const
        {
            if(c_plural_)
                return c_plural_;
            if(plural_.empty())
                return 0;
            return plural_.c_str();
        }
        const char_type* context() const
        {
            if(c_context_)
                return c_context_;
            if(context_.empty())
                return 0;
            return context_.c_str();
        }

        const char_type* id() const { return c_id_ ? c_id_ : id_.c_str(); }

        const char_type* write(const std::locale& loc, int domain_id, string_type& buffer) const
        {
            const char_type* translated = 0;
            static const char_type empty_string[1] = {0};

            const char_type* id = this->id();
            const char_type* context = this->context();
            const char_type* plural = this->plural();

            if(*id == 0)
                return empty_string;

            const facet_type* facet = 0;
            if(std::has_facet<facet_type>(loc))
                facet = &std::use_facet<facet_type>(loc);

            if(facet) {
                if(!plural) {
                    translated = facet->get(domain_id, context, id);
                } else {
                    translated = facet->get(domain_id, context, id, n_);
                }
            }

            if(!translated) {
                const char_type* msg = plural ? (n_ == 1 ? id : plural) : id;

                if(facet) {
                    translated = facet->convert(msg, buffer);
                } else {
                    translated = detail::string_cast_traits<char_type>::cast(msg, buffer);
                }
            }
            return translated;
        }


        int n_;
        const char_type* c_id_;
        const char_type* c_context_;
        const char_type* c_plural_;
        string_type id_;
        string_type context_;
        string_type plural_;
    };

    typedef basic_message<char> message;
    typedef basic_message<wchar_t> wmessage;
#ifdef BOOST_LOCALE_ENABLE_CHAR16_T
    typedef basic_message<char16_t> u16message;
#endif
#ifdef BOOST_LOCALE_ENABLE_CHAR32_T
    typedef basic_message<char32_t> u32message;
#endif

    template<typename CharType>
    std::basic_ostream<CharType>& operator<<(std::basic_ostream<CharType>& out, const basic_message<CharType>& msg)
    {
        msg.write(out);
        return out;
    }


    template<typename CharType>
    inline basic_message<CharType> translate(const CharType* msg)
    {
        return basic_message<CharType>(msg);
    }

    template<typename CharType>
    inline basic_message<CharType> translate(const CharType* context, const CharType* msg)
    {
        return basic_message<CharType>(context, msg);
    }

    template<typename CharType>
    inline basic_message<CharType> translate(const CharType* single, const CharType* plural, int n)
    {
        return basic_message<CharType>(single, plural, n);
    }

    template<typename CharType>
    inline basic_message<CharType>
    translate(const CharType* context, const CharType* single, const CharType* plural, int n)
    {
        return basic_message<CharType>(context, single, plural, n);
    }

    template<typename CharType>
    inline basic_message<CharType> translate(const std::basic_string<CharType>& msg)
    {
        return basic_message<CharType>(msg);
    }

    template<typename CharType>
    inline basic_message<CharType> translate(const std::basic_string<CharType>& context,
                                             const std::basic_string<CharType>& msg)
    {
        return basic_message<CharType>(context, msg);
    }

    template<typename CharType>
    inline basic_message<CharType> translate(const std::basic_string<CharType>& context,
                                             const std::basic_string<CharType>& single,
                                             const std::basic_string<CharType>& plural,
                                             int n)
    {
        return basic_message<CharType>(context, single, plural, n);
    }

    template<typename CharType>
    inline basic_message<CharType>
    translate(const std::basic_string<CharType>& single, const std::basic_string<CharType>& plural, int n)
    {
        return basic_message<CharType>(single, plural, n);
    }



    template<typename CharType>
    std::basic_string<CharType> gettext(const CharType* id, const std::locale& loc = std::locale())
    {
        return basic_message<CharType>(id).str(loc);
    }
    template<typename CharType>
    std::basic_string<CharType>
    ngettext(const CharType* s, const CharType* p, int n, const std::locale& loc = std::locale())
    {
        return basic_message<CharType>(s, p, n).str(loc);
    }

    template<typename CharType>
    std::basic_string<CharType> dgettext(const char* domain, const CharType* id, const std::locale& loc = std::locale())
    {
        return basic_message<CharType>(id).str(loc, domain);
    }

    template<typename CharType>
    std::basic_string<CharType>
    dngettext(const char* domain, const CharType* s, const CharType* p, int n, const std::locale& loc = std::locale())
    {
        return basic_message<CharType>(s, p, n).str(loc, domain);
    }

    template<typename CharType>
    std::basic_string<CharType>
    pgettext(const CharType* context, const CharType* id, const std::locale& loc = std::locale())
    {
        return basic_message<CharType>(context, id).str(loc);
    }

    template<typename CharType>
    std::basic_string<CharType> npgettext(const CharType* context,
                                          const CharType* s,
                                          const CharType* p,
                                          int n,
                                          const std::locale& loc = std::locale())
    {
        return basic_message<CharType>(context, s, p, n).str(loc);
    }

    template<typename CharType>
    std::basic_string<CharType>
    dpgettext(const char* domain, const CharType* context, const CharType* id, const std::locale& loc = std::locale())
    {
        return basic_message<CharType>(context, id).str(loc, domain);
    }

    template<typename CharType>
    std::basic_string<CharType> dnpgettext(const char* domain,
                                           const CharType* context,
                                           const CharType* s,
                                           const CharType* p,
                                           int n,
                                           const std::locale& loc = std::locale())
    {
        return basic_message<CharType>(context, s, p, n).str(loc, domain);
    }


    template<>
    struct BOOST_LOCALE_DECL base_message_format<char> : public std::locale::facet {
        base_message_format(size_t refs = 0) : std::locale::facet(refs) {}
        ~base_message_format();
        static std::locale::id id;
    };

    template<>
    struct BOOST_LOCALE_DECL base_message_format<wchar_t> : public std::locale::facet {
        base_message_format(size_t refs = 0) : std::locale::facet(refs) {}
        ~base_message_format();
        static std::locale::id id;
    };

#ifdef BOOST_LOCALE_ENABLE_CHAR16_T

    template<>
    struct BOOST_LOCALE_DECL base_message_format<char16_t> : public std::locale::facet {
        base_message_format(size_t refs = 0) : std::locale::facet(refs) {}
        ~base_message_format();
        static std::locale::id id;
    };

#endif

#ifdef BOOST_LOCALE_ENABLE_CHAR32_T

    template<>
    struct BOOST_LOCALE_DECL base_message_format<char32_t> : public std::locale::facet {
        base_message_format(size_t refs = 0) : std::locale::facet(refs) {}
        ~base_message_format();
        static std::locale::id id;
    };

#endif


    namespace as {
        namespace detail {
            struct set_domain {
                std::string domain_id;
            };
            template<typename CharType>
            std::basic_ostream<CharType>& operator<<(std::basic_ostream<CharType>& out, const set_domain& dom)
            {
                int id = std::use_facet<message_format<CharType>>(out.getloc()).domain(dom.domain_id);
                ios_info::get(out).domain_id(id);
                return out;
            }
        } // namespace detail


        inline
#ifdef BOOST_LOCALE_DOXYGEN
          unspecified_type
#else
          detail::set_domain
#endif
          domain(const std::string& id)
        {
            detail::set_domain tmp = {id};
            return tmp;
        }
    } // namespace as
}}    // namespace boost::locale

#ifdef BOOST_MSVC
#    pragma warning(pop)
#endif

#endif