container_iterator.hpp

 
#ifndef UFO_CONTAINER_TREE_CONTAINER_ITERATOR_HPP
#define UFO_CONTAINER_TREE_CONTAINER_ITERATOR_HPP
 
// STL
#include <iterator>
#include <type_traits>
 
namespace ufo
{
// Forward declare
template <class... Ts>
class TreeContainer;
 
template <class T, bool Const, class... Ts>
class TreeContainterIterator
{
 private:
    //
    // Friends
    //
 
    friend class TreeContainterIterator<T, !Const, Ts...>;
 
    friend class TreeContainer<Ts...>;
 
 public:
    //
    // Tags
    //
 
    using iterator_category = std::random_access_iterator_tag;
    using difference_type   = std::ptrdiff_t;
    using value_type        = T;
    using pointer           = std::conditional_t<Const, T const*, T*>;
    using reference         = std::conditional_t<Const, T const&, T&>;
 
    TreeContainterIterator() = default;
 
    TreeContainterIterator(TreeContainterIterator const&) = default;
 
    template <bool Const2, class = std::enable_if_t<Const && !Const2>>
    TreeContainterIterator(TreeContainterIterator<T, Const2, Ts...> const& other)
        : container_(other.container_), idx_(other.idx_)
    {
    }
 
    TreeContainterIterator& operator++()
    {
        ++idx_;
        return *this;
    }
 
    TreeContainterIterator& operator--()
    {
        --idx_;
        return *this;
    }
 
    TreeContainterIterator operator++(int)
    {
        TreeContainterIterator tmp(*this);
        ++*this;
        return tmp;
    }
 
    TreeContainterIterator operator--(int)
    {
        TreeContainterIterator tmp(*this);
        --*this;
        return tmp;
    }
 
    TreeContainterIterator& operator+=(difference_type n)
    {
        idx_ += n;
        return *this;
    }
 
    TreeContainterIterator& operator-=(difference_type n)
    {
        idx_ -= n;
        return *this;
    }
 
    TreeContainterIterator operator+(difference_type n)
    {
        TreeContainterIterator tmp(*this);
        tmp += n;
        return tmp;
    }
 
    TreeContainterIterator operator-(difference_type n)
    {
        TreeContainterIterator tmp(*this);
        tmp -= n;
        return tmp;
    }
 
    reference operator[](difference_type pos) const
    {
        return container_->template get<T>(idx_ + pos);
    }
 
    reference operator*() const { return container_->template get<T>(idx_); }
 
    pointer operator->() const { return &(container_->template get<T>(idx_)); }
 
    template <bool Const1, bool Const2>
    friend difference_type operator-(TreeContainterIterator<T, Const1, Ts...> const& lhs,
                                     TreeContainterIterator<T, Const2, Ts...> const& rhs)
    {
        return lhs.idx_ - rhs.idx_;
    }
 
    template <bool Const1, bool Const2>
    friend bool operator==(TreeContainterIterator<T, Const1, Ts...> const& lhs,
                           TreeContainterIterator<T, Const2, Ts...> const& rhs)
    {
        return lhs.idx_ == rhs.idx_;
    }
 
    template <bool Const1, bool Const2>
    friend bool operator!=(TreeContainterIterator<T, Const1, Ts...> const& lhs,
                           TreeContainterIterator<T, Const2, Ts...> const& rhs)
    {
        return lhs.idx_ != rhs.idx_;
    }
 
    template <bool Const1, bool Const2>
    friend bool operator<(TreeContainterIterator<T, Const1, Ts...> const& lhs,
                          TreeContainterIterator<T, Const2, Ts...> const& rhs)
    {
        return lhs.idx_ < rhs.idx_;
    }
 
    template <bool Const1, bool Const2>
    friend bool operator<=(TreeContainterIterator<T, Const1, Ts...> const& lhs,
                           TreeContainterIterator<T, Const2, Ts...> const& rhs)
    {
        return lhs.idx_ <= rhs.idx_;
    }
 
    template <bool Const1, bool Const2>
    friend bool operator>(TreeContainterIterator<T, Const1, Ts...> const& lhs,
                          TreeContainterIterator<T, Const2, Ts...> const& rhs)
    {
        return lhs.idx_ > rhs.idx_;
    }
 
    template <bool Const1, bool Const2>
    friend bool operator>=(TreeContainterIterator<T, Const1, Ts...> const& lhs,
                           TreeContainterIterator<T, Const2, Ts...> const& rhs)
    {
        return lhs.idx_ >= rhs.idx_;
    }
 
 protected:
    TreeContainterIterator(TreeContainer<Ts...>* container, difference_type idx)
        : container_(container), idx_(idx)
    {
    }
 
    TreeContainterIterator(TreeContainer<Ts...>& container, difference_type idx)
        : TreeContainterIterator(&container, idx)
    {
    }
 
 private:
    TreeContainer<Ts...>* container_ = nullptr;
 
    difference_type idx_;
};
}  // namespace ufo
 
#endif  // UFO_CONTAINER_TREE_CONTAINER_ITERATOR_HPP