Forest.hpp

// Copyright 2021 Arnaud Becheler    <abechele@umich.edu>
 
 
#ifndef __FOREST_H_INCLUDED__
#define __FOREST_H_INCLUDED__
 
#include "assert.h"
#include <set>
#include <unordered_map>
#include <vector>
 
namespace quetzal
{
namespace coalescence
{
namespace container
{
template <typename Position, typename Tree> class Forest
{
  private:
    using SelfType = Forest<Position, Tree>;
    using data_type = std::unordered_multimap<Position, Tree>;
    using size_type = typename data_type::size_type;
    data_type m_data;
 
  public:
    using position_type = Position;
    using iterator = typename data_type::iterator;
    using const_iterator = typename data_type::const_iterator;
    Forest() : m_data()
    {
    }
    Forest(const Forest<Position, Tree> &other) : m_data(other.m_data)
    {
    }
    Forest(Forest<Position, Tree> &&other) noexcept : m_data(std::move(other.m_data))
    {
    }
    Forest<Position, Tree> &operator=(const Forest<Position, Tree> &other)
    {
        Forest<Position, Tree> otherCopy(other);
        *this = std::move(otherCopy);
        return *this;
    }
    Forest<Position, Tree> &operator=(Forest<Position, Tree> &&other) noexcept
    {
        m_data = std::move(other.m_data);
        return *this;
    }
    iterator begin()
    {
        return m_data.begin();
    }
    iterator end()
    {
        return m_data.end();
    }
    const_iterator begin() const
    {
        return m_data.begin();
    }
    const_iterator end() const
    {
        return m_data.end();
    }
    const_iterator cbegin() const
    {
        return m_data.cbegin();
    }
    const_iterator cend() const
    {
        return m_data.cend();
    }
    unsigned int nb_trees() const
    {
        return m_data.size();
    }
    unsigned int nb_trees(Position const &position) const
    {
        return m_data.count(position);
    }
    std::pair<const_iterator, const_iterator> trees_at_same_position(const Position &position) const
    {
        assert(m_data.count(position) > 0 && "no trees at position");
        return m_data.equal_range(position);
    }
    std::pair<iterator, iterator> trees_at_same_position(const Position &position)
    {
        assert(m_data.count(position) > 0 && "no trees at position");
        return m_data.equal_range(position);
    }
 
    iterator insert(Position const &position, Tree const &tree)
    {
        return m_data.insert(std::pair<Position, Tree>(position, tree));
    }
    iterator insert(Position const &position, Tree &&tree) noexcept
    {
        return m_data.insert(std::pair<Position, Tree>(position, std::move(tree)));
    }
    Forest<Position, Tree> &insert(Position const &position, std::vector<Tree> const &trees)
    {
        for (auto const &it : trees)
        {
            insert(position, it);
        }
        return *this;
    }
    Forest<Position, Tree> &insert(Position const &position, std::vector<Tree> &&trees) noexcept
    {
        for (auto &&it : trees)
        {
            insert(position, std::move(it));
        }
        return *this;
    }
    size_type erase(Position const &x)
    {
        return m_data.erase(x);
    }
    void erase(iterator first, iterator last)
    {
        m_data.erase(first, last);
    }
    std::set<Position> positions() const
    {
        std::set<Position> s;
        for (auto const &it : m_data)
        {
            s.insert(it.first);
        }
        return s;
    }
    std::vector<Tree> get_all_trees() const
    {
        std::vector<Tree> trees;
        trees.reserve(this->nb_trees());
        for (auto &it : *this)
        {
            trees.push_back(it.second);
        }
        return trees;
    }
}; // end class Forest
} // namespace container
} // end namespace coalescence
} // end namespace quetzal
#endif