stdpp.h

Go to the documentation of this file.

#ifndef TAG_STDPP_H
#define TAG_STDPP_H

#include <iostream>
#include <utility>

namespace tag {


#ifndef DOXYGEN_IGNORE_INTERNAL

static struct noendl_s {} noendl;

template <class T> struct NotFirst {
    inline NotFirst(T & d) : data(d), last(true) {}
    inline ~NotFirst() { if(last) data << std::endl; }
    T & data;
    bool last;
    
    template <class S>
    inline NotFirst<T> & operator,( const S & arg ){
        data << data.fill() << arg;
        return *this;
    }

    inline T & operator,(T & (*modifier)(T &)){
        data << modifier;
        last = false;
        return data;
    }

    inline NotFirst<T> & operator,( noendl_s & arg ){
        last = false;
        return *this;
    }
};

template <class T, class Char, class Traits> 
inline NotFirst<std::basic_ostream<Char,Traits> > operator,(std::basic_ostream<Char,Traits>  & stream, const T & arg ){
    stream << arg;
    return NotFirst<std::basic_ostream<Char,Traits> >(stream);
}

template <class Char, class Traits>
inline std::basic_ostream<Char,Traits> & operator,(std::basic_ostream<Char,Traits>  & stream, std::basic_ostream<Char,Traits> & (*modifier)(std::basic_ostream<Char,Traits> &)){
    stream << modifier;
    return stream;
}

template <class Char, class Traits>
inline std::basic_ostream<Char,Traits> & operator,(std::basic_ostream<Char,Traits>  & stream, noendl_s & arg ){
    return stream;
}

namespace Internal
{

    struct add_fill_s{};
    struct like_print_s{};
    struct no_space_s{};

    template<class S> struct add_fill_bound
    {
        add_fill_bound(S& os)
        :o(os),first(1) {}


        template<class C> add_fill_bound& operator<<(const C& c)
        {
                if(first == true)
                    first=false;
                else
                    o << o.fill();

                o << c;
                return *this;
        }

        add_fill_bound& operator<<(const no_space_s&)
        {
            first=true;
            return *this;
        }

        add_fill_bound& operator<<(S& (*fptr)(S&) )
        {
                o << fptr;

                if(fptr == static_cast<S&(*)(S&)>(std::endl))
                    first=true;

                return *this;
        }

        private:
            S& o;
            bool first;
    };


    template<class S> struct like_print_bound:public add_fill_bound<S>
    {
        like_print_bound(S&os)
        :add_fill_bound<S>(os)
        {
        }

        ~like_print_bound()
        {
            add_fill_bound<S>::operator<<(std::endl);
        }
    };

}

#endif

static struct Internal::add_fill_s add_fill;

static struct Internal::like_print_s print;

static struct Internal::no_space_s no_space;

#ifndef DOXYGEN_IGNORE_INTERNAL

template<class Char, class Traits> Internal::add_fill_bound<std::basic_ostream<Char,Traits> > operator<<(std::basic_ostream<Char,Traits>& o, const Internal::add_fill_s&)
{
        return Internal::add_fill_bound<std::basic_ostream<Char,Traits> >(o);
}

template<class Char, class Traits> Internal::like_print_bound<std::basic_ostream<Char,Traits> > operator<<(std::basic_ostream<Char,Traits>& o, const Internal::like_print_s&)
{
        return Internal::like_print_bound<std::basic_ostream<Char,Traits> >(o);
}

#endif

#ifndef DOXYGEN_IGNORE_INTERNAL
namespace Internal
{
    template<class A, class B> struct refpair
    {
        A& a;
        B& b;
        refpair(A& aa, B& bb)
        :a(aa),b(bb)
        {}

        void operator=(const std::pair<A,B>& p)
        {
            a=p.first;
            b=p.second;
        }
    };
}

#endif

template<class A, class B> Internal::refpair<A,B> rpair(A&aa, B&bb)
{
    return Internal::refpair<A,B>(aa, bb);
}



} // namespace tag

#endif // __PRINT_H_