src/base/features/output.hpp

#pragma once

#include"base/dependencies/index.hpp"

#include"attributes.hpp"
#include"characters.hpp"
#include"containers.hpp"
#include"integers.hpp"
#include"shortcuts.hpp"

// Write the given arguments in order to the given output stream.
template<class...Types>
ostream&write(ostream&os,Types const&...args){return(os<<...<<args);}

// Pair output overload.
template<class Fst,class Snd>
ostream&operator<<(ostream&os,pair<Fst,Snd>const&p){
    return os<<p.first<<sp<<p.second;
}

// Tuple output overload.
template<class...Types>ostream&operator<<(ostream&os,tuple<Types...>const&t){
    apply([&os](Types const&...args){
        size_t rem=sizeof...(Types);
        ((os<<args<<(--rem?" ":"")),...);
    },t);
    return os;
}

// Printable wrapper for generic containers.
template<class Container,char Sep>struct printable{
    // Wrap the container in a printable structure.
    printable(Container const&_c):c(_c){}
    // Container wrapper output overload.
    friend ostream&operator<<(ostream&os,printable const&w){
        s32 rem=SIZE(w.c);
        FORE(e,w.c){
            os<<e;
            if(--rem)LIKELY{os<<Sep;}
        }
        return os;
    }
private:
    // Wrapped container.
    Container const&c;
};

// Horizontal printable wrapper for containers.
template<class Container>
printable<Container,sp>horizontal(Container const&c){return c;}

// Vertical printable wrapper for containers.
template<class Container>
printable<Container,lf>vertical(Container const&c){return c;}

// Array output overload.
template<class Type,size_t Size>
ostream&operator<<(ostream&os,array<Type,Size>const&a){
    return os<<horizontal(a);
}

// Valarray output overload.
template<class Type>ostream&operator<<(ostream&os,valarray<Type>const&va){
    return os<<horizontal(va);
}

// Vector output overload.
template<class Type>
ostream&operator<<(ostream&os,vector<Type>const&v){return os<<horizontal(v);}

// Deque output overload.
template<class Type>
ostream&operator<<(ostream&os,deque<Type>const&d){return os<<horizontal(d);}

// Set output overload.
template<class Key,class Comp>
ostream&operator<<(ostream&os,set<Key,Comp>const&s){return os<<horizontal(s);}

// Unordered set output overload.
template<class Key,class Hash>
ostream&operator<<(ostream&os,uset<Key,Hash>const&us){
    return os<<horizontal(us);
}

// Map output overload.
template<class Key,class Val,class Comp>
ostream&operator<<(ostream&os,map<Key,Val,Comp>const&m){
    return os<<vertical(m);
}

// Unordered map output overload.
template<class Key,class Val,class Hash>
ostream&operator<<(ostream&os,umap<Key,Val,Hash>const&um){
    return os<<vertical(um);
}

// Indexable red-black tree output overload.
template<class Key,class Val,class Comp>
ostream&operator<<(ostream&os,rbtree<Key,Val,Comp>const&rb){
    if constexpr(is_same_v<Val,PBDS::null_type>){return os<<horizontal(rb);}
    return os<<vertical(rb);
}

// Hash table output overload.
template<class Key,class Val,class Hash>
ostream&operator<<(ostream&os,htable<Key,Val,Hash>const&ht){
    if constexpr(is_same_v<Val,PBDS::null_type>){return os<<horizontal(ht);}
    return os<<vertical(ht);
}