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