Packer.hpp

/*
 * Packer_cls.hpp
 *
 *  Created on: Jul 15, 2015
 *      Author: i-bird
 */

#ifndef SRC_PACKER_HPP_
#define SRC_PACKER_HPP_

#include "util/object_util.hpp"
//#include "Grid/util.hpp"
#include "Vector/util.hpp"
#include "memory/ExtPreAlloc.hpp"
#include "util/util_debug.hpp"

#ifdef SRC_PACK_SELECTOR_HPP_
#error blabla
#endif

#include "Grid/grid_sm.hpp"
#include "util/Pack_stat.hpp"
#include "Pack_selector.hpp"
//#include "Vector/map_vector.hpp"

template<typename T, typename Mem, int pack_type=Pack_selector<T>::value >
class Packer
{
public:

    static void pack(ExtPreAlloc<Mem> , const T & obj)
    {
        std::cerr << "Error: " << __FILE__ << ":" << __LINE__ << " packing for the type " << demangle(typeid(T).name()) << " is not implemented\n";
    }

    static size_t packRequest(std::vector<size_t> & req)
    {
        std::cerr << "Error: " << __FILE__ << ":" << __LINE__ << " packing for the type " << demangle(typeid(T).name()) << " is not implemented\n";
        return 0;
    }
};

template<typename T, typename Mem>
class Packer<T,Mem,PACKER_PRIMITIVE>
{
public:

    inline static void pack(ExtPreAlloc<Mem> & ext, const T & obj, Pack_stat & sts)
    {
        ext.allocate(sizeof(T));
        *(T *)ext.getPointer() = obj;

        // update statistic
        sts.incReq();
    }

    static void packRequest(std::vector<size_t> & req)
    {
        req.push_back(sizeof(T));
    }
};

template<typename T, typename Mem>
class Packer<T,Mem,PACKER_ARRAY_PRIMITIVE>
{
public:

    inline static void pack(ExtPreAlloc<Mem> & ext, const T & obj, Pack_stat & sts, size_t n)
    {
        //Pack the size of a vector
        Packer<size_t, Mem>::pack(ext,obj.size(),sts);

        //Pack a vector
        ext.allocate(sizeof(typename T::value_type)*n);
        memcpy(ext.getPointer(),obj.getPointer(),sizeof(typename T::value_type)*n);

        // update statistic
        sts.incReq();
    }

    static void packRequestDummy(std::vector<size_t> & req)
    {
        req.push_back(sizeof(T));
    }
};


template<typename T, typename Mem>
class Packer<T,Mem,PACKER_OBJECTS_WITH_WARNING_POINTERS>
{
public:

    static void pack(ExtPreAlloc<Mem> & ext, T & obj, Pack_stat & sts)
    {
#ifdef DEBUG
        if (ext.ref() == 0)
            std::cerr << "Error : " << __FILE__ << ":" << __LINE__ << " the reference counter of mem should never be zero when packing \n";

        std::cerr << "Warning: " << __FILE__ << ":" << __LINE__ << " impossible to check the type " << demangle(typeid(T).name()) << " please consider to add a static method \"void noPointers()\" \n" ;
#endif
        ext.allocate(sizeof(T));
        memcpy((T *)ext.getPointer(),&obj,sizeof(T));

        // update statistic
        sts.incReq();
    }

    static void packRequest(std::vector<size_t> & req)
    {
        req.push_back(sizeof(T));
    }
};

template<typename T, typename Mem>
class Packer<T,Mem,PACKER_OBJECTS_WITH_POINTER_CHECK>
{
public:

    static void pack(ExtPreAlloc<Mem> & ext, T & obj, Pack_stat & sts)
    {
#ifdef DEBUG
        if (ext.ref() == 0)
            std::cerr << "Error : " << __FILE__ << ":" << __LINE__ << " the reference counter of mem should never be zero when packing \n";

        if (obj.noPointers() == false)
            std::cerr << "Error: " << __FILE__ << ":" << __LINE__ << " the type " << demangle(typeid(T).name()) << " has pointers inside, sending pointers values has no sense\n";
#endif
        ext.allocate(sizeof(T));
        memcpy((T *)ext.getPointer(),&obj,sizeof(T));

        // Update statistic
        sts.incReq();
    }

    static void packRequest(std::vector<size_t> & req)
    {
        req.push_back(sizeof(T));
    }
};

template<typename T, typename Mem>
class Packer<T,Mem,PACKER_VECTOR>
{
public:

    template<int ... prp> static void packRequest(T & obj, std::vector<size_t> & v)
    {
        obj.template packRequest<prp...>(v);
    };

    template<int ... prp> static void pack(ExtPreAlloc<Mem> & mem, T & obj, Pack_stat & sts)
    {
#ifdef DEBUG
        std::cout << "Inside vector pack() function! (packer.hpp)" << std::endl;
#endif
        obj.template pack<prp...>(mem, sts);
    };
};

template<typename T, typename Mem>
class Packer<T,Mem,PACKER_GRID>
{
public:

    template<int ... prp> static void packRequest(T & obj, std::vector<size_t> & v)
    {
        obj.template packRequest<prp...>(v);
    };

    template<int ... prp> static void packRequest(T & obj, grid_key_dx_iterator_sub<T::dims> & sub, std::vector<size_t> & v)
    {
        obj.template packRequest<prp...>(sub, v);
    };

    template<int ... prp> static void pack(ExtPreAlloc<Mem> & mem, T & obj, Pack_stat & sts)
    {
        obj.template pack<prp...>(mem, sts);
    }

    template<int ... prp> static void pack(ExtPreAlloc<Mem> & mem, T & obj, grid_key_dx_iterator_sub<T::dims> & sub_it, Pack_stat & sts)
    {
        obj.template pack<prp...>(mem, sub_it, sts);
    }

};

template<typename T, typename Mem>
class Packer<T,Mem,PACKER_ENCAP_OBJECTS>
{
public:

    void pack(ExtPreAlloc<Mem> & mem, T & eobj)
    {
#ifdef DEBUG
        if (mem.ref() == 0)
            std::cerr << "Error : " << __FILE__ << ":" << __LINE__ << " the reference counter of mem should never be zero when packing \n";
#endif

        // Create an object out of the encapsulated object and copy
        typename T::type obj = eobj;

        memcpy(mem.getPointer(),&obj,sizeof(T::type));
    }

    void packRequest(std::vector<size_t> & v)
    {
        v.push_back(sizeof(T::type));
    }
};

#endif /* SRC_PACKER_HPP_ */