Basic hierarchical tree implementation. Expects population from tim::graph. More...

#include "timemory/storage/basic_tree.hpp"

Collaboration diagram for tim::basic_tree< Tp >:

Public Types
using	this_type = basic_tree< Tp >

using	value_type = Tp

using	child_type = this_type

using	child_pointer = std::shared_ptr< child_type >

using	children_type = std::vector< child_pointer >

using	children_base = std::vector< child_type >

Public Member Functions
template<typename GraphT , typename ItrT >
this_type &	operator() (const GraphT &g, ItrT root)
	construction from `tim::graph<Tp>` More...

this_type &	operator+= (const this_type &rhs)

this_type &	operator-= (const this_type &rhs)

template<typename Archive >
void	save (Archive &ar, const unsigned int) const

template<typename Archive >
void	load (Archive &ar, const unsigned int)

auto &	get_value ()
	return the current tree node More...

auto &	get_children ()
	return the array of child nodes More...

const auto &	get_value () const

const auto &	get_children () const

template<typename GraphT , typename ItrT >
basic_tree< Tp > &	operator() (const GraphT &g, ItrT root)

Friends
bool	operator== (const this_type &lhs, const this_type &rhs)

bool	operator!= (const this_type &lhs, const this_type &rhs)

Detailed Description

template<typename Tp>
struct tim::basic_tree< Tp >

Basic hierarchical tree implementation. Expects population from tim::graph.

Template Parameters

Tp	Component type

Definition at line 43 of file basic_tree.hpp.

Member Typedef Documentation

◆ child_pointer

template<typename Tp >

using tim::basic_tree< Tp >::child_pointer = std::shared_ptr<child_type>

Definition at line 48 of file basic_tree.hpp.

◆ child_type

template<typename Tp >

using tim::basic_tree< Tp >::child_type = this_type

Definition at line 47 of file basic_tree.hpp.

◆ children_base

template<typename Tp >

using tim::basic_tree< Tp >::children_base = std::vector<child_type>

Definition at line 50 of file basic_tree.hpp.

◆ children_type

template<typename Tp >

using tim::basic_tree< Tp >::children_type = std::vector<child_pointer>

Definition at line 49 of file basic_tree.hpp.

◆ this_type

template<typename Tp >

using tim::basic_tree< Tp >::this_type = basic_tree<Tp>

Definition at line 45 of file basic_tree.hpp.

◆ value_type

template<typename Tp >

using tim::basic_tree< Tp >::value_type = Tp

Definition at line 46 of file basic_tree.hpp.

Member Function Documentation

◆ get_children() [1/2]

template<typename Tp >

auto & tim::basic_tree< Tp >::get_children ( )

inline

return the array of child nodes

Definition at line 70 of file basic_tree.hpp.

70{ return m_children; }

Referenced by tim::operation::finalize::merge< Type, true >::operator()().

◆ get_children() [2/2]

template<typename Tp >

const auto & tim::basic_tree< Tp >::get_children ( ) const

inline

Definition at line 73 of file basic_tree.hpp.

73{ return m_children; }

◆ get_value() [1/2]

template<typename Tp >

auto & tim::basic_tree< Tp >::get_value ( )

inline

return the current tree node

Definition at line 68 of file basic_tree.hpp.

68{ return m_value; }

◆ get_value() [2/2]

template<typename Tp >

const auto & tim::basic_tree< Tp >::get_value ( ) const

inline

Definition at line 72 of file basic_tree.hpp.

72{ return m_value; }

◆ load()

template<typename Tp >

template<typename Archive >

void tim::basic_tree< Tp >::load	(	Archive &	ar,
		const unsigned int
	)

Definition at line 238 of file basic_tree.hpp.

{
    // this is for backward compatiblity
    children_base _children{};
    ar(cereal::make_nvp("node", m_value), cereal::make_nvp("children", _children));
    for(auto&& itr : _children)
        m_children.emplace_back(std::make_shared<child_type>(std::move(itr)));
}

◆ operator()() [1/2]

template<typename Tp >

template<typename GraphT , typename ItrT >

this_type & tim::basic_tree< Tp >::operator()	(	const GraphT &	g,
		ItrT	root
	)

construction from tim::graph<Tp>

◆ operator()() [2/2]

template<typename Tp >

template<typename GraphT , typename ItrT >

basic_tree< Tp > & tim::basic_tree< Tp >::operator()	(	const GraphT &	g,
		ItrT	root
	)

Definition at line 95 of file basic_tree.hpp.

{
    using iterator_t = typename GraphT::sibling_iterator;
    using entry_type = std::decay_t<decltype(std::declval<ItrT>()->data())>;
 
    m_value              = *root;
    iterator_t _begin    = g.begin(root);
    iterator_t _end      = g.end(root);
    auto       nchildren = std::distance(_begin, _end);
    if(nchildren > 0)
    {
        m_children.reserve(nchildren);
        for(auto itr = _begin; itr != _end; ++itr)
        {
            if(!itr->is_dummy() &&
               !operation::get_is_invalid<entry_type, false>{}(itr->data()))
            {
                m_value.exclusive().data() -= itr->data();
                m_value.exclusive().stats() -= itr->stats();
                m_children.emplace_back(std::make_shared<child_type>());
                m_children.back()->operator()(g, itr);
            }
            else
            {
                iterator_t _dbegin = g.begin(itr);
                iterator_t _dend   = g.end(itr);
                for(auto ditr = _dbegin; ditr != _dend; ++ditr)
                {
                    if(!ditr->is_dummy())
                    {
                        m_children.emplace_back(std::make_shared<child_type>());
                        m_children.back()->operator()(g, ditr);
                    }
                }
            }
        }
    }
    return *this;
}

◆ operator+=()

template<typename Tp >

basic_tree< Tp > & tim::basic_tree< Tp >::operator+= ( const this_type & rhs )

Definition at line 137 of file basic_tree.hpp.

{
    if(*this == rhs)
    {
        m_value += rhs.m_value;
    }
    if(false)
    {
        for(auto& ritr : rhs.m_children)
            m_children.insert(m_children.end(), ritr);
    }
    else
    {
        std::set<size_t> found{};
        auto nitr = std::min<size_t>(m_children.size(), rhs.m_children.size());
        // add identical entries
        for(size_t i = 0; i < nitr; ++i)
        {
            if((*m_children.at(i)) == (*rhs.m_children.at(i)))
            {
                found.insert(i);
                (*m_children.at(i)) += (*rhs.m_children.at(i));
            }
        }
        // add to first matching entry
        for(size_t i = 0; i < rhs.m_children.size(); ++i)
        {
            if(found.find(i) != found.end())
                continue;
            for(size_t j = 0; j < m_children.size(); ++j)
            {
                if((*m_children.at(j)) == (*rhs.m_children.at(i)))
                {
                    found.insert(i);
                    (*m_children.at(j)) += (*rhs.m_children.at(i));
                }
            }
        }
        // append to end if not found anywhere
        for(size_t i = 0; i < rhs.m_children.size(); ++i)
        {
            if(found.find(i) != found.end())
                continue;
            m_children.insert(m_children.end(), rhs.m_children.at(i));
        }
    }
    return *this;
}

◆ operator-=()

template<typename Tp >

basic_tree< Tp > & tim::basic_tree< Tp >::operator-= ( const this_type & rhs )

Definition at line 188 of file basic_tree.hpp.

{
    if(*this == rhs)
    {
        m_value -= rhs.m_value;
    }
 
    std::set<size_t> found{};
    auto             nitr = std::min<size_t>(m_children.size(), rhs.m_children.size());
    // add identical entries
    for(size_t i = 0; i < nitr; ++i)
    {
        if((*m_children.at(i)) == (*rhs.m_children.at(i)))
        {
            found.insert(i);
            m_children.at(i) -= rhs.m_children.at(i);
        }
    }
    // add to first matching entry
    for(size_t i = 0; i < rhs.m_children.size(); ++i)
    {
        if(found.find(i) != found.end())
            continue;
        for(size_t j = 0; j < m_children.size(); ++j)
        {
            if((*m_children.at(j)) == (*rhs.m_children.at(i)))
            {
                found.insert(i);
                m_children.at(j) -= rhs.m_children.at(i);
            }
        }
    }
    return *this;
}

◆ save()

template<typename Tp >

template<typename Archive >

void tim::basic_tree< Tp >::save	(	Archive &	ar,
		const unsigned int
	)		const

Definition at line 226 of file basic_tree.hpp.

{
    // this is for backward compatiblity
    children_base _children{};
    for(const auto& itr : m_children)
        _children.emplace_back(*itr);
    ar(cereal::make_nvp("node", m_value), cereal::make_nvp("children", _children));
}

Friends And Related Function Documentation

◆ operator!=

template<typename Tp >

bool operator!=	(	const this_type &	lhs,
		const this_type &	rhs
	)

friend

Definition at line 82 of file basic_tree.hpp.

    {
        return !(lhs == rhs);
    }

◆ operator==

template<typename Tp >

bool operator==	(	const this_type &	lhs,
		const this_type &	rhs
	)

friend

Definition at line 75 of file basic_tree.hpp.

    {
        // auto _lhash = get_hash_id(get_hash_aliases(), lhs.m_value.hash());
        // auto _rhash = get_hash_id(get_hash_aliases(), rhs.m_value.hash());
        return (lhs.m_value.hash() == rhs.m_value.hash());
    }

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

timemory/operations/types.hpp
timemory/storage/basic_tree.hpp

Public Types

Public Member Functions

Friends

Detailed Description

Member Typedef Documentation

◆ child_pointer

◆ child_type

◆ children_base

◆ children_type

◆ this_type

◆ value_type

Member Function Documentation

◆ get_children() [1/2]

◆ get_children() [2/2]

◆ get_value() [1/2]

◆ get_value() [2/2]

◆ load()

◆ operator()() [1/2]

◆ operator()() [2/2]

◆ operator+=()

◆ operator-=()

◆ save()

Friends And Related Function Documentation

◆ operator!=

◆ operator==