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_ */