iomanip.hpp

Go to the documentation of this file.

/*
    Copyright 2013 Adobe
    Distributed under the Boost Software License, Version 1.0.
    (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
*/
/**************************************************************************************************/
 
#ifdef ADOBE_STD_SERIALIZATION
 
/**************************************************************************************************/
 
#ifndef ADOBE_IOMANIP_HPP
#define ADOBE_IOMANIP_HPP
 
/**************************************************************************************************/
 
#include <adobe/config.hpp>
 
#include <adobe/iomanip_fwd.hpp>
 
#include <cassert>
#include <functional>
#include <iosfwd>
#include <list>
#include <sstream>
#include <stdexcept>
#include <string>
 
#include <boost/next_prior.hpp>
 
#include <adobe/manip.hpp>
#include <adobe/name.hpp>
#include <adobe/serializable.hpp>
 
 
 
/**************************************************************************************************/
 
namespace adobe {
 
/**************************************************************************************************/
 
namespace implementation {
 
/**************************************************************************************************/
 
} // namespace implementation
 
/**************************************************************************************************/
 
static const static_name_t bag_name_g = "bag"_name;
static const static_name_t seq_name_g = "seq"_name;
static const static_name_t alt_name_g = "alt"_name;
static const static_name_t atom_name_g = "atom"_name;
 
/**************************************************************************************************/


class format_element_t {
public:
    explicit format_element_t(name_t tag = name_t(), const std::string& ident = std::string())
        : ident_m(ident), num_out_m(0), tag_m(tag), value_m(0) {}
 
    format_element_t(name_t tag, const serializable_t& value)
        : num_out_m(0), tag_m(tag), value_m(&value) {}
 
    name_t tag() const { return tag_m; }
 
    const serializable_t& value() const {
        if (!value_m)
            throw std::runtime_error("invalid value");
 
        return *value_m;
    }
 
    std::string ident_m;
    std::size_t num_out_m;
 
private:
    name_t tag_m;
    const serializable_t* value_m;
};
 
/**************************************************************************************************/

class format_base {
public:
    typedef std::ostream stream_type;
    typedef format_element_t stack_value_type;
    typedef std::list<stack_value_type> stack_type;
 
    virtual ~format_base() {}
 
    virtual void begin_format(stream_type& os) { push_stack(os); }
    virtual void end_format(stream_type& os) { pop_stack(os); }
 
    virtual void begin_bag(stream_type& os, const std::string&) { push_stack(os); }
    virtual void end_bag(stream_type& os) { pop_stack(os); }
 
    virtual void begin_sequence(stream_type& os) { push_stack(os); }
    virtual void end_sequence(stream_type& os) { pop_stack(os); }
 
    virtual void begin_alternate(stream_type& os) { push_stack(os); }
    virtual void end_alternate(stream_type& os) { pop_stack(os); }
 
    virtual void begin_atom(stream_type& os, const serializable_t&) { push_stack(os); }
    virtual void end_atom(stream_type& os) { pop_stack(os); }
 
    format_base() : depth_m(0) {}
 
    virtual std::size_t depth() { return depth_m; }
 
    virtual std::size_t stack_depth() { return stack_m.size(); }
 
protected:
    void push_stack(stream_type& os, const stack_value_type& element = format_element_t()) {
        stack_m.push_front(element);
        stack_event(os, true);
    }
 
    void pop_stack(stream_type& os) {
        assert(stack_m.empty() == false);
        stack_event(os, false);
        stack_m.pop_front();
    }
 
    const stack_value_type& stack_top() const { return stack_n(0); }
 
    stack_value_type& stack_top() { return stack_n(0); }
 
    const stack_value_type& stack_n(std::size_t n) const {
        if (n >= stack_m.size()) {
            std::stringstream buf;
            buf << "stack_n: n(" << static_cast<unsigned int>(n) << ") > size("
                << static_cast<unsigned int>(stack_m.size()) << ").";
            throw std::range_error(buf.str());
        }
 
        return *boost::next(stack_m.begin(), n);
    }
 
    stack_value_type& stack_n(std::size_t n) {
        if (n >= stack_m.size()) {
            std::stringstream buf;
            buf << "stack_n: n(" << static_cast<unsigned int>(n) << ") > size("
                << static_cast<unsigned int>(stack_m.size()) << ").";
            throw std::range_error(buf.str());
        }
 
        return *boost::next(stack_m.begin(), n);
    }
 
    void up() { ++depth_m; }
 
    void down() {
        std::size_t temp = (std::max)(std::size_t(0), --depth_m);
        depth_m = temp; // use temp to suppress gcc-4.5.0 warning/error
    }
 
private:
    virtual void stack_event(stream_type& os, bool is_push) = 0;
 
    std::size_t depth_m; // note: Visual "depth", NOT the depth of the stack
    stack_type stack_m;
};
 
/**************************************************************************************************/
 
format_base::stream_type& begin_format(format_base::stream_type& os);
format_base::stream_type& end_format(format_base::stream_type& os);
 
format_base::stream_type& end_bag(format_base::stream_type& os);
 
format_base::stream_type& begin_sequence(format_base::stream_type& os);
format_base::stream_type& end_sequence(format_base::stream_type& os);
 
format_base::stream_type& begin_alternate(format_base::stream_type& os);
format_base::stream_type& end_alternate(format_base::stream_type& os);
 
format_base::stream_type& end_atom(format_base::stream_type& os);
 
/**************************************************************************************************/

class indents : public basic_omanipulator<std::size_t, char, std::char_traits<char>> {
    typedef basic_omanipulator<std::size_t, char, std::char_traits<char>> inherited_t;
 
public:
    typedef inherited_t::stream_type stream_type;
    typedef inherited_t::argument_type argument_type;
 
    indents(argument_type num) : inherited_t(indents::fct, num) {}
 
    inherited_t& operator()(argument_type i) {
        arg_m = i;
        return *this;
    }
 
private:
    static stream_type& fct(stream_type& os, const argument_type& i) {
        for (argument_type count(0); count < i; ++count)
            os.put('\t');
 
        return os;
    }
};
 
/**************************************************************************************************/

class begin_bag : public basic_omanipulator<std::string, char, std::char_traits<char>> {
    typedef basic_omanipulator<std::string, char, std::char_traits<char>> inherited_t;
 
public:
    typedef inherited_t::stream_type stream_type;
    typedef inherited_t::argument_type argument_type;
 
    begin_bag(const argument_type& index) : inherited_t(begin_bag::fct, index) {}
 
    inherited_t& operator()(argument_type /*i*/) { return *this; }
 
private:
    static stream_type& fct(stream_type& os, const argument_type& i) {
        format_base* format(get_formatter(os));
 
        if (format)
            format->begin_bag(os, i);
 
        return os;
    }
};
 
/**************************************************************************************************/

template <typename T>
class begin_atom : public basic_omanipulator<const serializable_t, char, std::char_traits<char>> {
    typedef basic_omanipulator<const serializable_t, char, std::char_traits<char>> inherited_t;
 
public:
    typedef inherited_t::stream_type stream_type;
    typedef inherited_t::argument_type argument_type;
 
    explicit begin_atom(const T& x) : inherited_t(begin_atom::fct, serializable_t(x)) {}
 
    inherited_t& operator()(argument_type /*i*/) { return *this; }
 
private:
    static stream_type& fct(stream_type& os, const argument_type& atom) {
        format_base* format(get_formatter(os));
 
        if (format)
            format->begin_atom(os, atom);
        else
            os << atom;
 
        return os;
    }
};
 
/**************************************************************************************************/

template <typename T, class charT, class traits>
std::basic_ostream<charT, traits>& operator<<(std::basic_ostream<charT, traits>& os,
                                              const begin_atom<T>& manip) {
    if (os.good())
        manip.do_manip(os);
 
    return os;
}
 
/**************************************************************************************************/

template <typename NewFormat>
void callback(std::ios_base::event ev, std::ios_base& strm, int idx) {
    if (ev == std::ios_base::erase_event) {
        try {
            delete static_cast<NewFormat*>(strm.pword(idx));
 
            strm.pword(idx) = 0;
        } catch (...) {
        }
    } else if (ev == std::ios_base::copyfmt_event) {
        NewFormat* old(static_cast<NewFormat*>(strm.pword(idx)));
 
        if (old != 0) {
            try {
                strm.pword(idx) = new NewFormat(*old);
            } catch (std::bad_alloc&) {
            }
        }
    }
}
 
/**************************************************************************************************/

template <typename OldFormat, typename NewFormat>
void replace_pword(std::ios_base& iob, int idx) {
    iob.register_callback(callback<NewFormat>, idx);
 
    NewFormat* new_format(new NewFormat());
    OldFormat* old_format(static_cast<OldFormat*>(iob.pword(idx)));
    iob.pword(idx) = new_format;
    delete old_format;
}
 
/**************************************************************************************************/

template <typename OldFormat, typename NewFormat, typename T>
void replace_pword(std::ios_base& iob, int idx, const T& x) {
    iob.register_callback(callback<NewFormat>, idx);
 
    NewFormat* new_format(new NewFormat(x));
    OldFormat* old_format(static_cast<OldFormat*>(iob.pword(idx)));
    iob.pword(idx) = new_format;
    delete old_format;
}
 
/**************************************************************************************************/

template <class T>
std::ostream& fmt(std::ostream& os, const T& t) {
    os << begin_atom<T>(t) << end_atom;
 
    return os;
}
 
/**************************************************************************************************/

template <class T>
class basic_format : public basic_omanipulator<T, char, std::char_traits<char>> {
    typedef basic_omanipulator<T, char, std::char_traits<char>> inherited_t;
 
public:
    typedef typename inherited_t::stream_type stream_type;
    typedef typename inherited_t::argument_type argument_type;
 
    basic_format(const argument_type& t) : inherited_t(fmt<T>, t) {}
 
    inherited_t& operator()(const argument_type& /*i*/) { return *this; }
};
 
/**************************************************************************************************/

template <class T>
inline basic_format<T> format(const T& t) {
    return basic_format<T>(t);
}
 
/**************************************************************************************************/
 
} // namespace adobe
 
/**************************************************************************************************/
 
#endif
 
/**************************************************************************************************/
 
#endif
 
/**************************************************************************************************/