container_iterator.hpp

//
// (c) Copyright 2012 DESY, Eugen Wintersberger <eugen.wintersberger@desy.de>
//
// This file is part of libpnicore.
//
// libpnicore is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 2 of the License, or
// (at your option) any later version.
//
// libpnicore is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with libpnicore.  If not, see <http://www.gnu.org/licenses/>.
//
// ============================================================================
//
// Created on: May 16, 2012
//     Author: Eugen Wintersberger <eugen.wintersberger@desy.de>
//
#pragma once

#include "../error/exceptions.hpp" 

namespace pni{
namespace core{
   



    template<typename ITERABLE> class container_iterator
    {
        private:
            typedef typename std::remove_const<ITERABLE>::type container_type;
            typedef ITERABLE *cptr_type;
            ITERABLE *_container; 

            ssize_t _state;                    

            ssize_t _maxsize;

        public:
            //====================public types==================================
            typedef typename container_type::value_type value_type;
            typedef typename std::conditional<std::is_const<ITERABLE>::value,
                                             const value_type*,value_type*>::type pointer;
            typedef typename std::conditional<std::is_const<ITERABLE>::value,
                                              const value_type&,value_type&>::type reference;
            typedef ssize_t difference_type;
            typedef std::random_access_iterator_tag iterator_category;
            typedef container_iterator<ITERABLE> iterator_type;
            //================constructor and destructor========================
            container_iterator():_container(nullptr),_state(0),_maxsize(0) {}

            //------------------------------------------------------------------
            explicit container_iterator(cptr_type container,size_t state=0):
                _container(container),
                _state(state),
                _maxsize(container->size())
            { }

            //------------------------------------------------------------------
            container_iterator(const iterator_type &i):
                _container(i._container),
                _state(i._state),
                _maxsize(i._maxsize)
            { }

            //------------------------------------------------------------------
            container_iterator(iterator_type &&i):
                _container(i._container),
                _state(i._state),
                _maxsize(i._maxsize)
            {
                i._container = nullptr;
                i._state = 0;
                i._maxsize = 0;
            }

            //------------------------------------------------------------------
            ~container_iterator() {}

            //=================assignment operator==============================
            iterator_type &operator=(const iterator_type &i)
            {
                if(this == &i) return *this;
                _container = i._container;
                _state     = i._state;
                _maxsize   = i._maxsize;
                return *this;
            }

            //------------------------------------------------------------------
            iterator_type &operator=(iterator_type &&i)
            {
                if(this == &i) return *this;
                _container = i._container;
                i._container = nullptr;
                _state = i._state;
                i._state = 0;
                _maxsize = i._maxsize;
                i._maxsize = 0;
                return *this;
            }

            //====================public methods and operators==================
            explicit operator bool() const
            {
                return !( (!_container)|| (_state >= _maxsize)|| (_state<0));
            }
            
            //------------------------------------------------------------------
            typename std::conditional<std::is_const<ITERABLE>::value,
                                      value_type,reference>::type
            operator*()
            {
                if(!(*this))
                    throw iterator_error(EXCEPTION_RECORD,"Iterator invalid!");

                return (*(_container))[_state];
            }

            //------------------------------------------------------------------
            pointer operator->()
            {
                if(!(*this))
                    throw iterator_error(EXCEPTION_RECORD,"Iterator invalid!");

                return &(*(_container))[_state];
            }

            //------------------------------------------------------------------
            iterator_type &operator++()
            {
                _state++;
                return *this;
            }

            //------------------------------------------------------------------
            iterator_type operator++(int)
            {
                iterator_type temp = *this;
                ++(*this);
                return temp;
            }

            //------------------------------------------------------------------
            iterator_type &operator--()
            {
                _state--;
                return *this;
            }

            //------------------------------------------------------------------
            iterator_type operator--(int)
            {
                iterator_type tmp = *this;
                --(*this);
                return tmp;
            }

            //------------------------------------------------------------------
            iterator_type &operator+=(ssize_t i)
            {
                _state += i;
                return *this;
            }

            //------------------------------------------------------------------
            iterator_type &operator-=(ssize_t i)
            {
                _state -= i;
                return *this;
            }
            //------------------------------------------------------------------
            bool operator==(const iterator_type &a)
            {
                //check if the iterators point to the same container
                if(_container != a._container) return false;
                //check if the iterators point to the same element
                //within the container
                if(_state != a._state) return false;

                return true;
            }

            //------------------------------------------------------------------
            bool operator!=(const iterator_type &a)
            {
                if((*this)==a) return false;
                return true;
            }

            //===============comparison operators==============================
            bool operator<(const iterator_type &b)
            {
                return _state < b._state;
            }

            //-----------------------------------------------------------------
            bool operator<=(const iterator_type &b)
            {
                return _state <= b._state;
            }

            //-----------------------------------------------------------------
            bool operator>(const iterator_type &b)
            {
                return _state > b._state;
            }

            //-----------------------------------------------------------------
            bool operator>=(const iterator_type &b)
            {
                return _state >= b._state;
            }

            ssize_t state() const { return _state; }

    };

    //================binary arithmetic operators===============================
    template<typename ITER> 
    container_iterator<ITER> operator+(const container_iterator<ITER> &a, 
                                       ssize_t b)
    {
        container_iterator<ITER> iter = a;
        iter += b;
        return iter;
    }

    //--------------------------------------------------------------------------
    template<typename ITER> 
    container_iterator<ITER> operator+(ssize_t a, 
                                       const container_iterator<ITER> &b)
    {
        return b+a;
    }

    //--------------------------------------------------------------------------
    template<typename ITER> 
    container_iterator<ITER> operator-(const container_iterator<ITER> &a, 
                                       ssize_t b)
    {
        container_iterator<ITER> iter = a;
        iter -= b;
        return iter;
    }

    //--------------------------------------------------------------------------
    template<typename ITER> 
    ssize_t operator-(const container_iterator<ITER> &a, 
                      const container_iterator<ITER> &b)
    {
        return a.state() - b.state();
    }

//end of namespace
}
}