index_map.hpp

#pragma once
#include <algorithm>
#include <numeric>

#include "../../utilities/container_utils.hpp"

namespace pni{
namespace core{

    class array_selection;


    template<
             typename SHAPE_STORE,
             typename MAP_IMP
            > 
    class index_map
    {
        public:
            //=================public types====================================
            typedef SHAPE_STORE storage_type;
            typedef typename storage_type::value_type value_type;
            typedef MAP_IMP     implementation_type;
            typedef typename storage_type::iterator iterator;
            typedef typename storage_type::const_iterator const_iterator;
            typedef index_map<storage_type,implementation_type> map_type;
        private:
            storage_type _shape;
        public:
            //-----------------------------------------------------------------
            index_map():_shape() {}

            //-----------------------------------------------------------------
            index_map(const map_type &m):_shape(m._shape) {}

            //-----------------------------------------------------------------
            index_map(map_type &&m):_shape(std::move(m._shape)) 
            {
                std::fill(m._shape.begin(),m._shape.end(),0); 
            }

            //-----------------------------------------------------------------

            explicit index_map(const storage_type &s):_shape(s) {}

            //-----------------------------------------------------------------

            explicit index_map(storage_type &&s):_shape(std::move(s)) {}

            //-----------------------------------------------------------------
            map_type &operator=(const map_type &m)
            {
                if(this == &m) return *this;
                _shape = m._shape;

                return *this;
            }

            //-----------------------------------------------------------------
            map_type &operator=(map_type &&m)
            {
                if(this == &m) return *this;
                _shape = std::move(m._shape);
                std::fill(m._shape.begin(),m._shape.end(),0);

                return *this;
            }

            //-----------------------------------------------------------------
            size_t max_elements() const
            {
                if(_shape.size() == 0) return 0;
                else
                    return std::accumulate(_shape.begin(),_shape.end(),1,
                                           std::multiplies<size_t>()); 
            }

            //-----------------------------------------------------------------
            size_t rank() const { return _shape.size(); }

            //----------------------------------------------------------------
            size_t size() const { return rank(); }

            //-----------------------------------------------------------------

            template<
                     typename CTYPE,
                     typename = typename std::enable_if<
                     std::is_compound<
                     typename std::remove_reference<CTYPE>::type
                     >::value
                     >::type
                    >
            size_t offset(const CTYPE &index) const
            {
                return implementation_type::template offset(_shape,index);
            }

            //-----------------------------------------------------------------

            template<typename CTYPE,
                     typename = typename std::enable_if<
                     std::is_compound<
                     typename std::remove_reference<CTYPE>::type
                     >::value
                     >::type
                    >
            size_t offset(const array_selection &s,const CTYPE &index)
            {
                return implementation_type::template offset(s,_shape,index);
            }

            //-----------------------------------------------------------------

            template<typename CTYPE> CTYPE index(size_t offset) const
            {
                CTYPE index = container_utils<CTYPE>::create(rank()); 
                implementation_type::template index(_shape,index,offset);
                return index;

            }

            //-----------------------------------------------------------------
            iterator begin() { return _shape.begin(); }

            //-----------------------------------------------------------------
            iterator end()   { return _shape.end(); }

            //-----------------------------------------------------------------
            const_iterator begin() const { return _shape.begin(); }

            //-----------------------------------------------------------------
            const_iterator end() const { return _shape.end(); }

    };
//end of namespace
}
}