ostream.hh

Go to the documentation of this file.

#ifndef UTOPIA_CORE_OSTREAM_HH
#define UTOPIA_CORE_OSTREAM_HH
 
#include "type_traits.hh"
 
namespace Utopia::Utils {
 
template < typename T, typename U >
std::ostream&
operator<<(std::ostream& out, const std::pair< T, U >& pair)
{
    out << "(" << pair.first << ", " << pair.second << ")";
    return out;
}
 
template < class T >
std::enable_if_t< is_container_v< T >, std::ostream& >
operator<<(std::ostream& out, const T& container)
{
    if (container.size() == 0)
    {
        out << "[]";
    }
    else
    {
        out << std::setprecision(16) << "[";
 
        for (auto it = container.begin();
             it != std::next(std::begin(container), container.size() - 1);
             ++it)
        {
            out << *it << ", "; // becomes a recursive call in case of nested
                                // containers
        }
        out << *std::next(std::begin(container), container.size() - 1) << "]";
    }
    return out;
}
 
std::ostream&
operator<<(std::ostream& out, const std::vector< bool >& container)
{
    if (container.size() == 0)
    {
        out << "[]" << std::endl;
    }
    else
    {
        out << "[";
        for (std::size_t i = 0; i < container.size() - 1; ++i)
        {
            out << container[i] << ", ";
        }
        out << container.back() << "]";
    }
    return out;
}
 
template < template < typename, typename, typename... > class MapType,
           typename Key,
           typename Value,
           typename... Args >
std::enable_if_t<
    is_associative_container_v< MapType< Key, Value, Args... > > or
        is_unordered_associative_container_v< MapType< Key, Value, Args... > >,
    std::ostream& >
operator<<(std::ostream& out, const MapType< Key, Value, Args... >& map)
{
    if (map.size() == 0)
    {
        out << "[]";
    }
    else
    {
        out << "[";
        for (auto it = map.begin();
             it != std::next(map.begin(), map.size() - 1);
             ++it)
        {
            out << *it << ", ";
        }
        out << *std::next(map.begin(), map.size() - 1) << "]";
    }
    return out;
}
 
template < typename... Types >
std::ostream&
operator<<(std::ostream& ostr, std::tuple< Types... > tuple)
{
    std::string val_str("(");
 
    auto report_val = [&val_str](auto&& val) {
        val_str += std::to_string(val) + ", ";
    };
    boost::hana::for_each(tuple, report_val);
 
    // remove final comma
    val_str.erase(val_str.end() - 2);
    val_str += ")";
 
    ostr << val_str;
    return ostr;
}
 
 
template < typename T >
std::string
str(T&& t)
{
    std::stringstream s;
    s << t;
    return s.str();
}
 
 
} // namespace Utopia::Utils
 
#endif