diagram.hpp

#ifndef LIBTEDDY_DETAILS_DIAGRAM_HPP
#define LIBTEDDY_DETAILS_DIAGRAM_HPP
 
#include <libteddy/details/node.hpp>
#include <libteddy/details/node_manager.hpp>
#include <libteddy/details/tools.hpp>
 
namespace teddy
{
template<class Data, class Degree>
class diagram
{
public:
    using node_t = node<Data, Degree>;
 
public:
    diagram() = default;
 
    diagram(node_t* root);
 
    diagram(diagram const& other);
 
    diagram(diagram&& other) noexcept;
 
    ~diagram();
 
    auto operator= (diagram other) -> diagram&;
 
    auto swap (diagram& other) -> void;
 
    auto equals (diagram const& other) const -> bool;
 
    auto unsafe_get_root () const -> node_t*;
 
private:
    node_t* root_ {nullptr};
};
 
template<class Data, class Degree>
auto swap (diagram<Data, Degree>& lhs, diagram<Data, Degree>& rhs) -> void
{
    lhs.swap(rhs);
}
 
template<class Data, class Degree>
auto operator== (
    diagram<Data, Degree> const& lhs,
    diagram<Data, Degree> const& rhs
) -> bool
{
    return lhs.equals(rhs);
}
 
template<class Data, class Degree>
auto equals (diagram<Data, Degree> lhs, diagram<Data, Degree> rhs) -> bool
{
    return lhs.equals(rhs);
}
 
template<class Data, class Degree>
diagram<Data, Degree>::diagram(node_t* const root) :
    root_(id_set_notmarked(id_inc_ref_count(root)))
{
}
 
template<class Data, class Degree>
diagram<Data, Degree>::diagram(diagram const& other) :
    root_(id_inc_ref_count(other.root_))
{
}
 
template<class Data, class Degree>
diagram<Data, Degree>::diagram(diagram&& other) noexcept :
    root_(utils::exchange(other.root_, nullptr))
{
}
 
template<class Data, class Degree>
diagram<Data, Degree>::~diagram()
{
    if (root_)
    {
        root_->dec_ref_count();
    }
}
 
template<class Data, class Degree>
auto diagram<Data, Degree>::operator= (diagram other) -> diagram&
{
    other.swap(*this);
    return *this;
}
 
template<class Data, class Degree>
auto diagram<Data, Degree>::swap(diagram& other) -> void
{
    utils::swap(root_, other.root_);
}
 
template<class Data, class Degree>
auto diagram<Data, Degree>::equals(diagram const& other) const -> bool
{
    return root_ == other.unsafe_get_root();
}
 
template<class Data, class Degree>
auto diagram<Data, Degree>::unsafe_get_root() const -> node_t*
{
    return root_;
}
} // namespace teddy
 
namespace std
{
template<class Data, class Degree>
struct hash<teddy::diagram<Data, Degree>>
{
    [[nodiscard]] auto operator() (teddy::diagram<Data, Degree> const& diagram
    ) const noexcept -> std::size_t
    {
        return ::teddy::utils::do_hash(diagram.unsafe_get_root());
    }
};
 
template<class Data, class Degree>
struct equal_to<teddy::diagram<Data, Degree>>
{
    [[nodiscard]] auto operator() (
        teddy::diagram<Data, Degree> const& lhs,
        teddy::diagram<Data, Degree> const& rhs
    ) const noexcept -> bool
    {
        return lhs.equals(rhs);
    }
};
} // namespace std
 
#endif