MemMemoryWise.hpp

/*
 * MemMemoryWise.hpp
 *
 *  Created on: Mar 22, 2015
 *  Last modified: June 25, 2015
 *      Authors: Pietro Incardona, Yaroslav Zaluzhnyi
 */

#ifndef CELLISTMEM_HPP_
#define CELLISTMEM_HPP_

#include "NN/CellList/CellList.hpp"

template<typename local_index = size_t>
class Mem_mw
{
    typedef openfpm::vector<local_index> base;

    std::unordered_map<local_index,base> cl_base;

    typename std::remove_reference<decltype(std::declval<openfpm::vector<local_index>>().get(0))>::type invalid;

public:

    typedef void toKernel_type;

    typedef local_index local_index_type;

    inline void init_to_zero(local_index slot, local_index tot_n_cell)
    {
        clear();
    }

    inline Mem_mw & operator=(const Mem_mw & cell)
    {
        cl_base = cell.cl_base;
        return *this;
    }

    inline void addCell(local_index cell_id, typename base::value_type ele)
    {
        //add another neighbor element

        cl_base[cell_id].add(ele);
    }

    inline void add(local_index cell_id, typename base::value_type ele)
    {
        this->addCell(cell_id,ele);
    }

    inline void remove(local_index cell, local_index ele)
    {
        cl_base[cell].remove(ele);
    }

    inline size_t getNelements(const local_index cell_id) const
    {
        auto it = cl_base.find(cell_id);
        if (it == cl_base.end())
            return 0;

        return it->second.size();
    }

    inline auto get(local_index cell, local_index ele) -> decltype(cl_base[0].get(0)) &
    {
        auto it = cl_base.find(cell);
        if (it == cl_base.end())
            return invalid;

        return it->second.get(ele);
    }


    inline auto get(local_index cell, local_index ele) const -> decltype(cl_base.find(cell)->second.get(0)) &
    {
        auto it = cl_base.find(cell);
        if (it == cl_base.end())
            return invalid;

        return it->second.get(ele);
    }

    inline void swap(Mem_mw & cl)
    {
        cl_base.swap(cl.cl_base);
    }

    inline void swap(Mem_mw && cell)
    {
        cl_base.swap(cell.cl_base);
    }

    inline void clear()
    {
        cl_base.clear();
    }

    inline const local_index & getStartId(size_t part_id) const
    {
        auto it = cl_base.find(part_id);
        if (it == cl_base.end())
            return *(&invalid);

        return it->second.get(0);
    }

    inline const local_index & getStopId(size_t part_id) const
    {
        auto it = cl_base.find(part_id);
        if (it == cl_base.end())
            return *(&invalid);

        return *(&it->second.last() + 1);
    }

    inline const local_index & get_lin(const local_index * part_id) const
    {
        return *part_id;
    }

public:

    inline Mem_mw(size_t slot)
    :invalid(0)
    {
    }

    inline void set_slot(size_t slot)
    {}

};


#endif /* CELLISTMEM_HPP_ */