Network.hpp

// Copyright 2021 Arnaud Becheler    <abechele@umich.edu>
 
 
#ifndef NETWORK_H_INCLUDED
#define NETWORK_H_INCLUDED
 
#include <vector>
 
namespace quetzal
{
namespace coalescence
{
namespace container
{
template <class CellT> class Network
{
  private:
    CellT m_cell;
    std::vector<Network<CellT>> m_parents;
    std::vector<Network<CellT>> m_children;
 
  public:
    Network() : m_parents(), m_cell(), m_children()
    {
    }
    Network(const CellT &cell) : m_parents(), m_cell(cell), m_children()
    {
    }
    Network(CellT &&cell) noexcept : m_parents(), m_cell(std::move(cell)), m_children()
    {
    }
    unsigned int nb_children() const
    {
        return m_children.size();
    }
    unsigned int nb_parents() const
    {
        return m_parents.size();
    }
    const CellT &cell() const
    {
        return m_cell;
    }
    CellT &cell()
    {
        return m_cell;
    }
 
    Network<CellT> &add_child(CellT &&cell) noexcept
    {
        Network<CellT> subnetwork(std::move(cell));
        subnetwork.add_parent(*this);
        m_children.push_back(std::move(subnetwork));
        return m_children.back();
    }
    Network<CellT> &add_child(Network<CellT> &subnetwork)
    {
        subnetwork.add_parent(*this);
        m_children.push_back(subnetwork);
        return m_children.back();
    }
    Network<CellT> &add_parent(Network<CellT> &parent)
    {
        m_parents.push_back(parent);
        return m_parents.back();
    }
    bool has_parent() const
    {
        return !m_parents.empty();
    }
    bool has_children() const
    {
        return !m_children.empty();
    }
    template <typename UnaryOperation> void visit_cell_by_pre_order_DFS(UnaryOperation op) const
    {
        op(this->cell());
        for (auto const &child : this->m_children)
        {
            child.visit_cells_by_pre_order_DFS(op);
        }
    }
    template <class UnaryOperation> void visit_by_pre_order_DFS(UnaryOperation op)
    {
        op(*this);
        for (auto &child : this->m_children)
        {
            child.visit_by_pre_order_DFS(op);
        }
    }
    template <typename Op1, typename Op2, typename Op3>
    void visit_by_generic_DFS(Op1 preorder, Op2 inorder, Op3 postorder)
    {
        preorder(*this);
        for (auto &child : this->m_children)
        {
            child.visit_by_generic_DFS(preorder, inorder, postorder);
            inorder(*this);
        }
        postorder(*this);
    }
    template <typename UnaryOperation> void visit_leaves_cells_by_DFS(UnaryOperation op) const
    {
        if (has_children())
        {
            for (auto const &child : this->m_children)
            {
                child.visit_leaves_cells_by_DFS(op);
            }
        }
        else
        {
            op(this->cell());
        }
    }
}; // end class Network
} // end namespace container
} // end namespace coalescence
} // end namespace quetzal
 
#endif