format.hpp

//
// Copyright (c) 2009-2011 Artyom Beilis (Tonkikh)
// Copyright (c) 2021-2023 Alexander Grund
//
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
 
#ifndef BOOST_LOCALE_FORMAT_HPP_INCLUDED
#define BOOST_LOCALE_FORMAT_HPP_INCLUDED
 
#include <boost/locale/formatting.hpp>
#include <boost/locale/hold_ptr.hpp>
#include <boost/locale/message.hpp>
#include <sstream>
#include <stdexcept>
#include <string>
#include <vector>
 
#ifdef BOOST_MSVC
#    pragma warning(push)
#    pragma warning(disable : 4275 4251 4231 4660)
#endif
 
namespace boost { namespace locale {
 
 
    namespace detail {
 
        template<typename CharType>
        struct formattible {
            typedef std::basic_ostream<CharType> stream_type;
            typedef void (*writer_type)(stream_type& output, const void* ptr);
 
            formattible() noexcept : pointer_(nullptr), writer_(&formattible::void_write) {}
 
            formattible(const formattible&) noexcept = default;
            formattible(formattible&&) noexcept = default;
            formattible& operator=(const formattible&) noexcept = default;
            formattible& operator=(formattible&&) noexcept = default;
 
            template<typename Type>
            explicit formattible(const Type& value) noexcept
            {
                pointer_ = static_cast<const void*>(&value);
                writer_ = &write<Type>;
            }
 
            friend stream_type& operator<<(stream_type& out, const formattible& fmt)
            {
                fmt.writer_(out, fmt.pointer_);
                return out;
            }
 
        private:
            static void void_write(stream_type& output, const void* /*ptr*/)
            {
                CharType empty_string[1] = {0};
                output << empty_string;
            }
 
            template<typename Type>
            static void write(stream_type& output, const void* ptr)
            {
                output << *static_cast<const Type*>(ptr);
            }
 
            const void* pointer_;
            writer_type writer_;
        }; // formattible
 
        class BOOST_LOCALE_DECL format_parser {
        public:
            format_parser(std::ios_base& ios, void*, void (*imbuer)(void*, const std::locale&));
            ~format_parser();
            format_parser(const format_parser&) = delete;
            format_parser& operator=(const format_parser&) = delete;
 
            unsigned get_position();
 
            void set_one_flag(const std::string& key, const std::string& value);
 
            template<typename CharType>
            void set_flag_with_str(const std::string& key, const std::basic_string<CharType>& value)
            {
                if(key == "ftime" || key == "strftime") {
                    as::strftime(ios_);
                    ios_info::get(ios_).date_time_pattern(value);
                }
            }
            void restore();
 
        private:
            void imbue(const std::locale&);
 
            std::ios_base& ios_;
            struct data;
            hold_ptr<data> d;
        };
 
    } // namespace detail
 
 
    template<typename CharType>
    class basic_format {
        int throw_if_params_bound() const;
 
    public:
        typedef CharType char_type;                    
        typedef basic_message<char_type> message_type; 
        typedef detail::formattible<CharType> formattible_type;
 
        typedef std::basic_string<CharType> string_type;  
        typedef std::basic_ostream<CharType> stream_type; 
 
        basic_format(const string_type& format_string) : format_(format_string), translate_(false), parameters_count_(0)
        {}
        basic_format(const message_type& trans) : message_(trans), translate_(true), parameters_count_(0) {}
 
        basic_format(const basic_format& other) = delete;
        void operator=(const basic_format& other) = delete;
        basic_format(basic_format&& other) :
            message_((other.throw_if_params_bound(), std::move(other.message_))), format_(std::move(other.format_)),
            translate_(other.translate_), parameters_count_(0)
        {}
        basic_format& operator=(basic_format&& other)
        {
            other.throw_if_params_bound();
            message_ = std::move(other.message_);
            format_ = std::move(other.format_);
            translate_ = other.translate_;
            parameters_count_ = 0;
            ext_params_.clear();
            return *this;
        }
 
        template<typename Formattible>
        basic_format& operator%(const Formattible& object)
        {
            add(formattible_type(object));
            return *this;
        }
 
        string_type str(const std::locale& loc = std::locale()) const
        {
            std::basic_ostringstream<CharType> buffer;
            buffer.imbue(loc);
            write(buffer);
            return buffer.str();
        }
 
        void write(stream_type& out) const
        {
            string_type format;
            if(translate_)
                format = message_.str(out.getloc(), ios_info::get(out).domain_id());
            else
                format = format_;
 
            format_output(out, format);
        }
 
    private:
        class format_guard {
        public:
            format_guard(detail::format_parser& fmt) : fmt_(fmt), restored_(false) {}
            void restore()
            {
                if(restored_)
                    return;
                fmt_.restore();
                restored_ = true;
            }
            ~format_guard()
            {
                // clang-format off
                try { restore(); } catch(...) {}
                // clang-format on
            }
 
        private:
            detail::format_parser& fmt_;
            bool restored_;
        };
 
        void format_output(stream_type& out, const string_type& sformat) const
        {
            constexpr char_type obrk = '{';
            constexpr char_type cbrk = '}';
            constexpr char_type eq = '=';
            constexpr char_type comma = ',';
            constexpr char_type quote = '\'';
 
            const size_t size = sformat.size();
            const CharType* format = sformat.c_str();
            for(size_t pos = 0; format[pos];) {
                if(format[pos] != obrk) {
                    if(format[pos] == cbrk && format[pos + 1] == cbrk) {
                        // Escaped closing brace
                        out << cbrk;
                        pos += 2;
                    } else {
                        out << format[pos];
                        pos++;
                    }
                    continue;
                }
                pos++;
                if(format[pos] == obrk) {
                    // Escaped opening brace
                    out << obrk;
                    pos++;
                    continue;
                }
 
                detail::format_parser fmt(out, static_cast<void*>(&out), &basic_format::imbue_locale);
 
                format_guard guard(fmt);
 
                while(pos < size) {
                    std::string key;
                    std::string svalue;
                    string_type value;
                    bool use_svalue = true;
                    for(char_type c = format[pos]; !(c == 0 || c == comma || c == eq || c == cbrk); c = format[++pos]) {
                        key += static_cast<char>(c);
                    }
 
                    if(format[pos] == eq) {
                        pos++;
                        if(format[pos] == quote) {
                            pos++;
                            use_svalue = false;
                            while(format[pos]) {
                                if(format[pos] == quote) {
                                    if(format[pos + 1] == quote) {
                                        value += quote;
                                        pos += 2;
                                    } else {
                                        pos++;
                                        break;
                                    }
                                } else {
                                    value += format[pos];
                                    pos++;
                                }
                            }
                        } else {
                            char_type c;
                            while((c = format[pos]) != 0 && c != comma && c != cbrk) {
                                svalue += static_cast<char>(c);
                                pos++;
                            }
                        }
                    }
 
                    if(use_svalue)
                        fmt.set_one_flag(key, svalue);
                    else
                        fmt.set_flag_with_str(key, value);
 
                    if(format[pos] == comma)
                        pos++;
                    else {
                        if(format[pos] == cbrk) {
                            unsigned position = fmt.get_position();
                            out << get(position);
                            pos++;
                        }
                        break;
                    }
                }
            }
        }
 
        void add(const formattible_type& param)
        {
            if(parameters_count_ >= base_params_)
                ext_params_.push_back(param);
            else
                parameters_[parameters_count_] = param;
            parameters_count_++;
        }
 
        formattible_type get(unsigned id) const
        {
            if(id >= parameters_count_)
                return formattible_type();
            else if(id >= base_params_)
                return ext_params_[id - base_params_];
            else
                return parameters_[id];
        }
 
        static void imbue_locale(void* ptr, const std::locale& l) { static_cast<stream_type*>(ptr)->imbue(l); }
 
        static constexpr unsigned base_params_ = 8;
 
        message_type message_;
        string_type format_;
        bool translate_;
 
        formattible_type parameters_[base_params_];
        unsigned parameters_count_;
        std::vector<formattible_type> ext_params_;
    };
 
    template<typename CharType>
    std::basic_ostream<CharType>& operator<<(std::basic_ostream<CharType>& out, const basic_format<CharType>& fmt)
    {
        fmt.write(out);
        return out;
    }
 
    typedef basic_format<char> format;
    typedef basic_format<wchar_t> wformat;
#ifndef BOOST_LOCALE_NO_CXX20_STRING8
    typedef basic_format<char8_t> u8format;
#endif
 
#ifdef BOOST_LOCALE_ENABLE_CHAR16_T
    typedef basic_format<char16_t> u16format;
#endif
 
#ifdef BOOST_LOCALE_ENABLE_CHAR32_T
    typedef basic_format<char32_t> u32format;
#endif
 
    template<typename CharType>
    int basic_format<CharType>::throw_if_params_bound() const
    {
        if(parameters_count_)
            throw std::invalid_argument("Can't move a basic_format with bound parameters");
        return 0;
    }
}} // namespace boost::locale
 
#ifdef BOOST_MSVC
#    pragma warning(pop)
#endif
 
 
#endif