main_ser.cpp

#include "Vector/vector_dist.hpp"


struct my_struct
{
    size_t size;

    char * ptr;

    std::string str;

    openfpm::vector<int> v;


public:

    static bool pack()  {return true;}



    my_struct()
    {
        size = 0;
        ptr = NULL;
    }

    my_struct(const my_struct & my)
    {
        this->operator=(my);
    }

    my_struct(my_struct && my)
    {
        this->operator=(my);
    }

    ~my_struct()
    {
        if (ptr != NULL)
            delete [] ptr;
    }

    // we copy pointer and we do double delete
    my_struct & operator=(const my_struct & my)
    {
        size = my.size;
        str = my.str;
        v = my.v;

        ptr = new char[size];
        memcpy(ptr,my.ptr,32);

        return *this;
    }

    // we copy pointer and we do double delete
    my_struct & operator=(my_struct && my)
    {
        size = my.size;
        my.size = 0;
        str.swap(my.str);
        v.swap(my.v);
        ptr = my.ptr;
        my.ptr = 0;

        return *this;
    }



    template<int ... prp> inline void packRequest(size_t & req) const
    {
        req += 2*sizeof(size_t) + size + str.size()+1;
        v.packRequest(req);
    }



    static bool noPointers()
    {
        return false;
    }



    template<typename Memory, int ... prp> inline void pack(ExtPreAlloc<Memory> & mem, Pack_stat & sts) const
    {

        //Serialize the number that determine the C-string size
        Packer<size_t, Memory>::pack(mem,size,sts);



        // Allocate and copy the string
        mem.allocate(size);
        void * t_ptr = mem.getPointer();
        memcpy(t_ptr,ptr,size);



        //Serialize the number that determine the C++-string str.size()+1 given by the null terminator
        Packer<size_t, Memory>::pack(mem,str.size()+1,sts);

        // Allocate and copy the string
        mem.allocate(str.size()+1);
        char * t_ptr2 = (char *)mem.getPointer();
        memcpy(t_ptr2,str.c_str(),str.size());

        // Add null terminator
        t_ptr2[str.size()] = 0;

        Packer<decltype(v), Memory>::pack(mem,v,sts);

    }



    template<typename Memory, int ... prp> inline void unpack(ExtPreAlloc<Memory> & mem, Unpack_stat & ps)
    {

        // unpack the size of the C string
        Unpacker<size_t, Memory>::unpack(mem,size,ps);



        // Allocate the C string
        ptr = new char[size];

        // source pointer
        char * ptr_src = (char *)mem.getPointerOffset(ps.getOffset());

        // copy from the buffer to the destination
        memcpy(ptr,ptr_src,size);

        // update the pointer
        ps.addOffset(size);



        // get the the C++ string size
        size_t cpp_size;
        Unpacker<size_t, Memory>::unpack(mem,cpp_size,ps);

        // Create the string from the serialized data (de-serialize)
        char * ptr_src2 = (char *)mem.getPointerOffset(ps.getOffset());
        str = std::string(ptr_src2);
        ps.addOffset(cpp_size);

        // Unpack the vector
        Unpacker<decltype(v), Memory>::unpack(mem,v,ps);

    }



};


int main(int argc, char* argv[])
{
    // initialize the library
    openfpm_init(&argc,&argv);

    // Here we define our domain a 2D box with internals from 0 to 1.0 for x and y
    Box<2,float> domain({0.0,0.0},{1.0,1.0});

    // Here we define the boundary conditions of our problem
    size_t bc[2]={PERIODIC,PERIODIC};

    // extended boundary around the domain, and the processor domain
    Ghost<2,float> g(0.01);

    // my_struct at position 0 in the aggregate
    constexpr int my_s1 = 0;

    // my_struct at position 1 in the aggregate
    constexpr int my_s2 = 1;


    vector_dist<2,float, aggregate<my_struct,my_struct>>
    vd(4096,domain,bc,g);

    std::cout << "HAS PACK: " << has_pack_agg<aggregate<my_struct,my_struct>>::result::value << std::endl;



    auto it = vd.getDomainIterator();

    while (it.isNext())
    {
        auto p = it.get();

        // we define x, assign a random position between 0.0 and 1.0
        vd.getPos(p)[0] = (float)rand() / RAND_MAX;

        // we define y, assign a random position between 0.0 and 1.0
        vd.getPos(p)[1] = (float)rand() / RAND_MAX;

        // Get the particle position as point
        Point<2,float> pt = vd.getPos(p);

        // create a C string from the particle coordinates
        // and copy into my struct
        vd.getProp<my_s1>(p).size = 32;
        vd.getProp<my_s1>(p).ptr = new char[32];
        strcpy(vd.getProp<my_s1>(p).ptr,pt.toString().c_str());

        // create a C++ string from the particle coordinates
        vd.getProp<my_s1>(p).str = std::string(pt.toString());

        vd.getProp<my_s1>(p).v.add(1);
        vd.getProp<my_s1>(p).v.add(2);
        vd.getProp<my_s1>(p).v.add(3);

        pt = pt * 2.0;

        // create a C string from the particle coordinates multiplied by 2.0
        // and copy into my struct
        vd.getProp<my_s2>(p).size = 32;
        vd.getProp<my_s2>(p).ptr = new char[32];
        strcpy(vd.getProp<my_s2>(p).ptr,pt.toString().c_str());

        // create a C++ string from the particle coordinates
        vd.getProp<my_s2>(p).str = std::string(pt.toString());

        vd.getProp<my_s2>(p).v.add(1);
        vd.getProp<my_s2>(p).v.add(2);
        vd.getProp<my_s2>(p).v.add(3);
        vd.getProp<my_s2>(p).v.add(4);

        // next particle
        ++it;
    }



    // Particles are redistribued across the processors
    vd.map();

    // Synchronize the ghost
    vd.ghost_get<my_s1,my_s2>();



    vd.write("particles");



    size_t fg = vd.size_local();

    Vcluster & v_cl = create_vcluster();

    // Only the master processor print
    if (v_cl.getProcessUnitID() == 0)
    {
        // Print 4 particles
        for ( ; fg < vd.size_local()+4 ; fg++)
        {
            // Print my struct1 information
            std::cout << "my_struct1:" << std::endl;
            std::cout << "C-string: " << vd.getProp<my_s1>(fg).ptr << std::endl;
            std::cout << "Cpp-string: " << vd.getProp<my_s1>(fg).str << std::endl;

            for (size_t i = 0 ; i < vd.getProp<my_s1>(fg).v.size() ; i++)
                std::cout << "Element: " << i << "   " << vd.getProp<my_s1>(fg).v.get(i) << std::endl;

            // Print my struct 2 information
            std::cout << "my_struct2" << std::endl;
            std::cout << "C-string: " << vd.getProp<my_s2>(fg).ptr << std::endl;
            std::cout << "Cpp-string: " << vd.getProp<my_s2>(fg).str << std::endl;

            for (size_t i = 0 ; i < vd.getProp<my_s2>(fg).v.size() ; i++)
                std::cout << "Element: " << i << "   " << vd.getProp<my_s2>(fg).v.get(i) << std::endl;
        }
    }



    openfpm_finalize();


}