Iterator.h

Go to the documentation of this file.

// Copyright 2025 Julien Lamy, ICube, Université de Strasbourg-CNRS.
// Part of msl, distributed under the terms of the MIT license.
 
#ifndef _3608ae00_0c4a_4bb2_a439_7094206b302f
#define _3608ae00_0c4a_4bb2_a439_7094206b302f
 
#include "Counter.h"
 
namespace msl
{

template<typename T>
class ConstIterator
{
public:
    ConstIterator(T const & container={})
    : _counter(0), _container()
    {
        this->setContainer(container);
    }
    
    ConstIterator(ConstIterator<T> const &) = default;
    ConstIterator(ConstIterator<T> &&) = default;
    ConstIterator<T> & operator=(ConstIterator<T> const &) = default;
    ConstIterator<T> & operator=(ConstIterator<T> &&) = default;
    virtual ~ConstIterator() = default;
    
    T const & container() const
    {
        return this->_container;
    }
    
    void setContainer(T const & container)
    {
        this->_counter.setEnd(container.size());
        this->_counter.reset();
        
        this->_container = container;
    }
    
    std::size_t index() const
    {
        return this->_counter.index();
    }
    
    typename T::value_type const & item() const
    {
        return this->_container[this->_counter.index()];
    }
    
    std::size_t end() const
    {
        return this->_counter.end();
    }
    
    ConstIterator & reset()
    {
        this->_counter.reset();
        return *this;
    }
    
    ConstIterator & operator++()
    {
        ++this->_counter;
        return *this;
    }
    
    bool first() const
    {
        return this->_counter.first();
    }
    
    bool last() const
    {
        return this->_counter.last();
    }
    
    bool done() const
    {
        return this->_counter.done();
    }
    
protected:
    Counter _counter;
    T _container;
};

template<typename T>
class Iterator: public ConstIterator<T>
{
public:
    Iterator(T const & container={})
    : ConstIterator<T>(container)
    {
        // Nothing else
    }
    
    Iterator(Iterator<T> const &) = default;
    Iterator(Iterator<T> &&) = default;
    Iterator<T> & operator=(Iterator<T> const &) = default;
    Iterator<T> & operator=(Iterator<T> &&) = default;
    
    typename T::value_type & item()
    {
        return this->_container[this->_counter.index()];
    }
};
 
}
 
#endif // _3608ae00_0c4a_4bb2_a439_7094206b302f