array_iterator.hpp

//
// (c) Copyright 2013 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: Jan 16, 2013
//     Author: Eugen Wintersberger <eugen.wintersberger@desy.de>
//
#pragma once

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

namespace pni{
namespace core{

    class array;
   
    //=========================================================================
    template<int const_flag> struct array_iterator_types
    {};

    //=========================================================================
    template<> struct array_iterator_types<0>
    {
        typedef array *cont_ptr; 
        typedef value_ref value_type;
        typedef value_ref return_type;
        typedef value_ref* ptr_type;    
        typedef value_ref ref_type;
    };



    //=========================================================================
    template<> struct array_iterator_types<1>
    { 
        typedef const array *cont_ptr; 
        typedef value value_type;
        typedef value return_type;    
        typedef const value *ptr_type; 
        typedef const value &ref_type;
    };
   

    //=========================================================================

    template<int const_flag> class array_iterator
    {
        private:
            typedef array_iterator_types<const_flag> iterator_types;
            
            typename array_iterator_types<const_flag>::cont_ptr _container; 

            ssize_t _state;                    
        public:
            //====================public types==================================
            typedef typename iterator_types::value_type value_type;
            typedef typename iterator_types::ptr_type pointer;
            typedef typename iterator_types::ref_type reference;
            typedef typename iterator_types::cont_ptr cptr_type;
            typedef ssize_t difference_type;
            typedef std::random_access_iterator_tag iterator_category;
            typedef array_iterator<const_flag> iterator_type;
            //================constructor and destructor========================
            array_iterator():_container(nullptr),_state(0) {}

            //------------------------------------------------------------------
            explicit array_iterator(cptr_type container,size_t state=0):
                _container(container),
                _state(state)
            { }

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

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

            //====================public methods and operators==================
            explicit operator bool() const
            {
                //if(!this->_container) return false;
                //ssize_t size = (ssize_t)(this->_container->size());
                return !((!_container)||
                         (_state >= ssize_t(_container->size()))||
                         (_state<0));
            }

            //------------------------------------------------------------------
            typename array_iterator_types<const_flag>::return_type operator*()
            {
                if(!(*this))
                    throw iterator_error(EXCEPTION_RECORD,"Iterator invalid!");
            
                return (*_container)[_state];
            }

            //------------------------------------------------------------------
            typename array_iterator_types<const_flag>::return_type operator*()
                const
            {
                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 this->_state; }

    };

    //================binary arithmetic operators===============================

    template<int const_flag> 
    array_iterator<const_flag> operator+(const array_iterator<const_flag> &a, 
                                         ssize_t b)
    {
        array_iterator<const_flag> iter = a;
        iter += b;
        return iter;
    }

    //--------------------------------------------------------------------------
    template<int const_flag> 
    array_iterator<const_flag> operator+(ssize_t a, 
                                         const array_iterator<const_flag> &b)
    {
        return b+a;
    }

    //--------------------------------------------------------------------------
    template<int const_flag> 
    array_iterator<const_flag> operator-(const array_iterator<const_flag> &a, 
                                          ssize_t b)
    {
        array_iterator<const_flag> iter = a;
        iter -= b;
        return iter;
    }

    //--------------------------------------------------------------------------
    template<int const_flag>
    ssize_t operator-(const array_iterator<const_flag> &a, 
                      const array_iterator<const_flag> &b)
    {
        return a.state() - b.state();
    }

//end of namespace
}
}