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_
 
 
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;
 
    std::unordered_map<local_index,size_t> ghostMarkers;
 
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;
        ghostMarkers = cell.ghostMarkers;
        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 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 addCellGhostMarkers()
    {
        for (auto it = cl_base.begin(); it != cl_base.end(); it++) {
            ghostMarkers[it->first] = it->second.size();
        }
    }
 
    inline size_t getGhostMarker(local_index cell_id) const
    {
        auto it = ghostMarkers.find(cell_id);
        if (it == ghostMarkers.end())
            return invalid;
 
        return it->second;
    }
 
    inline void swap(Mem_mw & cl)
    {
        cl_base.swap(cl.cl_base);
        ghostMarkers.swap(cl.ghostMarkers);
    }
 
    inline void swap(Mem_mw && cell)
    {
        cl_base.swap(cell.cl_base);
        ghostMarkers.swap(cell.ghostMarkers);
    }
 
    inline void clear()
    {
        cl_base.clear();
        ghostMarkers.clear();
    }
 
    inline const local_index & getStartId(size_t cell_id) const
    {
        auto it = cl_base.find(cell_id);
        if (it == cl_base.end())
            return invalid;
 
        return it->second.get(0);
    }
 
    inline const local_index & getGhostId(size_t cell_id) const
    {
        auto gm_it = ghostMarkers.find(cell_id);
        if (gm_it == ghostMarkers.end())
            return invalid;
 
        auto cell_it = cl_base.find(cell_id);
        if (cell_it == cl_base.end())
            return invalid;
 
        return cell_it->second.get(gm_it->second);
    }
 
    inline const local_index & getStopId(size_t cell_id) const
    {
        auto it = cl_base.find(cell_id);
        if (it == cl_base.end())
            return invalid;
 
        return *(&it->second.last() + 1);
    }
 
    inline const local_index & get_lin(const local_index * cell_id) const
    {
        return *cell_id;
    }
 
public:
 
    inline Mem_mw(size_t slot)
    :invalid(0)
    {
    }
 
    inline void set_slot(size_t slot)
    {}
 
};
 
 
#endif /* CELLISTMEM_HPP_ */