AttributeMap.hpp

Go to the documentation of this file.

 
/*
 * AttributeMap.hpp
 *
 *  @date 26.07.2017
 */
 
#ifndef LVR2_ATTRMAPS_ATTRIBUTEMAP_H_
#define LVR2_ATTRMAPS_ATTRIBUTEMAP_H_
 
#include <boost/optional.hpp>
#include <memory>
 
#include "lvr2/geometry/Handles.hpp"
 
namespace lvr2
{
 
// Forward declarations
template<typename> class AttributeMapHandleIteratorPtr;
 
template<typename HandleT, typename ValueT>
class AttributeMap
{
    static_assert(
        std::is_base_of<BaseHandle<Index>, HandleT>::value,
        "HandleT must inherit from BaseHandle!"
    );
 
public:
    typedef HandleT HandleType;
 
    typedef ValueT ValueType;
 
    virtual bool containsKey(HandleT key) const = 0;
 
    virtual boost::optional<ValueT> insert(HandleT key, const ValueT& value) = 0;
 
    virtual boost::optional<ValueT> erase(HandleT key) = 0;
 
    virtual void clear() = 0;
 
    virtual boost::optional<ValueT&> get(HandleT key) = 0;
 
    virtual boost::optional<const ValueT&> get(HandleT key) const = 0;
 
    virtual size_t numValues() const = 0;
 
    virtual AttributeMapHandleIteratorPtr<HandleT> begin() const = 0;
 
    virtual AttributeMapHandleIteratorPtr<HandleT> end() const = 0;
 
    ValueT& operator[](HandleT key);
 
    const ValueT& operator[](HandleT key) const;
};
 
 
template<typename HandleT>
class AttributeMapHandleIterator
{
    static_assert(
        std::is_base_of<BaseHandle<Index>, HandleT>::value,
        "HandleT must inherit from BaseHandle!"
    );
 
public:
    virtual AttributeMapHandleIterator& operator++() = 0;
    virtual bool operator==(const AttributeMapHandleIterator& other) const = 0;
    virtual bool operator!=(const AttributeMapHandleIterator& other) const = 0;
 
    virtual HandleT operator*() const = 0;
    virtual std::unique_ptr<AttributeMapHandleIterator> clone() const = 0;
 
    virtual ~AttributeMapHandleIterator() = default;
};
 
template<typename HandleT>
class AttributeMapHandleIteratorPtr
{
    static_assert(
        std::is_base_of<BaseHandle<Index>, HandleT>::value,
        "HandleT must inherit from BaseHandle!"
    );
 
public:
    AttributeMapHandleIteratorPtr(std::unique_ptr<AttributeMapHandleIterator<HandleT>> iter)
        : m_iter(std::move(iter)) {}
    AttributeMapHandleIteratorPtr(const AttributeMapHandleIteratorPtr& iteratorPtr)
        : m_iter(iteratorPtr.m_iter->clone()) {}
 
    AttributeMapHandleIteratorPtr& operator++();
    bool operator==(const AttributeMapHandleIteratorPtr& other) const;
    bool operator!=(const AttributeMapHandleIteratorPtr& other) const;
    HandleT operator*() const;
 
    virtual ~AttributeMapHandleIteratorPtr() = default;
 
private:
    std::unique_ptr<AttributeMapHandleIterator<HandleT>> m_iter;
};
 
} // namespace lvr2
 
#include "lvr2/attrmaps/AttributeMap.tcc"
 
#endif /* LVR2_ATTRMAPS_ATTRIBUTEMAP_H_ */