VectorMap.hpp

Go to the documentation of this file.

 
/*
 * VectorMap.hpp
 *
 *  @date 08.06.2017
 *  @author Johan M. von Behren <johan@vonbehren.eu>
 */
 
#ifndef LVR2_ATTRMAPS_VECTORMAP_H_
#define LVR2_ATTRMAPS_VECTORMAP_H_
 
#include <vector>
#include <boost/optional.hpp>
 
#include "lvr2/attrmaps/StableVector.hpp"
#include "lvr2/attrmaps/AttributeMap.hpp"
#include "lvr2/geometry/Handles.hpp"
#include "lvr2/util/Cluster.hpp"
 
using std::vector;
 
 
namespace lvr2
{
 
template<typename HandleT, typename ValueT>
class VectorMap : public AttributeMap<HandleT, ValueT>
{
public:
    VectorMap() {}
 
    VectorMap(const ValueT& defaultValue);
 
    VectorMap(size_t countElements, const ValueT& defaultValue);
 
    VectorMap(size_t countElements, const boost::shared_array<ValueT>& values);
 
    // =======================================================================
    // Implemented methods from the interface (check interface for docs)
    // =======================================================================
    bool containsKey(HandleT key) const final;
    boost::optional<ValueT> insert(HandleT key, const ValueT& value) final;
    boost::optional<ValueT> erase(HandleT key) final;
    void clear() final;
    boost::optional<ValueT&> get(HandleT key) final;
    boost::optional<const ValueT&> get(HandleT key) const final;
    size_t numValues() const final;
 
    AttributeMapHandleIteratorPtr<HandleT> begin() const final;
    AttributeMapHandleIteratorPtr<HandleT> end() const final;
 
 
    void reserve(size_t newCap);
 
private:
    StableVector<HandleT, ValueT> m_vec;
    boost::optional<ValueT> m_default;
};
 
template<typename HandleT, typename ValueT>
class VectorMapIterator : public AttributeMapHandleIterator<HandleT>
{
    static_assert(
        std::is_base_of<BaseHandle<Index>, HandleT>::value,
        "HandleT must inherit from BaseHandle!"
    );
 
public:
    VectorMapIterator(StableVectorIterator<HandleT, ValueT> iter);
 
    AttributeMapHandleIterator<HandleT>& operator++() final;
    bool operator==(const AttributeMapHandleIterator<HandleT>& other) const final;
    bool operator!=(const AttributeMapHandleIterator<HandleT>& other) const final;
    HandleT operator*() const final;
    std::unique_ptr<AttributeMapHandleIterator<HandleT>> clone() const final;
 
private:
    StableVectorIterator<HandleT, ValueT> m_iter;
};
 
} // namespace lvr2
 
#include "lvr2/attrmaps/VectorMap.tcc"
 
#endif /* LVR2_ATTRMAPS_VECTORMAP_H_ */