block.hpp

 
#ifndef UFO_CONTAINER_TREE_SET_BLOCK_HPP
#define UFO_CONTAINER_TREE_SET_BLOCK_HPP
 
// UFO
#include <ufo/container/tree/block.hpp>
#include <ufo/container/tree/code.hpp>
#include <ufo/container/tree/index.hpp>
#include <ufo/geometry/aabb.hpp>
 
// STL
#include <array>
#include <cstddef>
#include <limits>
#include <list>
 
namespace ufo
{
template <std::size_t Dim, std::size_t BF>
struct TreeSetBlock : public TreeBlock<Dim, BF> {
    using Base = TreeBlock<Dim, BF>;
 
    using Code           = TreeCode<Dim>;
    using length_t       = typename Base::length_t;
    using Length         = typename Base::Length;
    using Point          = typename Base::Point;
    using Bounds         = AABB<Dim, typename Point::value_type>;
    using scalar_type    = typename Point::value_type;
    using value_type     = Point;
    using container_type = std::list<value_type>;
 
    static constexpr auto const MIN =
        Point(std::numeric_limits<typename Point::value_type>::lowest());
    static constexpr auto const MAX =
        Point(std::numeric_limits<typename Point::value_type>::max());
 
    std::array<Bounds, BF>         bounds = createArray<BF>(Bounds(MAX, MIN));
    std::array<container_type, BF> values;
 
    constexpr TreeSetBlock() = default;
 
    constexpr TreeSetBlock(TreeIndex::pos_t parent_block, Code code, Point center,
                           Length half_length)
        : Base(parent_block, code, center, half_length)
    {
    }
 
    constexpr TreeSetBlock(TreeIndex::pos_t parent_block, TreeSetBlock const& parent,
                           std::size_t offset, Length half_length)
        : Base(parent_block, parent, offset, half_length)
    {
    }
};
}  // namespace ufo
 
#endif  // UFO_CONTAINER_TREE_SET_BLOCK_HPP