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;
    }
};