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

#include <algorithm>
#include <vector>
#include "index_map/index_maps.hpp"

namespace pni{
namespace core{

    template<
             typename INDEXT,
             typename IMT
            > 
    class index_iterator
    {
        public:
            //===================public types==================================
            typedef IMT map_type;
            typedef INDEXT index_type;
            typedef index_type value_type;
            typedef const value_type* pointer;
            typedef const value_type& reference;
            typedef const value_type* cptr_type;
            typedef ssize_t difference_type;
            typedef index_iterator<index_type,map_type> iterator_type;
        private:
            map_type _index_map;
            ssize_t _state;
            index_type _index;

        public:
            //===================constructors and destructor===================
            index_iterator();

            //-----------------------------------------------------------------
            template<typename CTYPE>
            index_iterator(const CTYPE &shape,size_t state=0):
                _index_map(map_utils<map_type>::create(shape)),
                _state(state),
                _index(shape.size())
            {}

            //====================factory to create an index iterator==========
            template<typename CTYPE>
            static iterator_type begin(const CTYPE &shape)
            {
                return index_iterator(shape);
            }

            //-----------------------------------------------------------------
            template<typename CTYPE>
            static iterator_type end(const CTYPE &shape)
            {
                size_t size=std::accumulate(shape.begin(),shape.end(),size_t(1),
                            std::multiplies<size_t>());;

                return index_iterator(shape,size);
            }

            //===================public member functions=======================
            value_type operator*()
            {
                return _index;
            }

            //-----------------------------------------------------------------
            pointer operator->()
            {
                return &_index;
            }

            //-----------------------------------------------------------------
            iterator_type &operator++()
            {
                _state++;
                if(_state < ssize_t(_index_map.max_elements()))
                    _index = _index_map.template index<index_type>(_state);
                return *this;
            }

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

            //-----------------------------------------------------------------
            iterator_type &operator--()
            {
                _state--;
                if(this->_state>=0)
                    _index = _index_map.template index<index_type>(_state);

                return *this;
            }

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

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

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


//end of namespace 
}
}