SparseSuperContainer.hpp

Go to the documentation of this file.

#ifndef _VOXOMAP_SPARSESUPERCONTAINER_HPP_
#define _VOXOMAP_SPARSESUPERCONTAINER_HPP_
 
#include <cstdint>
#include <memory>
#include <string>
#include <vector>
#include <functional>
#include "../iterator.hpp"
#include "../SparseIDArray.hpp"
 
namespace voxomap
{
 
template <class Container> class VoxelNode;
 
template <class T_Container, template <class...> class T_InternalContainer = std::vector>
struct SparseSuperContainer
{
    using Container = T_Container;
    using VoxelData = typename Container::VoxelData;
    using VoxelContainer = typename Container::VoxelContainer;
    using iterator = supercontainer_iterator<SparseSuperContainer<Container, T_InternalContainer>>;
 
    const static uint32_t NB_CONTAINERS = 8;
    const static uint32_t CONTAINER_MASK = NB_CONTAINERS - 1;
    const static uint32_t NB_VOXELS = NB_CONTAINERS * Container::NB_VOXELS;
    const static uint32_t COORD_MASK = ~(NB_VOXELS - 1);
    const static uint32_t VOXEL_MASK = Container::VOXEL_MASK;
    const static uint32_t NB_SUPERCONTAINER = 1 + Container::NB_SUPERCONTAINER;
    const static uint32_t SUPERCONTAINER_ID = NB_SUPERCONTAINER - 1;
 
    SparseSuperContainer() = default;
    SparseSuperContainer(SparseSuperContainer const& other) = default;
    SparseSuperContainer(SparseSuperContainer&& other) = default;
    ~SparseSuperContainer() = default;
 
 
    void                init(VoxelNode<SparseSuperContainer<Container, T_InternalContainer>> const&) {}
    uint32_t            getNbVoxel() const;
    template <typename Iterator>
    VoxelData*          findVoxel(Iterator& it);
    template <typename Iterator>
    VoxelData const*    findVoxel(Iterator& it) const;
 
    bool                hasContainer(uint8_t x) const;
    bool                hasContainer(uint8_t x, uint8_t y) const;
    bool                hasContainer(uint8_t x, uint8_t y, uint8_t z) const;
    Container*          findContainer(uint8_t x, uint8_t y, uint8_t z);
    Container const*    findContainer(uint8_t x, uint8_t y, uint8_t z) const;
 
    template <typename Iterator, typename... Args>
    bool                addVoxel(Iterator& it, Args&&... args);
    template <typename Iterator, typename... Args>
    bool                updateVoxel(Iterator& it, Args&&... args);
    template <typename Iterator, typename... Args>
    void                putVoxel(Iterator& it, Args&&... args);
    template <typename Iterator, typename... Args>
    bool                removeVoxel(Iterator const& it, Args&&... args);
 
    void                serialize(std::string& str) const;
    size_t              unserialize(char const* str, size_t size);
 
    template <typename Iterator>
    void                exploreVoxel(Iterator& it, std::function<void(Iterator const&)> const& predicate) const;
 
    void                exploreVoxelContainer(std::function<void(typename T_Container::VoxelContainer const&)> const& predicate) const;
 
private:
    SparseIDArray<std::unique_ptr<Container>, NB_CONTAINERS, T_InternalContainer> _sparseArray;
    uint32_t _nbVoxels = 0; 
};
 
}
 
#include "SparseSuperContainer.ipp"
 
#endif // _VOXOMAP_SPARSESUPERCONTAINER_HPP_