StableVector.hpp

Go to the documentation of this file.

 
/*
 * StableVector.hpp
 *
 *  @date 08.06.2017
 *  @author Johan M. von Behren <johan@vonbehren.eu>
 */
 
#ifndef LVR2_ATTRMAPS_STABLEVECTOR_H_
#define LVR2_ATTRMAPS_STABLEVECTOR_H_
 
#include <vector>
#include <utility>
#include <boost/optional.hpp>
#include <boost/shared_array.hpp>
 
using std::move;
using std::vector;
 
 
#include "lvr2/util/BaseHandle.hpp"
#include "lvr2/geometry/Handles.hpp"
 
 
namespace lvr2
{
 
template<typename HandleT, typename ElemT>
class StableVectorIterator
{
private:
    const vector<boost::optional<ElemT>>* m_elements;
 
    size_t m_pos;
public:
    StableVectorIterator(const vector<boost::optional<ElemT>>* deleted, bool startAtEnd = false);
 
    StableVectorIterator& operator=(const StableVectorIterator& other);
    bool operator==(const StableVectorIterator& other) const;
    bool operator!=(const StableVectorIterator& other) const;
 
    StableVectorIterator& operator++();
 
    bool isAtEnd() const;
 
    HandleT operator*() const;
};
 
template<typename HandleT, typename ElemT>
class StableVector
{
    static_assert(
        std::is_base_of<BaseHandle<Index>, HandleT>::value,
        "HandleT must inherit from BaseHandle!"
    );
 
public:
 
    using ElementType = ElemT;
    using HandleType = HandleT;
 
    StableVector() : m_usedCount(0) {};
 
    StableVector(size_t countElements, const ElementType& defaultValue);
 
    StableVector(size_t countElements, const boost::shared_array<ElementType>& sharedArray);
 
    HandleType push(const ElementType& elem);
 
    HandleType push(ElementType&& elem);
 
    void increaseSize(HandleType upTo);
 
    void increaseSize(HandleType upTo, const ElementType& elem);
 
    HandleType nextHandle() const;
 
    void erase(HandleType handle);
 
    void clear();
 
    boost::optional<ElementType&> get(HandleType handle);
 
    boost::optional<const ElementType&> get(HandleType handle) const;
 
    void set(HandleType handle, const ElementType& elem);
 
    void set(HandleType handle, ElementType&& elem);
 
    ElementType& operator[](HandleType handle);
 
    const ElementType& operator[](HandleType handle) const;
 
    size_t size() const;
 
    size_t numUsed() const;
 
    StableVectorIterator<HandleType, ElementType> begin() const;
 
    StableVectorIterator<HandleType, ElementType> end() const;
 
    void reserve(size_t newCap);
 
private:
    size_t m_usedCount;
 
    vector<boost::optional<ElementType>> m_elements;
 
    void checkAccess(HandleType handle) const;
};
 
} // namespace lvr2
 
#include "lvr2/attrmaps/StableVector.tcc"
 
#endif /* LVR2_ATTRMAPS_STABLEVECTOR_H_ */