SidedContainer.hpp

Go to the documentation of this file.

#ifndef _VOXOMAP_SIDEDCONTAINER_HPP_
#define _VOXOMAP_SIDEDCONTAINER_HPP_
 
#include <cstdint>
#include <utility>
#include <type_traits>
#include "../VoxelNode.hpp"
#include "../iterator.hpp"
 
namespace voxomap
{
 
enum SideEnum : uint8_t
{
    XPOS = 1,       
    XNEG = 2,       
    YPOS = 4,       
    YNEG = 8,       
    ZPOS = 16,      
    ZNEG = 32,      
    ALL = XPOS | XNEG | YPOS | YNEG | ZPOS | ZNEG 
};
 
template <class T_Voxel>
struct SidedVoxel : T_Voxel
{
    SidedVoxel() = default;
    template <typename T, typename = typename std::enable_if<!std::is_class<T>::value, int>::type>
    SidedVoxel(T arg);
    template <typename T, typename = typename std::enable_if<std::is_class<T>::value, int>::type>
    SidedVoxel(T const& arg);
    template <typename T, typename U, typename... Args>
    SidedVoxel(T&& arg_1, U&& arg_2, Args&&... args);
    SidedVoxel(SidedVoxel const& other) = default;
    SidedVoxel(SidedVoxel&& other) = default;
    template <typename... Args>
    SidedVoxel(SideEnum side, Args&&... args);
 
    SidedVoxel& operator=(SidedVoxel const& other) = default;
    SidedVoxel& operator=(SidedVoxel&& other) = default;
 
    operator    bool() const;
    bool        operator==(SidedVoxel const& other) const;
    bool        operator!=(SidedVoxel const& other) const;
    bool        operator==(T_Voxel const& other) const;
    bool        operator!=(T_Voxel const& other) const;
    bool        operator==(uint8_t s) const;
    bool        operator!=(uint8_t s) const;
    uint8_t     operator&(uint8_t s) const;
    uint8_t     operator|(uint8_t s) const;
    uint8_t     operator&(SideEnum s) const;
    uint8_t     operator|(SideEnum s) const;
    SidedVoxel& operator&=(uint8_t s);
    SidedVoxel& operator|=(uint8_t s);
    uint8_t     getSide() const;
 
private:
    uint8_t _voxel_side = 0;
};
 
template <template <class...> class T_Container, class T_Voxel>
struct SidedContainer : public T_Container<SidedVoxel<T_Voxel>>
{
    using VoxelData = SidedVoxel<T_Voxel>;
    using VoxelContainer = SidedContainer<T_Container, T_Voxel>;
    using iterator = container_iterator<SidedContainer<T_Container, T_Voxel>>;
 
    const static uint32_t NB_VOXELS = T_Container<VoxelData>::NB_VOXELS;
    const static uint32_t COORD_MASK = ~(NB_VOXELS - 1);
    const static uint32_t VOXEL_MASK = NB_VOXELS - 1;
    const static uint32_t NB_SUPERCONTAINER = 0;
 
    SidedContainer() = default;
    SidedContainer(SidedContainer const& other) = default;
    SidedContainer(SidedContainer&& other) = default;
 
    void                init(VoxelNode<SidedContainer> const&) {}
    inline uint16_t     getNbSide() 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>
    bool                removeVoxel(Iterator const& it, VoxelData* voxel = nullptr);
 
    void                exploreVoxelContainer(std::function<void(SidedContainer const&)> const& predicate) const;
 
    void                serialize(std::string& str) const;
    size_t              unserialize(char const* str, size_t size);
 
private:
    // Side management
    template <typename Iterator>
    void addSide(Iterator const& it);
    template <typename Iterator>
    void removeSide(Iterator const& it);
    template <typename Iterator>
    void updateSide(Iterator const& it);
    template <class Iterator> friend void addSide(Iterator const& otherIt, SideEnum side);
    template <class Iterator> friend void removeSide(Iterator const& currentIt, Iterator const& otherIt, SideEnum s1, SideEnum s2);
    template <class Iterator> friend void updateSide(Iterator const& currentIt, Iterator const& otherIt, SideEnum s1, SideEnum s2);
 
    uint16_t _nbSides = 0;
};
 
}
 
#include "SidedContainer.ipp"
 
#endif // _VOXOMAP_SidedContainer_HPP_