#include "timemory/data/stream.hpp"

Collaboration diagram for tim::data::stream:

Public Types
template<typename T >
using	set_t = std::set< T >

template<typename K , typename M >
using	map_t = std::map< K, M >

template<typename K , typename M >
using	pair_t = std::pair< K, M >

template<typename T >
using	vector_t = std::vector< T >

using	string_t = std::string

using	stringstream_t = std::stringstream

using	format_flags = std::ios_base::fmtflags

using	order_map_t = vector_t< string_t >

using	header_col_t = vector_t< header >

using	entry_col_t = vector_t< entry >

using	header_pair_t = pair_t< string_t, header_col_t >

using	entry_pair_t = pair_t< string_t, entry_col_t >

using	header_map_t = vector_t< header_pair_t >

using	entry_map_t = vector_t< entry_pair_t >

using	break_set_t = set_t< int >

Public Member Functions
	stream (char _delim='\|', char _fill='-', format_flags _fmt={}, int _width=0, int _prec=0, bool _center=false)

bool	center () const

int	precision () const

int	width () const

char	delim () const

format_flags	flags () const

int64_t	freq () const

void	center (bool v)

void	precision (int v)

void	width (int v)

void	delim (char v)

void	setf (format_flags v)

void	setfreq (int64_t v)

void	set_name (string_t v)

void	set_banner (string_t v)

void	set_prefix_begin (int val=-1)

void	set_prefix_end (int val=-1)

void	insert_break (int val=-1)

void	operator() (header _hdr)

void	operator() (entry _obj)

template<typename StreamT >
void	write_separator (StreamT &os, char _delim) const

template<typename StreamT >
void	write_banner (StreamT &os) const

void	clear ()

header &	get_header (const string_t &_key, int64_t _n)

int	add_row ()
	indicate that a row of data has been finished More...

void	sort (const std::function< bool(const std::string &, const std::string &)> &sorter, std::vector< std::string > keys={}, const std::set< std::string > &exclude={})
	Provide a. More...

Static Public Member Functions
static int64_t &	separator_frequency ()

static int64_t	index (const string_t &_val, const vector_t< string_t > &_obj)

static int64_t	insert (const string_t &_val, vector_t< string_t > &_obj)

template<typename Tp >
static int64_t	index (const string_t &_val, const vector_t< pair_t< string_t, vector_t< Tp > > > &_obj)

template<typename Tp >
static int64_t	insert (const string_t &_val, vector_t< pair_t< string_t, vector_t< Tp > > > &_obj)

template<typename... Tp, template< typename... > class _Tuple, size_t... Idx>
static void	write (stream &, const _Tuple< Tp... > &, index_sequence< Idx... >)

Friends
std::ostream &	operator<< (std::ostream &os, const stream &obj)

Detailed Description

Definition at line 268 of file stream.hpp.

Member Typedef Documentation

◆ break_set_t

using tim::data::stream::break_set_t = set_t<int>

Definition at line 295 of file stream.hpp.

◆ entry_col_t

using tim::data::stream::entry_col_t = vector_t<entry>

Definition at line 288 of file stream.hpp.

◆ entry_map_t

using tim::data::stream::entry_map_t = vector_t<entry_pair_t>

Definition at line 294 of file stream.hpp.

◆ entry_pair_t

using tim::data::stream::entry_pair_t = pair_t<string_t, entry_col_t>

Definition at line 291 of file stream.hpp.

◆ format_flags

using tim::data::stream::format_flags = std::ios_base::fmtflags

Definition at line 284 of file stream.hpp.

◆ header_col_t

using tim::data::stream::header_col_t = vector_t<header>

Definition at line 287 of file stream.hpp.

◆ header_map_t

using tim::data::stream::header_map_t = vector_t<header_pair_t>

Definition at line 293 of file stream.hpp.

◆ header_pair_t

using tim::data::stream::header_pair_t = pair_t<string_t, header_col_t>

Definition at line 290 of file stream.hpp.

◆ map_t

template<typename K , typename M >

using tim::data::stream::map_t = std::map<K, M>

Definition at line 274 of file stream.hpp.

◆ order_map_t

using tim::data::stream::order_map_t = vector_t<string_t>

Definition at line 285 of file stream.hpp.

◆ pair_t

template<typename K , typename M >

using tim::data::stream::pair_t = std::pair<K, M>

Definition at line 277 of file stream.hpp.

◆ set_t

template<typename T >

using tim::data::stream::set_t = std::set<T>

Definition at line 271 of file stream.hpp.

◆ string_t

using tim::data::stream::string_t = std::string

Definition at line 282 of file stream.hpp.

◆ stringstream_t

using tim::data::stream::stringstream_t = std::stringstream

Definition at line 283 of file stream.hpp.

◆ vector_t

template<typename T >

using tim::data::stream::vector_t = std::vector<T>

Definition at line 280 of file stream.hpp.

Constructor & Destructor Documentation

◆ stream()

tim::data::stream::stream	(	char	_delim = `'\|'`,
		char	_fill = `'-'`,
		format_flags	_fmt = `{}`,
		int	_width = `0`,
		int	_prec = `0`,
		bool	_center = `false`
	)

inlineexplicit

Definition at line 301 of file stream.hpp.

                                                                             {},
                    int _width = 0, int _prec = 0, bool _center = false)
    : m_center(_center)
    , m_fill(_fill)
    , m_delim(_delim)
    , m_width(_width)
    , m_precision(_prec)
    , m_format(_fmt)
    {}

Member Function Documentation

◆ add_row()

int tim::data::stream::add_row ( )

inline

indicate that a row of data has been finished

Definition at line 693 of file stream.hpp.

    {
        m_cols = 0;
        return ++m_rows;
    }

Referenced by tim::operation::finalize::print< Tp, true >::write_stream().

◆ center() [1/2]

bool tim::data::stream::center ( ) const

inline

Definition at line 311 of file stream.hpp.

311{ return m_center; }

◆ center() [2/2]

void tim::data::stream::center ( bool v )

inline

Definition at line 318 of file stream.hpp.

318{ m_center = v; }

◆ clear()

void tim::data::stream::clear ( )

inline

Definition at line 665 of file stream.hpp.

    {
        m_name = "";
        m_headers.clear();
        m_entries.clear();
    }

◆ delim() [1/2]

char tim::data::stream::delim ( ) const

inline

Definition at line 314 of file stream.hpp.

314{ return m_delim; }

◆ delim() [2/2]

void tim::data::stream::delim ( char v )

inline

Definition at line 321 of file stream.hpp.

321{ m_delim = v; }

◆ flags()

format_flags tim::data::stream::flags ( ) const

inline

Definition at line 315 of file stream.hpp.

315{ return m_format; }

◆ freq()

int64_t tim::data::stream::freq ( ) const

inline

Definition at line 316 of file stream.hpp.

316{ return m_separator_freq; }

◆ get_header()

header & tim::data::stream::get_header	(	const string_t &	_key,
		int64_t	_n
	)

inline

Definition at line 672 of file stream.hpp.

    {
        auto idx = index(_key, m_headers);
        if(idx < 0)
        {
            stringstream_t ss;
            ss << "Missing header '" << _key << "'";
            throw std::runtime_error(ss.str());
        }
 
        if(!(_n < (int64_t) m_headers[idx].second.size()))
        {
            auto _size = m_headers[idx].second.size();
            return m_headers[idx].second[_n % _size];
        }
 
        return m_headers[idx].second[_n];
    }

References index().

Referenced by tim::data::write_entry().

◆ index() [1/2]

template<typename Tp >

static int64_t tim::data::stream::index	(	const string_t &	_val,
		const vector_t< pair_t< string_t, vector_t< Tp > > > &	_obj
	)

inlinestatic

Definition at line 354 of file stream.hpp.

    {
        for(size_t i = 0; i < _obj.size(); ++i)
        {
            if(_obj.at(i).first == _val)
                return static_cast<int64_t>(i);
        }
        return -1;
    }

◆ index() [2/2]

static int64_t tim::data::stream::index	(	const string_t &	_val,
		const vector_t< string_t > &	_obj
	)

inlinestatic

Definition at line 330 of file stream.hpp.

    {
        for(size_t i = 0; i < _obj.size(); ++i)
        {
            if(_obj.at(i) == _val)
                return static_cast<int64_t>(i);
        }
        return -1;
    }

Referenced by get_header(), insert(), operator()(), write_banner(), and write_separator().

◆ insert() [1/2]

template<typename Tp >

static int64_t tim::data::stream::insert	(	const string_t &	_val,
		vector_t< pair_t< string_t, vector_t< Tp > > > &	_obj
	)

inlinestatic

Definition at line 366 of file stream.hpp.

    {
        auto idx = index(_val, _obj);
        if(idx < 0)
        {
            idx = _obj.size();
            _obj.resize(_obj.size() + 1);
            _obj[idx].first = _val;
            if(settings::debug())
                printf("[%s]> inserted '%s'...\n", demangle<Tp>().c_str(), _val.c_str());
        }
        return idx;
    }

References tim::debug, and index().

◆ insert() [2/2]

static int64_t tim::data::stream::insert	(	const string_t &	_val,
		vector_t< string_t > &	_obj
	)

inlinestatic

Definition at line 340 of file stream.hpp.

    {
        auto idx = index(_val, _obj);
        if(idx < 0)
        {
            idx = _obj.size();
            _obj.push_back(_val);
            if(settings::debug())
                printf("> inserted '%s'...\n", _val.c_str());
        }
        return idx;
    }

References tim::debug, and index().

Referenced by operator()().

◆ insert_break()

void tim::data::stream::insert_break ( int val = -1 )

inline

Definition at line 391 of file stream.hpp.

    {
        m_break.insert((val < 0) ? ((int) m_order.size()) : val);
    }

Referenced by tim::operation::print_header< Tp >::print_header().

◆ operator()() [1/2]

void tim::data::stream::operator() ( entry _obj )

inline

Definition at line 413 of file stream.hpp.

    {
        if(_obj.get().empty() && !_obj.permit_empty())
            throw std::runtime_error("Entry has no value");
 
        auto _w = std::max<int>(m_width, _obj.get().length() + 2);
        _w      = std::max<int>(_w, _obj.get_header().width());
 
        _obj.width(_w);
        _obj.get_header().width(_w);
 
        auto _o = index(m_name, m_order);
        if(_o < 0)
            throw std::runtime_error(string_t("Missing entry for ") + m_name);
 
        auto _r = insert(m_name, m_entries);
        _obj.center(false);
        _obj.row(m_rows + 1);
        _obj.column(m_cols);
        m_entries[_r].second.push_back(_obj);
        ++m_cols;
    }

References tim::data::base::stream_entry::center(), tim::data::base::stream_entry::column(), tim::data::base::stream_entry::get(), tim::data::entry::get_header(), index(), insert(), tim::data::entry::permit_empty(), tim::data::base::stream_entry::row(), tim::data::base::stream_entry::width(), and tim::data::entry::width().

◆ operator()() [2/2]

void tim::data::stream::operator() ( header _hdr )

inline

Definition at line 396 of file stream.hpp.

    {
        if(_hdr.get().empty())
            throw std::runtime_error("Header has no value");
 
        auto _w = std::max<int>(m_width, _hdr.get().length() + 2);
        _hdr.width(_w);
 
        m_order.push_back(m_name);
        auto _h = insert(m_name, m_headers);
        auto _n = m_headers[_h].second.size();
        _hdr.center(true);
        _hdr.row(0);
        _hdr.column(_n);
        m_headers[_h].second.push_back(_hdr);
    }

References tim::data::base::stream_entry::center(), tim::data::base::stream_entry::column(), tim::data::base::stream_entry::get(), insert(), tim::data::base::stream_entry::row(), and tim::data::base::stream_entry::width().

◆ precision() [1/2]

int tim::data::stream::precision ( ) const

inline

Definition at line 312 of file stream.hpp.

312{ return m_precision; }

◆ precision() [2/2]

void tim::data::stream::precision ( int v )

inline

Definition at line 319 of file stream.hpp.

319{ m_precision = v; }

◆ separator_frequency()

static int64_t & tim::data::stream::separator_frequency ( )

inlinestatic

Definition at line 298 of file stream.hpp.

298{ return settings::separator_frequency(); }

tim::separator_frequency

separator_frequency

Definition: settings.cpp:1785

References tim::separator_frequency.

◆ set_banner()

void tim::data::stream::set_banner ( string_t v )

inline

Definition at line 328 of file stream.hpp.

328{ m_banner = v; }

◆ set_name()

void tim::data::stream::set_name ( string_t v )

inline

Definition at line 326 of file stream.hpp.

326{ m_name = v; }

Referenced by tim::data::write_entry().

◆ set_prefix_begin()

void tim::data::stream::set_prefix_begin ( int val = -1 )

inline

Definition at line 381 of file stream.hpp.

    {
        m_prefix_begin = (val < 0) ? ((int) m_order.size()) : val;
    }

Referenced by tim::operation::print_header< Tp >::print_header().

◆ set_prefix_end()

void tim::data::stream::set_prefix_end ( int val = -1 )

inline

Definition at line 386 of file stream.hpp.

    {
        m_prefix_end = (val < 0) ? ((int) m_order.size()) : val;
    }

Referenced by tim::operation::print_header< Tp >::print_header().

◆ setf()

void tim::data::stream::setf ( format_flags v )

inline

Definition at line 322 of file stream.hpp.

322{ m_format = v; }

◆ setfreq()

void tim::data::stream::setfreq ( int64_t v )

inline

Definition at line 323 of file stream.hpp.

323{ m_separator_freq = v; }

◆ sort()

void tim::data::stream::sort	(	const std::function< bool(const std::string &, const std::string &)> &	sorter,
		std::vector< std::string >	keys = `{}`,
		const std::set< std::string > &	exclude = `{}`
	)

inline

Provide a.

Parameters

sorter	functor that operates on all or a specific set of header keys. If
keys	is empty, all header keys are sorted. If
keys	is non-empty, the sorted keys are placed at the front of the container and any remaining keys not list in
exclude	will be added to the end of the container in the order consistent with the origial construction

Definition at line 705 of file stream.hpp.

                                                 {},
              const std::set<std::string>& exclude = {})
    {
        // if no keys were provided, add all of them
        if(keys.empty())
        {
            for(const auto& itr : m_order)
                keys.push_back(itr);
        }
 
        // the new headers
        order_map_t _order{};
 
        // sort the keys
        std::sort(keys.begin(), keys.end(), sorter);
 
        // generate the new layout in the order specified
        for(const auto& itr : keys)
        {
            bool found = false;
            for(auto hitr = m_order.begin(); hitr != m_order.end(); ++hitr)
            {
                if(*hitr == itr)
                {
                    _order.push_back(*hitr);
                    // remove entry
                    m_order.erase(hitr);
                    found = true;
                    break;
                }
            }
            if(!found)
            {
                PRINT_HERE("Warning! Expected header tag '%s' not found when sorting",
                           itr.c_str());
            }
        }
 
        // insert any remaining not excluded
        for(const auto& itr : m_order)
        {
            if(exclude.count(itr) == 0)
                _order.push_back(itr);
        }
 
        // set the new headers
        m_order = _order;
    }

◆ width() [1/2]

int tim::data::stream::width ( ) const

inline

Definition at line 313 of file stream.hpp.

313{ return m_width; }

◆ width() [2/2]

void tim::data::stream::width ( int v )

inline

Definition at line 320 of file stream.hpp.

320{ m_width = v; }

◆ write()

template<typename... Tp, template< typename... > class _Tuple, size_t... Idx>

static void tim::data::stream::write	(	stream &	,
		const _Tuple< Tp... > &	,
		index_sequence< Idx... >
	)

static

◆ write_banner()

template<typename StreamT >

void tim::data::stream::write_banner ( StreamT & os ) const

inline

Definition at line 589 of file stream.hpp.

    {
        if(m_banner.length() == 0)
            return;
 
        write_separator(os, '-');
 
        map_t<string_t, int> offset;
 
        int64_t tot_w      = 0;
        int64_t norder_col = 0;
        for(const auto& _key : m_order)
        {
            int64_t col     = ++norder_col;
            auto    _offset = offset[_key]++;
            auto    _hidx   = index(_key, m_headers);
            assert(_hidx >= 0);
            const auto& _hitr  = m_headers[_hidx].second;
            auto        _hsize = _hitr.size();
            const auto& _hdr   = _hitr.at(_offset % _hsize);
            tot_w += _hdr.width() + 1;
            if(m_break.count(col) > 0)
                break;
        }
 
        auto _trim = [&](string_t _banner) {
            // trim the banner
            if(_banner.length() > static_cast<size_t>(tot_w))
            {
                auto _hlen = (tot_w / 2) - 4;  // half-length
                auto _beg  = _banner.substr(0, _hlen);
                auto _end  = _banner.substr(_banner.length() - _hlen);
                _banner    = _beg + "..." + _end;
            }
            return _banner;
        };
 
        auto                     _delim = delimit(m_banner, " \t");
        std::vector<std::string> r_banner(1, "");
        for(auto itr : _delim)
        {
            itr       = _trim(itr);
            auto nlen = r_banner.back().length() + itr.length() + 2;
            if(nlen >= static_cast<size_t>(tot_w))
                r_banner.emplace_back("");
            if(r_banner.back().empty())
            {
                r_banner.back() += itr;
            }
            else
            {
                r_banner.back() += " " + itr;
            }
        }
 
        stringstream_t ss;
 
        auto _write_row = [&](const string_t& _banner) {
            auto obeg = tot_w / 2;
            obeg -= _banner.length() / 2;
            obeg += _banner.length();
            auto oend = tot_w - obeg;
 
            ss << m_delim << std::setw(obeg) << std::right << _banner << std::setw(oend)
               << std::right << m_delim << '\n';
        };
 
        for(const auto& itr : r_banner)
            _write_row(itr);
 
        os << ss.str();
    }

References tim::delimit(), index(), tim::os, and write_separator().

◆ write_separator()

template<typename StreamT >

void tim::data::stream::write_separator	(	StreamT &	os,
		char	_delim
	)		const

inline

Definition at line 554 of file stream.hpp.

    {
        map_t<string_t, int> offset;
        stringstream_t       ss;
        ss.fill(m_fill);
 
        int64_t norder_col = 0;
        for(const auto& _key : m_order)
        {
            int64_t        col = ++norder_col;
            stringstream_t _ss;
            auto           _offset = offset[_key]++;
            auto           _hidx   = index(_key, m_headers);
            assert(_hidx >= 0);
            const auto& _hitr  = m_headers[_hidx].second;
            auto        _hsize = _hitr.size();
            const auto& _hdr   = _hitr.at(_offset % _hsize);
            auto        _w     = _hdr.width();
            if(col == 1)
            {
                ss << m_delim << std::setw(_w) << "";
            }
            else
            {
                ss << _delim << std::setw(_w) << "";
            }
            if(m_break.count(col) > 0)
                break;
        }
 
        ss << m_delim << '\n';
        os << ss.str();
    }

References index(), and tim::os.

Referenced by write_banner().

Friends And Related Function Documentation

◆ operator<<

std::ostream & operator<<	(	std::ostream &	os,
		const stream &	obj
	)

friend

Definition at line 436 of file stream.hpp.

    {
        // return if completely empty
        if(obj.m_headers.empty())
            return os;
 
        // return if not entries
        if(obj.m_entries.empty())
            return os;
 
        stringstream_t       ss;
        map_t<string_t, int> offset;
 
        obj.write_banner(ss);
 
        obj.write_separator(ss, '-');
 
        int64_t norder_col = 0;
        for(const auto& itr : obj.m_order)
        {
            int64_t col = ++norder_col;
 
            stringstream_t _ss;
            // NOLINTNEXTLINE
            auto _key    = itr;
            auto _offset = offset[_key]++;
            auto _idx    = index(_key, obj.m_headers);
            if(_idx < 0 ||
               (_idx >= 0 && !(_offset < (int) obj.m_headers[_idx].second.size())))
            {
                throw std::runtime_error("Error! indexing issue!");
            }
 
            const auto& hitr = obj.m_headers[_idx].second.at(_offset);
            base::write_entry(_ss, hitr);
 
            ss << obj.delim() << ' ' << _ss.str() << ' ';
 
            if(obj.m_break.count(col) > 0)
                break;
        }
 
        // end the line
        ss << obj.delim() << '\n';
 
        obj.write_separator(ss, obj.m_delim);
 
        auto write_empty = [&](stringstream_t& _ss, int64_t _hidx, int64_t _offset) {
            const auto& _hitr  = obj.m_headers[_hidx].second;
            auto        _hsize = _hitr.size();
            const auto& _hdr   = _hitr.at(_offset % _hsize);
            _ss << obj.delim() << ' ' << std::setw(_hdr.width() - 2) << "" << ' ';
        };
 
        offset.clear();
 
        for(int i = 0; i < obj.m_rows; ++i)
        {
            bool just_broke = false;
            norder_col      = 0;
            for(const auto& itr : obj.m_order)
            {
                just_broke  = false;
                int64_t col = ++norder_col;
 
                stringstream_t _ss;
                auto           _key    = itr;  // NOLINT
                auto           _offset = offset[_key]++;
 
                auto _hidx = index(_key, obj.m_headers);
                auto _eidx = index(_key, obj.m_entries);
 
                if(_eidx < 0 && _hidx >= 0)
                {
                    write_empty(ss, _hidx, _offset);
                }
                else
                {
                    assert(_hidx >= 0);
                    assert(_eidx >= 0);
 
                    const auto& _eitr  = obj.m_entries[_eidx].second;
                    auto        _esize = _eitr.size();
                    const auto& _itr   = _eitr.at(_offset % _esize);
 
                    base::write_entry(_ss, _itr);
                    ss << obj.delim() << ' ' << _ss.str() << ' ';
                }
 
                // printf("column: %i, order size: %i, count: %i\n", col,
                // obj.m_order.size(),
                //       obj.m_break.count(col));
                if(col < (int64_t) obj.m_order.size() && obj.m_break.count(col) > 0)
                {
                    ss << obj.m_delim << '\n';
                    just_broke = true;
                    for(auto j = obj.m_prefix_begin; j < obj.m_prefix_end; ++j)
                        write_empty(ss, j, 0);
                }
            }
            if(!just_broke)
                ss << obj.m_delim << '\n';
 
            if(obj.m_separator_freq > 0)
            {
                if((i + 1) < obj.m_rows &&
                   (i % obj.m_separator_freq) == (obj.m_separator_freq - 1))
                    obj.write_separator(ss, obj.m_delim);
            }
        }
 
        obj.write_separator(ss, '-');
 
        os << ss.str();
        return os;
    }

The documentation for this struct was generated from the following file:

timemory/data/stream.hpp

Public Types

Public Member Functions

Static Public Member Functions

Friends

Detailed Description

Member Typedef Documentation

◆ break_set_t

◆ entry_col_t

◆ entry_map_t

◆ entry_pair_t

◆ format_flags

◆ header_col_t

◆ header_map_t

◆ header_pair_t

◆ map_t

◆ order_map_t

◆ pair_t

◆ set_t

◆ string_t

◆ stringstream_t

◆ vector_t

Constructor & Destructor Documentation

◆ stream()

Member Function Documentation

◆ add_row()

◆ center() [1/2]

◆ center() [2/2]

◆ clear()

◆ delim() [1/2]

◆ delim() [2/2]

◆ flags()

◆ freq()

◆ get_header()

◆ index() [1/2]

◆ index() [2/2]

◆ insert() [1/2]

◆ insert() [2/2]

◆ insert_break()

◆ operator()() [1/2]

◆ operator()() [2/2]

◆ precision() [1/2]

◆ precision() [2/2]

◆ separator_frequency()

◆ set_banner()

◆ set_name()

◆ set_prefix_begin()

◆ set_prefix_end()

◆ setf()

◆ setfreq()

◆ sort()

◆ width() [1/2]

◆ width() [2/2]

◆ write()

◆ write_banner()

◆ write_separator()

Friends And Related Function Documentation

◆ operator<<