array_view_utils.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: Nov 20, 2013
//     Author: Eugen Wintersberger <eugen.wintersberger@desy.de>
//

#pragma once

#include <vector>
#include <array>

#include <functional>
#include <boost/mpl/contains.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/mpl/placeholders.hpp>
#include <boost/mpl/count_if.hpp>
#include <boost/mpl/size.hpp>

namespace pni{
namespace core{

    template<typename ATYPE> class array_view;
    
    //==============================Define some useful macros===================
#define IDX_ARRAY(IT,i)\
    std::array<size_t,sizeof...(IT)>{{size_t(i)...}}

    template<typename T>
    struct is_index_type
    {
        static const bool value = std::is_integral<T>::value || 
                                  std::is_same<T,slice>::value;
    };

    //-------------------------------------------------------------------------
    template<typename ...ITYPES>
    struct is_index_types
    {
        template<typename T> 
        struct is_index_type_pred
        {
            typedef is_index_type<T> type;
        };

        using _ = boost::mpl::placeholders::_;
        typedef typename boost::mpl::vector<ITYPES...> types;

        typedef boost::mpl::count_if<types,is_index_type_pred<_>> n_index_types;

        static const bool value = n_index_types::value ==
            int(boost::mpl::size<types>::value);
    };

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

    template<typename ...ITYPES> 
    struct is_view_index
    {
        typedef typename boost::mpl::contains<
                                   typename boost::mpl::vector<ITYPES...>::type,
                                   slice
                                  >::type type;

        static const bool value = type::value;
    };

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

    template<typename ...ITYPES> 
    struct is_valid_index
    {
        typedef typename boost::mpl::contains<
            typename boost::mpl::vector<ITYPES...>::type,slice>::type has_slice;
        typedef typename boost::mpl::contains<
            typename boost::mpl::vector<ITYPES...>::type,size_t>::type
            has_size_t;

        static const bool value = has_slice::value || has_size_t::value;
    };


    //-------------------------------------------------------------------------
    template<typename CTYPE> struct is_view_cont
    {
        static const bool value = false;
    };
   
    //-------------------------------------------------------------------------
    template<typename T> struct is_view_cont<std::vector<T>>
    {
        static const bool value = std::is_same<T,slice>::value;
    };

    //------------------------------------------------------------------------
    template<typename T,size_t N> struct is_view_cont<std::array<T,N>>
    {
        static const bool value = std::is_same<T,slice>::value;
    };
  
    //-------------------------------------------------------------------------
    template<
             typename ATYPE,
             bool is_view
            > 
    struct array_view_trait;

    //-------------------------------------------------------------------------
    template<typename ATYPE> 
    struct array_view_trait<ATYPE,true>    
    {
        typedef array_view<ATYPE> type;
        typedef array_view<const ATYPE> const_type;
    };

    //-------------------------------------------------------------------------
    template<typename ATYPE> 
    struct array_view_trait<ATYPE,false>
    {
        typedef typename ATYPE::value_type& type;
        typedef typename ATYPE::value_type  const_type;

    };

template<typename CTYPE>
    using enable_element_cont = std::enable_if<!is_index_type<CTYPE>::value && 
                                               !is_view_cont<CTYPE>::value >;

template<typename CTYPE>
    using enable_view_cont = std::enable_if<!is_index_type<CTYPE>::value && 
                                            is_view_cont<CTYPE>::value >;

    //-------------------------------------------------------------------------
    template<
             typename RTYPE,
             bool is_view
            > 
    struct view_provider;

    //-------------------------------------------------------------------------
    template<typename ATYPE> 
    struct view_provider<ATYPE,false>
    {
        typedef typename array_view_trait<ATYPE,false>::type ref_type;
        typedef typename array_view_trait<ATYPE,false>::const_type type;
       
        //---------------------------------------------------------------------
        template<
                 typename CTYPE,
                 typename MAP,
                 typename... ITYPES
                > 
        static ref_type get_reference(CTYPE &c,MAP &map,ITYPES ...indexes)
        {
            typedef std::array<size_t,sizeof...(ITYPES)> array_type; 
#ifdef DEBUG
            array_type buffer{{size_t(indexes)...}};
            check_indexes(buffer,map,EXCEPTION_RECORD);
#endif

            size_t offset = map.offset(array_type{{size_t(indexes)...}});
            return c[offset];
        }

        //---------------------------------------------------------------------
        template<
                 typename CTYPE,
                 typename MAP,
                 typename ...ITYPES
                >
        static type get_value(const CTYPE &c,MAP &map,ITYPES ...indexes)
        {
            typedef std::array<size_t,sizeof...(ITYPES)> array_type;
#ifdef DEBUG
            array_type buffer{{size_t(indexes)...}};
            check_indexes(buffer,map,EXCEPTION_RECORD);
#endif

            size_t offset = map.offset(array_type{{size_t(indexes)...}});
            return c[offset];
        }

    };
  
    //-------------------------------------------------------------------------
    template<typename ATYPE> 
    struct view_provider<ATYPE,true>
    {
        typedef typename array_view_trait<ATYPE,true>::type ref_type;
        typedef typename array_view_trait<ATYPE,true>::const_type type;
       
        //---------------------------------------------------------------------
        template<
                 typename CTYPE,
                 typename MAP,
                 typename... ITYPES
                > 
        static ref_type get_reference(CTYPE &c,MAP &,ITYPES ...indexes)
        {
            typedef std::array<slice,sizeof...(ITYPES)> array_type; 

            return ref_type(c,array_selection::create(
                            array_type{{slice(indexes)...}}));
        }


        //---------------------------------------------------------------------
        template<
                 typename CTYPE,
                 typename MAP,
                 typename ...ITYPES
                >
        static type get_value(const CTYPE &c,MAP &,ITYPES ...indexes)
        {
            typedef std::array<slice,sizeof...(ITYPES)> array_type;

            return type(c,array_selection::create(
                        array_type{{slice(indexes)...}}));
        }

    };

template<typename ATYPE,
         typename ...ITYPES
        >
    using view_type_trait = array_view_trait<ATYPE,
                                       is_view_index<ITYPES...>::value>;

template<typename ...ITYPES>
    using enable_valid_index = std::enable_if<is_index_types<ITYPES...>::value>;
//end of namespace
}
}