index_maps.hpp

#pragma once
#include <sstream>
#include <boost/lexical_cast.hpp>
#include "index_map.hpp"
#include "static_index_map.hpp"
#include "c_index_map_imp.hpp"
#include "../../utilities/container_utils.hpp"

namespace pni{
namespace core{

    //-------------------------------------------------------------------------
    template<size_t... DIMS> 
    using static_cindex_map = static_index_map<c_index_map_imp,DIMS...>;

    //-------------------------------------------------------------------------
    typedef index_map<std::vector<size_t>,c_index_map_imp> dynamic_cindex_map;

    //-------------------------------------------------------------------------
    template<size_t NDIMS> 
    using fixed_dim_cindex_map = index_map<std::array<size_t,NDIMS>,c_index_map_imp>;

    //=================define some convienance function========================

    template<typename MAPT> struct map_utils
    {
        typedef MAPT map_type;
        typedef typename map_type::storage_type storage_type;

        template<typename CTYPE> static MAPT create(const CTYPE &c)
        {
            storage_type storage; 

            //try to create a storage type
            try
            {
                storage = container_utils<storage_type>::create(c.size());
            }
            catch(size_mismatch_error &error)
            {
                std::stringstream ss;
                ss<<"The map supports only a fixed number of dimensions ("
                    <<storage.size()<<")! However, the container you are "
                    <<"passing has ("<<c.size()<<") elements!"<<std::endl;
                throw shape_mismatch_error(EXCEPTION_RECORD,ss.str());
            }
            std::copy(c.begin(),c.end(),storage.begin());
            return MAPT(std::move(storage)); 
        }

        //---------------------------------------------------------------------
        template<typename IT> 
        static MAPT create(std::initializer_list<IT> shape)
        {
            storage_type storage;

            try
            {
                storage = container_utils<storage_type>::create(shape);
            }
            catch(size_mismatch_error &error)
            {
                throw shape_mismatch_error(EXCEPTION_RECORD,
                    "Rank of user shape ("
                    +boost::lexical_cast<string>(shape.size())+
                    ") does not match the map rank ("
                    +boost::lexical_cast<string>(map_type().rank())+")!");
            }
            std::copy(shape.begin(),shape.end(),storage.begin());
            return MAPT(std::move(storage));
        }
    };

    //-------------------------------------------------------------------------
    template<typename POLTYPE,size_t...DIMS>
    struct map_utils<static_index_map<POLTYPE,DIMS...> >
    {
        typedef static_index_map<POLTYPE,DIMS...> map_type;

        template<typename CTYPE> static map_type create(const CTYPE &c)
        {
            map_type map;
            if(c.size() != map.rank())
                throw size_mismatch_error(EXCEPTION_RECORD,
                        "rank does not match");

            if(!std::equal(map.begin(),map.end(),c.begin()))
                throw shape_mismatch_error(EXCEPTION_RECORD,
                        "Elements counts do not match!");

            return map;
        }

        //---------------------------------------------------------------------
        template<typename IT> 
        static map_type create(std::initializer_list<IT> shape)
        {
            map_type map;
            if(shape.size() != map.rank())
                throw size_mismatch_error(EXCEPTION_RECORD,
                        "rank does not match");

            if(!std::equal(map.begin(),map.end(),shape.begin()))
                throw shape_mismatch_error(EXCEPTION_RECORD,
                        "Elements counts do not match!");

            return map;
        }
        
    };

//end of namespace
}
}