scalar_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: Dec 2, 2013
//     Author: Eugen Wintersberger <eugen.wintersberger@desy.de>
//
#pragma once

#include <type_traits>
#include "../error/exceptions.hpp" 

namespace pni{
namespace core{


    template<typename ITERABLE> 
    class scalar_iterator
    {
        private:
            ITERABLE* _container;

            ssize_t _state;

            //removing a possible const-ness
            typedef typename std::remove_const<ITERABLE>::type container_type;
        public:
            //====================public types==================================
            typedef scalar_iterator<ITERABLE> iterator_type;
            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;
            //================constructor and destructor========================
            scalar_iterator(ITERABLE *container,size_t state=0):
                _container(container),
                _state(state)
            { }

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

            //====================public methods and operators==================
            explicit operator bool() const { return true; }
            //------------------------------------------------------------------
            reference operator*() { return (*_container)[_state]; }

            //------------------------------------------------------------------
            pointer operator->() { return &((*_container)[_state]); }

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

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

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

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

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

            //------------------------------------------------------------------
            iterator_type &operator-=(ssize_t i)
            {
                this->_state -= i;
                return *this;
            }
            //------------------------------------------------------------------
            bool operator==(const iterator_type &a)
            {
                //return true only if this is the same iterator instance
                if(this == &a) return true; 
                return false;
            }

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

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

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

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

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

            ssize_t state() const { return this->_state; }

    };

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

    template<typename ITERABLE>
    scalar_iterator<ITERABLE> 
    operator+(const scalar_iterator<ITERABLE> &a, ssize_t b)
    {
        scalar_iterator<ITERABLE> iter = a;
        iter += b;
        return iter;
    }

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

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

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

//end of namespace
}
}