VariantChannelMap.hpp

Go to the documentation of this file.

 
#pragma once
 
#ifndef LVR2_TYPES_VARIANTCHANNELMAP
#define LVR2_TYPES_VARIANTCHANNELMAP
 
#include <unordered_map>
#include <iostream>
#include <utility>
#include <memory>
#include <vector>
#include "VariantChannel.hpp"
 
namespace lvr2 {
 
template<typename... T>
class VariantChannelMap
: public std::unordered_map<std::string, VariantChannel<T...> > 
{
public:
    using key_type = std::string;
    using val_type = VariantChannel<T...>;
    using elem_type = std::pair<const key_type, val_type>;
 
    using types = std::tuple<T...>;
    using base = std::unordered_map<std::string, VariantChannel<T...> >;
    using base::base;
 
    template<class U>
    struct index_of_type {
        static constexpr std::size_t value = val_type::template index_of_type<U>::value;
    };
 
    template <std::size_t N>
    using type_of_index = typename val_type::template type_of_index<N>;
 
    static constexpr std::size_t num_types = val_type::num_types;
 
    template<typename U>
    struct iterator {
 
        using resolved_elem_type = std::pair<const key_type&, Channel<U>& >;
        using pointer = std::shared_ptr<resolved_elem_type>;
        // using pointer = elem_type*;
        using reference = elem_type&;
 
        iterator(
            typename base::iterator base_it,
            typename base::iterator end_it)
        :m_base_it(base_it),
        m_end_it(end_it)
        {
            while(m_base_it != m_end_it && m_base_it->second.which() != index_of_type<U>::value)
            {
                m_base_it++;
            }
        }
 
        resolved_elem_type operator*() const noexcept
        {
            return {
                m_base_it->first,
                m_base_it->second.template extract<U>()
            };
        }
 
        pointer operator->() const noexcept
        {
            return pointer(
                new resolved_elem_type({
                    m_base_it->first,
                    m_base_it->second.template extract<U>()
                })
            );
        }
 
        iterator<U>& operator++() noexcept
        {
            m_base_it++;
            while(m_base_it != m_end_it && m_base_it->second.which() != index_of_type<U>::value)
            {
                m_base_it++;
            }
            return *this;
        }
 
        iterator<U> operator++(int) noexcept
        {
            iterator<U> tmp(*this);
            m_base_it++;
            while(m_base_it != m_end_it && m_base_it->second.which() != index_of_type<U>::value)
            {
                m_base_it++;
            }
            return tmp;
        }
 
        inline bool operator==(const typename base::iterator& rhs) noexcept
        {
            return m_base_it == rhs;
        }
 
        inline bool operator!=(const typename base::iterator& rhs) noexcept
        {
            return m_base_it != rhs;
        }
 
        typename base::iterator operator()() const noexcept
        {
            return m_base_it;
        }
 
        typename base::iterator m_base_it;
        typename base::iterator m_end_it;
    };
 
 
    template<typename U>
    struct const_iterator {
 
        using resolved_elem_type = std::pair<const key_type&, const Channel<U>& >;
        using pointer = std::shared_ptr<resolved_elem_type>;
        // using pointer = elem_type*;
        using reference = elem_type&;
 
        const_iterator(
            typename base::const_iterator base_it,
            typename base::const_iterator end_it)
        :m_base_it(base_it),
        m_end_it(end_it)
        {
            while(m_base_it != m_end_it && m_base_it->second.which() != index_of_type<U>::value)
            {
                m_base_it++;
            }
        }
 
        resolved_elem_type operator*() const noexcept
        {
            return {
                m_base_it->first,
                m_base_it->second.template extract<U>()
            };
        }
 
        pointer operator->() const noexcept
        {
            return pointer(
                new resolved_elem_type({
                    m_base_it->first,
                    m_base_it->second.template extract<U>()
                })
            );
        }
 
        const_iterator<U>& operator++() noexcept
        {
            m_base_it++;
            while(m_base_it != m_end_it && m_base_it->second.which() != index_of_type<U>::value)
            {
                m_base_it++;
            }
            return *this;
        }
 
        const_iterator<U> operator++(int) noexcept
        {
            iterator<U> tmp(*this);
            m_base_it++;
            while(m_base_it != m_end_it && m_base_it->second.which() != index_of_type<U>::value)
            {
                m_base_it++;
            }
            return tmp;
        }
 
        inline bool operator==(const typename base::const_iterator& rhs) noexcept
        {
            return m_base_it == rhs;
        }
 
        inline bool operator!=(const typename base::const_iterator& rhs) noexcept
        {
            return m_base_it != rhs;
        }
 
        typename base::iterator operator()() const noexcept
        {
            return m_base_it;
        }
 
        typename base::const_iterator m_base_it;
        typename base::const_iterator m_end_it;
    };
 
    template<typename U>
    void add(const std::string& name, Channel<U> channel);
 
 
    template<typename U>
    void add(const std::string& name);
 
    template<typename U>
    void add(const std::string& name, size_t numElements, size_t width);
 
    template<typename U>
    Channel<U>& get(const std::string& name);
 
    template<typename U>
    const Channel<U>& get(const std::string& name) const;
 
 
    template<typename U>
    typename Channel<U>::Optional getOptional(const std::string& name);
 
    template<typename U>
    const typename Channel<U>::Optional getOptional(const std::string& name) const;
 
    int type(const std::string& name) const;
 
    template<typename U>
    bool is_type(const std::string& name) const;
 
    template<typename U>
    std::vector<std::string> keys();
 
    template<typename U>
    size_t numChannels();
 
    template<typename U>
    iterator<U> typedBegin()
    {
        typename base::iterator it_base = this->begin();
        typename base::iterator it_end = this->end();
        return iterator<U>(it_base, it_end);
    }
 
    template<typename U>
    const_iterator<U> typedBegin() const
    {
        typename base::const_iterator it_base = this->begin();
        typename base::const_iterator it_end = this->end();
        return const_iterator<U>(it_base, it_end);
    }
 
    using base::erase;
 
    template<typename U>
    iterator<U> erase(iterator<U> it)
    {
        typename base::iterator it_base = erase(it());
        typename base::iterator it_end = this->end();
        return iterator<U>(it_base, it_end);
    }
 
    template<typename V>
    VariantChannelMap<T...> manipulate(V visitor)
    {
        VariantChannelMap<T...> cm;
        for(auto vchannel: *this)
        {
            cm.insert({vchannel.first, boost::apply_visitor(visitor, vchannel.second)});
        }
        return cm;
    }
 
    VariantChannelMap<T...> clone() const;
 
    friend std::ostream& operator<<(std::ostream& os, const VariantChannelMap<T...>& cm)
    {
        std::cout << "[ VariantChannelMap ]\n";
        for(auto it : cm)
        {
            std::cout << it.first << ": " << it.second  << "\n";
        }
        return os;
    }
};
 
} // namespace lvr2
 
#include "VariantChannelMap.tcc"
 
#endif // LVR2_TYPES_VARIANTCHANNELMAP