array_view.hpp

//
// (c) Copyright 2011 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 14, 2012
//     Author: Eugen Wintersberger <eugen.wintersberger@desy.de>
//


#pragma once

#include <memory>
#include <functional>
#include "index_map/index_maps.hpp"
#include "../utilities.hpp"
#include "array_selection.hpp"
#include "array_view_utils.hpp"
#include "../algorithms.hpp"

namespace pni{
namespace core{
    

    template<typename ATYPE> 
    class array_view
    {
        public:
            //====================public types=================================
            typedef ATYPE storage_type;
            typedef typename ATYPE::value_type value_type;             
            typedef array_view<storage_type> array_type;
            typedef std::shared_ptr<array_type> shared_ptr;
            typedef std::unique_ptr<array_type> unique_ptr; 
            typedef container_iterator<array_type> iterator;      
            typedef container_iterator<const array_type> const_iterator; 
            typedef array_view<array_type> view_type;
            typedef std::vector<size_t> index_type;
            typedef typename ATYPE::inplace_arithmetic inplace_arithmetic;
            typedef index_map<index_type,typename ATYPE::map_type::implementation_type> map_type;
            //========================public members===========================
            static const type_id_t type_id = ATYPE::type_id;
        private:
            std::reference_wrapper<ATYPE> _parray; 
            array_selection _selection;
            //view not the original array.
            map_type _imap;
            mutable index_type _index;
            bool _is_contiguous;

            size_t _start_offset;

        public:
            //-----------------------------------------------------------------
            array_view(storage_type &a,const array_selection &s):
                _parray(std::ref(a)),
                _selection(s),
                _imap(map_utils<map_type>::create(_selection.shape<index_type>())),
                _index(a.rank()),
                _is_contiguous(pni::core::is_contiguous(a.map(),_selection)),
                _start_offset(start_offset(a.map(),_selection))
            { }

            //------------------------------------------------------------------
            array_view(storage_type &a,array_selection &&s):
                _parray(std::ref(a)),
                _selection(std::move(s)),
                _imap(map_utils<map_type>::create(_selection.shape<index_type>())),
                _index(a.rank()),
                _is_contiguous(pni::core::is_contiguous(a.map(),_selection)),
                _start_offset(start_offset(a.map(),_selection))
            {}


            //-----------------------------------------------------------------
            array_view(const array_type &c):
                _parray(c._parray),
                _selection(c._selection),
                _imap(c._imap),
                _index(c._index),
                _is_contiguous(c._is_contiguous),
                _start_offset(c._start_offset)
            {}

            //-----------------------------------------------------------------
            array_view(array_type &&c):
                _parray(std::move(c._parray)),
                _selection(std::move(c._selection)),
                _imap(std::move(c._imap)),
                _index(std::move(c._index)),
                _is_contiguous(c._is_contiguous),
                _start_offset(c._start_offset)
            {}

            //-----------------------------------------------------------------
            template<typename ETYPE>
            array_type &operator=(const ETYPE &e)
            {
                if((void*)this == (void*)&e) return *this;
               
                //for(size_t i=0;i<size();++i) (*this)[i] = e[i];
                std::copy(e.begin(),e.end(),this->begin());

                return *this;
            }


            //-----------------------------------------------------------------
            array_type &operator=(array_type &&a)
            {
                if(this == &a) return *this;

                _parray = std::move(a._parray);
                _selection = std::move(a._selection);
                _imap = std::move(a._imap);
                _index = std::move(a._index);
                _is_contiguous = a._is_contiguous;
                _start_offset  = a._start_offset;

                return *this;
            }

            //==================public member functions========================
            template<
                     typename CTYPE,
                     typename = typename enable_element_cont<CTYPE>::type
                    >
            value_type &operator()(const CTYPE &index)
            {
                typedef typename ATYPE::map_type omap_type;
                auto &ref = _parray.get();

                if(_is_contiguous)
                    return ref[_start_offset + _imap.offset(index)];
                else
                {
                    auto  map = const_cast<omap_type&>(ref.map());
                    size_t o = map.offset(_selection,index);
                    return ref[o];
                }
            }

            //-----------------------------------------------------------------
            template<
                     typename CTYPE,
                     typename = typename enable_element_cont<CTYPE>::type
                    >
            value_type operator()(const CTYPE &index) const
            {
                typedef typename ATYPE::map_type omap_type;
                auto &ref = _parray.get();

                if(_is_contiguous)
                    return ref[_start_offset + _imap.offset(index)];
                else
                {
                    auto  map = const_cast<omap_type&>(ref.map());
                    size_t o = map.offset(_selection,index);
                    return ref[o];
                }
            }


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

            template<typename ...ITypes> 
            value_type & operator()(ITypes ...indices)
            {
                typedef typename ATYPE::map_type omap_type;
                auto &ref = _parray.get();

                if(_is_contiguous)
                    return ref[_start_offset +
                               _imap.offset(IDX_ARRAY(ITypes,indices))];
                else
                {
                    auto  map = const_cast<omap_type&>(ref.map());
                    size_t o = map.offset(_selection,IDX_ARRAY(ITypes,indices));
                    return ref[o];
                }

            }

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

            template<typename ...ITypes> 
            value_type operator()(ITypes ...indices) const
            {
                typedef typename ATYPE::map_type omap_type;
                auto &ref = _parray.get();

                if(_is_contiguous)
                    return ref[_start_offset + 
                               _imap.offset(IDX_ARRAY(ITypes,indices))];
                else
                {
                    //have to do some more work here
                    auto map = const_cast<omap_type&>(ref.map());
                    return ref[map.offset(_selection,IDX_ARRAY(ITypes,indices))];
                }
            }

            //-----------------------------------------------------------------
            template<typename CTYPE> CTYPE shape() const
            {
                return _selection.template shape<CTYPE>();
            }

            //-----------------------------------------------------------------
            value_type &operator[](size_t i)
            {
#ifdef DEBUG
                check_index_in_dim(i,size(),EXCEPTION_RECORD);
#endif
                //compute the multidimensional index in the original array for
                //the linear index i in the view
                if(_is_contiguous) return _parray.get()[i+_start_offset];
                else
                {
                    auto index = _imap.template index<index_type>(i);
                    return (*this)(index); 
                }
            }

            //-----------------------------------------------------------------
            
            value_type operator[](size_t i) const
            {
#ifdef DEBUG
                check_index_in_dim(i,size(),EXCEPTION_RECORD);
#endif
                if(_is_contiguous) return _parray.get()[i+_start_offset];
                else
                {
                    //compute the multidimensional index in the original array for
                    //the linear index i in the view
                    auto index = _imap.template index<index_type>(i);
                    return (*this)(index); 
                }
            }

            //-----------------------------------------------------------------
            const value_type *data() const
            {
                if(_is_contiguous) 
                    return &_parray.get()[_start_offset];
                else
                    throw shape_mismatch_error(EXCEPTION_RECORD,
                            "Selection view is not contiguous!");
            }

            //-----------------------------------------------------------------
            value_type *data() 
            {
                if(_is_contiguous) 
                    return &_parray.get()[_start_offset];
                else
                    throw shape_mismatch_error(EXCEPTION_RECORD,
                            "Selection view is not contiguous!");
            }

            //-----------------------------------------------------------------
            value_type &at(size_t i) 
            { 
                check_index_in_dim(i,size(),EXCEPTION_RECORD); 
                return (*this)[i]; 
            }

            //-----------------------------------------------------------------
            value_type at(size_t i) const 
            { 
                check_index_in_dim(i,size(),EXCEPTION_RECORD);
                return (*this)[i]; 
            }

            //-----------------------------------------------------------------
            void insert(size_t i,const value_type &v) { at(i) = v; }

            //-----------------------------------------------------------------
            value_type &front() { return at(0); }

            //-----------------------------------------------------------------
            value_type front() const { return at(0); }

            //-----------------------------------------------------------------
            value_type &back() { return at(size()-1); }

            //-----------------------------------------------------------------
            value_type back() const { return at(size()-1); }

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

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

            //-----------------------------------------------------------------
            iterator begin() { return iterator(this,0); }

            //-----------------------------------------------------------------
            iterator end() { return iterator(this,this->size()); }
           
            //-----------------------------------------------------------------
            const_iterator begin() const { return const_iterator(this,0); }

            //-----------------------------------------------------------------
            const_iterator end() const { return const_iterator(this,size()); }
            
            //==========implementation of unary arithmetic operators===========

            array_type &operator+=(value_type s) 
            { 
                storage_type::inplace_arithmetic::add(*this,s); 
                return *this;
            }

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

            template<typename RTYPE> 
            array_type &operator+=(const RTYPE &v) 
            { 
                storage_type::inplace_arithmetic::add(*this,v); 
                return *this;
            }

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

            array_type &operator-=(value_type s) 
            { 
                storage_type::inplace_arithmetic::sub(*this,s); 
                return *this;
            }

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

            template<typename RTYPE> 
            array_type &operator-=(const RTYPE &v) 
            { 
                storage_type::inplace_arithmetic::sub(*this,v); 
                return *this;
            }

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

            array_type &operator*=(value_type s) 
            { 
                storage_type::inplace_arithmetic::mult(*this,s); 
                return *this;
            }

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

            template<typename RTYPE>
            array_type &operator*=(const RTYPE &v) 
            { 
                storage_type::inplace_arithmetic::mult(*this,v); 
                return *this;
            }

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

            array_type &operator/=(value_type s) 
            {
                storage_type::inplace_arithmetic::div(*this,s); 
                return *this;
            }

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

            template<typename RTYPE>
            array_type &operator/=(const RTYPE &v) 
            { 
                storage_type::inplace_arithmetic::div(*this,v); 
                return *this;
            }

            //-----------------------------------------------------------------
            const map_type &map() const
            {
                return _imap;
            }

            //-----------------------------------------------------------------
            bool is_contiguous() const
            {
                return _is_contiguous;
            }
    };

    //------------------------------------------------------------------------
    template<typename ATYPE>
    type_id_t type_id(const array_view<ATYPE> &)
    {
        return type_id_map<typename ATYPE::value_type>::type_id;
    }

    //------------------------------------------------------------------------
    template<typename ATYPE> 
    struct container_trait<array_view<ATYPE>>
    {
        static const bool is_random_access = true;
        static const bool is_iterable = true;
        static const bool is_contiguous = false;
        static const bool is_multidim = true;
    };

    //------------------------------------------------------------------------
    template<typename ATYPE>
    bool operator==(const array_view<ATYPE> &a,const array_view<ATYPE> &b)
    {
        if(a.size()!=b.size())
            throw size_mismatch_error(EXCEPTION_RECORD,
                    "Array view sizes do not match!");

        return std::equal(a.begin(),a.end(),b.begin());
    }

    //------------------------------------------------------------------------
    template<typename ATYPE>
    bool operator!=(const array_view<ATYPE> &a,const array_view<ATYPE> &b)
    {
        return !(a==b);
    }

    //------------------------------------------------------------------------
    template<typename ATYPE>
    std::ostream &operator<<(std::ostream &stream,const array_view<ATYPE> &v)
    {
        for(auto x: v) stream<<x<<" ";

        return stream;
    }

    //------------------------------------------------------------------------
    template<typename ATYPE>
    std::istream &operator>>(std::istream &stream,array_view<ATYPE> &v)
    {
        for(auto &x: v) stream>>x;

        return stream;
    }

//end of namespace
}
}