node.hpp

 
#ifndef UFO_CONTAINER_TREE_NODE_HPP
#define UFO_CONTAINER_TREE_NODE_HPP
 
// UFO
#include <ufo/container/tree/code.hpp>
#include <ufo/container/tree/index.hpp>
 
// STL
#include <cstddef>
#include <functional>
#include <ostream>
 
namespace ufo
{
template <std::size_t Dim>
struct TreeNode {
    TreeCode<Dim> code;
    TreeIndex     index;
 
    constexpr TreeNode() = default;
 
    constexpr TreeNode(TreeCode<Dim> const& code, TreeIndex const& index) noexcept
        : code(code), index(index)
    {
    }
 
    operator TreeCode<Dim>() const noexcept { return code; }
 
    explicit operator TreeIndex() const noexcept { return index; }
};
 
//
// Deduction guide
//
 
template <std::size_t Dim>
TreeNode(TreeCode<Dim>, TreeIndex) -> TreeNode<Dim>;
 
//
// Compare
//
 
template <std::size_t Dim>
constexpr bool operator==(TreeNode<Dim> const& lhs, TreeNode<Dim> const& rhs) noexcept
{
    return lhs.code == rhs.code;
}
 
template <std::size_t Dim>
constexpr bool operator!=(TreeNode<Dim> const& lhs, TreeNode<Dim> const& rhs) noexcept
{
    return !(lhs == rhs);
}
 
template <std::size_t Dim>
constexpr bool operator<(TreeNode<Dim> const& lhs, TreeNode<Dim> const& rhs) noexcept
{
    return lhs.code < rhs.code;
}
 
template <std::size_t Dim>
constexpr bool operator<=(TreeNode<Dim> const& lhs, TreeNode<Dim> const& rhs) noexcept
{
    return lhs.code <= rhs.code;
}
 
template <std::size_t Dim>
constexpr bool operator>(TreeNode<Dim> const& lhs, TreeNode<Dim> const& rhs) noexcept
{
    return lhs.code > rhs.code;
}
 
template <std::size_t Dim>
constexpr bool operator>=(TreeNode<Dim> const& lhs, TreeNode<Dim> const& rhs) noexcept
{
    return lhs.code >= rhs.code;
}
 
template <std::size_t Dim>
std::ostream& operator<<(std::ostream& os, TreeNode<Dim> const& node)
{
    return os << "Code: (" << node.code << "), Index: (" << node.index << ')';
}
 
using BinaryNode = TreeNode<1>;
using QuadNode   = TreeNode<2>;
using OctNode    = TreeNode<3>;
using HexNode    = TreeNode<4>;
 
}  // namespace ufo
 
namespace std
{
template <std::size_t Dim>
struct hash<ufo::TreeNode<Dim>> {
    std::size_t operator()(ufo::TreeNode<Dim> const& node) const
    {
        return hash<ufo::TreeCode<Dim>>()(node.code);
    }
};
}  // namespace std
 
#endif  // UFO_CONTAINER_TREE_NODE_HPP