trie_iterator.hpp

Go to the documentation of this file.

 
#if !defined(TETENGO_TRIE_TRIEITERATOR_HPP)
#define TETENGO_TRIE_TRIEITERATOR_HPP
 
#include <any>
#include <iterator>
#include <utility>
 
#include <boost/stl_interfaces/iterator_interface.hpp>
 
#include <tetengo/trie/double_array_iterator.hpp>
 
 
namespace tetengo::trie
{
    class storage;
 
 
    class trie_iterator_impl
    {
    public:
        // types
 
        // constructors and destructor
 
        trie_iterator_impl(double_array_iterator double_array_iterator_, storage& storage_);
 
        trie_iterator_impl();
 
 
        // functions
 
        [[nodiscard]] const std::any& operator*() const;
 
        [[nodiscard]] std::any& operator*();
 
        friend bool operator==(const trie_iterator_impl& one, const trie_iterator_impl& another);
 
        trie_iterator_impl& operator++();
 
 
    private:
        // variables
 
        double_array_iterator m_double_array_iterator;
 
        storage* m_p_storage;
    };
 
 
    template <typename Value>
    class trie_iterator :
    public boost::stl_interfaces::iterator_interface<trie_iterator<Value>, std ::forward_iterator_tag, Value>
    {
    public:
        // types
 
        using value_type = Value;
 
 
        // constructors and destructor
 
        trie_iterator(trie_iterator_impl&& impl) : m_impl{ std::move(impl) } {}
 
 
        // functions
 
        [[nodiscard]] const value_type& operator*() const
        {
            return *std::any_cast<value_type>(&*m_impl);
        }
 
        [[nodiscard]] value_type& operator*()
        {
            return *std::any_cast<value_type>(&*m_impl);
        }
 
        [[nodiscard]] const value_type* operator->() const
        {
            return std::any_cast<value_type>(&*m_impl);
        }
 
        [[nodiscard]] value_type* operator->()
        {
            return std::any_cast<value_type>(&*m_impl);
        }
 
        friend bool operator==(const trie_iterator& one, const trie_iterator& another)
        {
            return one.m_impl == another.m_impl;
        }
 
        trie_iterator& operator++()
        {
            ++m_impl;
            return *this;
        }
 
        trie_iterator operator++(int)
        {
            trie_iterator original{ *this };
            ++(*this);
            return original;
        }
 
 
    private:
        // variables
 
        trie_iterator_impl m_impl;
    };
 
 
}
 
 
#endif