SparseIDArray.hpp

Go to the documentation of this file.

#ifndef _VOXOMAP_SPARSEIDARRAY_HPP_
#define _VOXOMAP_SPARSEIDARRAY_HPP_
 
#include <cstdint>
#include <memory>
#include <vector>
#include <string>
 
namespace voxomap
{
 
template <typename T, uint8_t T_Size, template<class...> class T_Container = std::vector>
class AbstractSparseIDArray
{
    static_assert(T_Size <= 32, "SparseIDArray can't have size > 32");  // because ids are store on a uint16_t
 
protected:
    AbstractSparseIDArray();
    AbstractSparseIDArray(AbstractSparseIDArray const& other);
 
public:
    uint16_t            getNbData() const;
 
    bool                hasData(uint8_t x) const;
    bool                hasData(uint8_t x, uint8_t y) const;
    bool                hasData(uint8_t x, uint8_t y, uint8_t z) const;
 
    T*                  findData(uint8_t x, uint8_t y, uint8_t z);
    T const*            findData(uint8_t x, uint8_t y, uint8_t z) const;
 
    template <typename... Args>
    bool                addData(uint8_t x, uint8_t y, uint8_t z, T*& data, Args&&... args);
    template <typename... Args>
    bool                updateData(uint8_t x, uint8_t y, uint8_t z, T*& data, Args&&... args);
    template <typename... Args>
    void                putData(uint8_t x, uint8_t y, uint8_t z, T*& data, Args&&... args);
    bool                removeData(uint8_t x, uint8_t y, uint8_t z);
    bool                removeData(uint8_t x, uint8_t y, uint8_t z, T* data);
 
    void                serialize(std::string& str) const;
    size_t              unserialize(char const* str, size_t size);
 
    void                shrinkToFit();
 
protected:
    // Serialization structure, use when there is less than 128 voxels inside area
    struct SerializationData
    {
        SerializationData(uint16_t position, uint16_t id);
        SerializationData(SerializationData const& other) = default;
        SerializationData(SerializationData&& other) = default;
 
#if (defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__) || defined(__BIG_ENDIAN__)
        uint16_t id : 7;
        uint16_t position : 9;
#else
        uint16_t position : 9;
        uint16_t id : 7;
#endif
    };
 
    uint16_t            getId(uint8_t x, uint8_t y, uint8_t z) const;
    void                setId(uint8_t x, uint8_t y, uint8_t z, uint16_t id);
    uint16_t            getNewId();
    template <typename T_Old, typename T_New>
    void                reallocIds();
    template <typename Type>
    void                changeId(uint16_t oldId, uint16_t newId);
    template <typename Type>
    void reset(Type& data);
    template <typename Type>
    void reset(std::unique_ptr<Type>& data);
    template <typename Type>
    void reset(std::shared_ptr<Type>& data);
 
    template <typename T_Data>
    void copy(T_Container<T_Data> const& other);
    template <typename T_Data>
    void copy(T_Container<std::unique_ptr<T_Data>> const& other);
 
    template <typename T_Data>
    typename std::enable_if<std::is_trivially_copyable<T_Data>::value>::type serializeContainer(std::string& str, T_Container<T_Data> const& datas) const;
    template <typename T_Data>
    typename std::enable_if<!std::is_trivially_copyable<T_Data>::value>::type serializeContainer(std::string& str, T_Container<T_Data> const& datas) const;
    template <typename T_Data>
    void serializeContainer(std::string& str, T_Container<T_Data*> const& datas) const;
    template <typename T_Data>
    void serializeContainer(std::string& str, T_Container<std::unique_ptr<T_Data>> const& datas) const;
    template <typename T_Data>
    void serializeContainer(std::string& str, T_Container<std::shared_ptr<T_Data>> const& datas) const;
    template <typename T_Data>
    typename std::enable_if<std::is_trivially_copyable<T_Data>::value>::type serializeData(std::string& str, T_Data const& data) const;
    template <typename T_Data>
    typename std::enable_if<!std::is_trivially_copyable<T_Data>::value>::type serializeData(std::string& str, T_Data const& data) const;
 
    template <typename T_Data>
    typename std::enable_if<std::is_trivially_copyable<T_Data>::value, size_t>::type unserializeContainer(char const* str, size_t size, T_Container<T_Data>& datas);
    template <typename T_Data>
    typename std::enable_if<!std::is_trivially_copyable<T_Data>::value, size_t>::type unserializeContainer(char const* str, size_t size, T_Container<T_Data>& datas);
    template <typename T_Data>
    size_t unserializeContainer(char const* str, size_t size, T_Container<T_Data*>& datas);
    template <typename T_Data>
    size_t unserializeContainer(char const* str, size_t size, T_Container<std::unique_ptr<T_Data>>& datas);
    template <typename T_Data>
    size_t unserializeContainer(char const* str, size_t size, T_Container<std::shared_ptr<T_Data>>& datas);
    template <typename T_Data>
    typename std::enable_if<std::is_trivially_copyable<T_Data>::value, size_t>::type unserializeData(char const* str, size_t size, T_Data& data);
    template <typename T_Data>
    typename std::enable_if<!std::is_trivially_copyable<T_Data>::value, size_t>::type unserializeData(char const* str, size_t size, T_Data& data);
 
    T_Container<T>                  _data;     //<! Contains the data
    T_Container<uint16_t>           _idFreed;   //<! List of unused data inside \a _datas
    std::unique_ptr<uint8_t[]>      _ids;       //<! 3D Array of id
};
 
 
template <typename T, uint8_t T_Size, template<class...> class T_Container = std::vector>
class SparseIDArray : public AbstractSparseIDArray<T, T_Size, T_Container>
{
    using AbstractSparseIDArray<T, T_Size, T_Container>::AbstractSparseIDArray;
};
 
 
template <typename T, uint8_t T_Size, template<class...> class T_Container>
class SparseIDArray<std::unique_ptr<T>, T_Size, T_Container> : public AbstractSparseIDArray<std::unique_ptr<T>, T_Size, T_Container>
{
public:
    SparseIDArray() = default;
    SparseIDArray(SparseIDArray const& other) = default;
    SparseIDArray(SparseIDArray&& other) = default;
 
    T* findData(uint8_t x, uint8_t y, uint8_t z);
    T const* findData(uint8_t x, uint8_t y, uint8_t z) const;
};
 
}
 
#include "SparseIDArray.ipp"
 
#endif // _VOXOMAP_SPARSEIDARRAY_HPP_