Printing.hpp

Go to the documentation of this file.

// <Printing.hpp> -*- C++ -*-
 
 
#pragma once
 
#include <iostream>
#include <string>
#include <ostream>
#include <vector>
#include <sstream>
 
#include "sparta/utils/SpartaException.hpp"
 
namespace sparta
{
namespace utils
{
 
    enum DisplayBase {
        BASE_DEC = 0, 
        BASE_HEX = 1, 
        BASE_OCT = 2  
    };
 
    inline std::ios_base::fmtflags setIOSFlags(std::ios_base& stream, DisplayBase base) {
        std::ios_base::fmtflags f;
        switch(base){
        case BASE_DEC:
            f = stream.setf(std::ios::dec, std::ios::basefield);
            break;
        case BASE_HEX:
            f = stream.setf(std::ios::hex, std::ios::basefield);
            break;
        case BASE_OCT:
            f = stream.setf(std::ios::oct, std::ios::basefield);
            break;
        default:
            SpartaException ex("Unsupported SPARTA display flag: ");
            ex << base;
            throw ex;
        };
        stream.setf(std::ios::showbase | std::ios::boolalpha);
        return f;
    }
 
    template <class T>
    inline std::string stringize_value(const std::vector<T>& v, DisplayBase base=BASE_DEC,
                                       const std::string& string_quote="") {
        std::stringstream out;
        out << "[";
        typename std::vector<T>::const_iterator itr = v.begin();
        if(itr != v.end()){
            std::ios_base::fmtflags old = setIOSFlags(out, base);
            out << stringize_value((T)(*itr++), base, string_quote);
            out.setf(old);
            for(; itr != v.end(); ++itr){
                out << ", ";
                old = setIOSFlags(out, base);
                out << stringize_value((T)(*itr), base, string_quote);
                out.setf(old);
            }
        }
        out << "]";
        return out.str();
    }
 
    template <class T, class U>
    inline std::string stringize_value(const std::pair<T,U>& p, DisplayBase base=BASE_DEC,
                                       const std::string& string_quote="") {
        std::stringstream out;
        std::ios_base::fmtflags old = setIOSFlags(out, base);
        out << stringize_value(p.first, base, string_quote) << ":"
            << stringize_value(p.second, base, string_quote);
        out.setf(old);
        return out.str();
    }
 
    template <class... Ts>
    inline std::string stringize_value(const std::tuple<Ts...>& t, DisplayBase base=BASE_DEC,
                                       const std::string& string_quote="") {
        std::stringstream out;
        std::ios_base::fmtflags old = setIOSFlags(out, base);
        stringize_tuple(out, t, base, string_quote, std::index_sequence_for<Ts...>{});
        out.setf(old);
        return out.str();
    }
 
    template <class T>
    inline std::string stringize_value(const T& o, DisplayBase base=BASE_DEC,
                                       const std::string& string_quote="") {
        (void) string_quote;
        std::stringstream out;
        std::ios_base::fmtflags old = setIOSFlags(out, base);
        out << o;
        out.setf(old);
        return out.str();
    }
 
    template <>
    inline std::string stringize_value<std::string>(const std::string& o, DisplayBase base,
                                                    const std::string& string_quote) {
        (void)base;
        std::stringstream out;
        out << string_quote << o << string_quote;
        return out.str();
    }
 
    inline std::vector<std::string>& operator<< (std::vector<std::string>& v, const char * e){
        v.push_back(e);
        return v;
    }
 
    template <class T, class U>
    inline std::vector<T>& operator<< (std::vector<T>& v, U& e){
        const T& val = (const T&)e;
        v.push_back(val);
        return v;
    }
 
    template <class T, class U>
    inline std::vector<T>& operator<< (std::vector<T>& v, const U& e){
        const T& val = (const T&)e;
        v.push_back(val);
        return v;
    }
 
    template <class T, std::size_t... Is>
    inline void stringize_tuple(std::stringstream& ss,
                                const T& t, DisplayBase base,
                                const std::string& string_quote,
                                std::index_sequence<Is...>) {
        ((ss << (Is == 0 ? "" : ":") << stringize_value(std::get<Is>(t), base, string_quote)), ...);
    }
 
} // namespace utils
} // namespace sparta
 
 
namespace std {
    template<class Ch,class T, class Tr>
    inline std::basic_ostream<Ch,Tr>&
    operator<< (std::basic_ostream<Ch,Tr>& out, std::vector<T> const & v){
        out << sparta::utils::stringize_value(v);
        return out;
    }
 
    template<class Ch, class T, class U, class Tr>
    inline std::basic_ostream<Ch,Tr>&
    operator<< (std::basic_ostream<Ch,Tr>& out, std::pair<T,U> const & p){
        out << sparta::utils::stringize_value(p);
        return out;
    }
 
    template<class Ch, class... Ts, class Tr>
    inline std::basic_ostream<Ch,Tr>&
    operator<< (std::basic_ostream<Ch,Tr>& out, std::tuple<Ts...> const & t){
        out << sparta::utils::stringize_value(t);
        return out;
    }
}
 
inline std::vector<std::string>& operator<< (std::vector<std::string>& v, const char * e){
    v.push_back(e);
    return v;
}
 
template <class T, class U>
inline std::vector<T>& operator<< (std::vector<T>& v, U& e){
    const T& val = (const T&)e;
    v.push_back(val);
    return v;
}
 
template <class T, class U>
inline std::vector<T>& operator<< (std::vector<T>& v, const U& e){
    const T& val = (const T&)e;
    v.push_back(val);
    return v;
}