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"


#include "Grid/grid_sm.hpp"
#include "util/Pack_stat.hpp"
#include "Pack_selector.hpp"
#include "has_pack_encap.hpp"
#include "Packer_util.hpp"

template<typename T, typename Mem, int pack_type >
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(const T & obj, 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(const T & obj, size_t & req)
    {
        req += sizeof(T);
    }

    static void packRequest(size_t & req)
    {
        req += 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 packRequest(T & obj,size_t & req)
    {
        req += sizeof(typename T::value_type)*obj.size();
    }
};


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

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

        if (!(std::is_array<T>::value == true && std::is_fundamental<typename std::remove_all_extents<T>::type>::value == true))
            std::cerr << "Warning: " << __FILE__ << ":" << __LINE__ << " impossible to check the type " << demangle(typeid(T).name()) << " please consider to add a static method like \"static bool noPointers() {return true;}\" \n" ;
#endif
        ext.allocate(sizeof(T));
        memcpy((T *)ext.getPointer(),&obj,sizeof(T));

        // update statistic
        sts.incReq();
    }

    static void packRequest(const T & obj,size_t & req)
    {
        req += sizeof(T);
    }

    static void packRequest(size_t & req)
    {
        req += sizeof(T);
    }
};

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

    static void pack(ExtPreAlloc<Mem> & ext, const 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(const T & obj,size_t & req)
    {
        req += sizeof(T);
    }

    static void packRequest(size_t & req)
    {
        req += sizeof(T);
    }
};

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

    template<int ... prp> static void packRequest(const T & obj, size_t & req)
    {
        obj.template packRequest<prp...>(req);
    };

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

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

    template<int ... prp> static void packRequest(const T & obj, size_t & req)
    {
        obj.template packRequest<prp...>(req);
    };

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

    template<int ... prp> static void pack(ExtPreAlloc<Mem> & mem, const 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:

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

        if (has_pack_encap<T,prp ...>::result::value == true)
            call_encapPack<T,Mem,prp ...>::call_pack(eobj,mem,sts);
        else
        {
            if (sizeof...(prp) == 0)
            {
                mem.allocate(sizeof(typename T::T_type));
                encapc<1,typename T::T_type,typename memory_traits_lin< typename T::T_type >::type> enc(*static_cast<typename T::T_type::type *>(mem.getPointer()));
                enc = eobj;
            }
            else
            {
                typedef object<typename object_creator<typename T::type,prp...>::type> prp_object;
                mem.allocate(sizeof(prp_object));
                encapc<1,prp_object,typename memory_traits_lin< typename T::T_type >::type> enc(*static_cast<typename prp_object::type *>(mem.getPointer()));
                object_si_d<T,decltype(enc),OBJ_ENCAP,prp ... >(eobj,enc);
            }
        }

        // update statistic
        sts.incReq();
    }

    template<int ... prp> void packRequest(T & eobj,size_t & req)
    {
        if (has_pack_encap<T>::value == true)
            call_encapPackRequest<T,Mem,prp ...>::call_packRequest(eobj,req);
        else
        {
            if (sizeof...(prp) == 0)
                return;

            typedef object<typename object_creator<typename T::type,prp...>::type> prp_object;

            req += sizeof(prp_object);
        }
    }
};

#endif /* SRC_PACKER_HPP_ */