RawReader.hpp

 
#include <iostream>
#include <Grid/map_grid.hpp>
#include <fstream>
 
#define FORTRAN_STYLE 1
#define STRUCT_OF_ARRAY 2
 
template<unsigned int dim, typename Tg, typename Tr, unsigned int i>
struct meta_raw_read
{
    static inline void read(grid_cpu<dim,Tg> & gr,std::ifstream & raw)
    {
        auto it = gr.getIterator();
 
        while (it.isNext())
        {
            auto key = it.get();
 
            raw.read((char *)&gr.template get<i>(key),sizeof(Tr));
 
            ++it;
        }
    }
};
 
template<unsigned int dim, typename Tg, typename Tr ,unsigned int i, unsigned int nv>
struct meta_raw_read<dim,Tg,Tr[nv],i>
{
    static inline void read(grid_cpu<dim,Tg> & gr,std::ifstream & raw)
    {
        for (size_t k = 0 ; k < nv ; k++)
        {
            auto it = gr.getIterator();
 
            while (it.isNext())
            {
                auto key = it.get();
 
                raw.read((char *)&gr.template get<i>(key)[k],sizeof(Tr));
 
                ++it;
            }
        }
    }
};
 
template<unsigned int dim, typename Tg>
struct raw_read
{
    grid_cpu<dim,Tg> & gr;
 
    std::ifstream & fl;
 
    raw_read(grid_cpu<dim,Tg> & gr,std::ifstream & fl)
    :gr(gr),fl(fl)
    {};
 
    template<typename T>
    void operator()(T& t) const
    {
        typedef typename boost::mpl::at<typename Tg::type,boost::mpl::int_<T::value>>::type Tr;
 
        meta_raw_read<dim,Tg,Tr,T::value>::read(gr,fl);
    }
};
 
template <unsigned int dim, typename T, typename idx_type>
class GridRawReader
{
public:
 
    GridRawReader() {};
 
 
    bool read(std::string file, grid_cpu<dim,T> & gr, size_t opt = 0, size_t skip = 0)
    {
        idx_type tmp;
        std::ifstream raw;
        raw.open (file, std::ios::binary );
 
        if (raw.is_open() == false)
        {
            std::cerr << __FILE__ << ":" << __LINE__ << " error in opening the file: " << file << std::endl;
            return false;
        }
 
        // get length of file:
        raw.seekg (0, std::ios::end);
        size_t length = raw.tellg();
        raw.seekg (skip, std::ios::beg);
 
        if (opt & FORTRAN_STYLE)
            raw.read((char *)&tmp,sizeof(idx_type));
 
        size_t sz[dim];
 
        for (size_t i = 0 ; i < dim ; i++)
        {
            sz[i] = 0;
            raw.read((char *)&sz[i],sizeof(idx_type));
        }
 
        if (opt & FORTRAN_STYLE)
            raw.read((char *)&tmp,sizeof(idx_type));
 
        if (opt & FORTRAN_STYLE)
            raw.read((char *)&tmp,sizeof(idx_type));
 
        grid_sm<dim,void> gs(sz);
 
        size_t offset = 0;
        if (opt & FORTRAN_STYLE)
            offset += 2*sizeof(idx_type)*2;
 
        // Check the the file size make sense
        if (length - dim*sizeof(idx_type) - offset - skip != gs.size()*sizeof(T) )
        {
            std::cout << __FILE__ << ":" << __LINE__ << " Error the size of the raw file does not match with the calculated one" << std::endl;
            return false;
        }
 
        gr.setMemory();
 
        // resize the grid
        gr.resize(sz);
 
        if (!(opt & STRUCT_OF_ARRAY))
        {
            // read the data
            raw.read((char *)gr.getPointer(),gr.size()*sizeof(T));
            raw.close();
        }
        else
        {
            // for each property
            raw_read<dim,T> rr(gr,raw);
 
            boost::mpl::for_each< boost::mpl::range_c<int,0, T::max_prop> >(rr);
        }
 
        return true;
    }
};