sprint/container/cachemap.h

Go to the documentation of this file.

/******************************************************************************
*   sprint::cachemap
*
*   Copyright (C) 2005-2011  Paolo Medici <www.pmx.it>
*
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License as published by the Free Software Foundation; either
 *  version 2.1 of the License, or (at your option) any later version.
 *
 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 *******************************************************************************/

#ifndef _CACHE_MAP_H
#define _CACHE_MAP_H

#include <fstream>
#include <sstream>
#include <string>
#include <map>

namespace sprint {

 // FW
template <typename _Key, typename _Tp, typename hash>
class cachemap;
 
template <typename _Key, typename _Tp, typename hash>
struct cachemap_iterator {
    typedef _Key                                 key_type;
        typedef typename hash::key_type              hash_key_type;
    typedef _Tp                                  mapped_type;
    typedef std::pair<_Key, _Tp>                 value_type;

        typedef typename std::map<_Key, _Tp>         mapset;    
        
    //typedef typename cachemap<_Key, _Tp, hash> parent;
    
    typename mapset::iterator m_i;
    cachemap_iterator(typename mapset::iterator  i) : m_i(i) { }
    
}; 
 
template <typename _Key, typename _Tp, typename hash>
class cachemap: public hash
 {
        typedef _Key                                 key_type;
        typedef typename hash::key_type              hash_key_type;
    typedef _Tp                                  mapped_type;
    typedef std::pair<_Key, _Tp>                 value_type;

        typedef typename std::map<_Key, _Tp>         mapset;        
        
        struct container: public mapset {
        unsigned int m_refcount;
    };
    
    typedef typename std::map<hash_key_type, container> innermapset;        
    
    
    unsigned int m_nmap;
    
    std::string m_cachename;
    
    innermapset m_innermap;
    
    container & load( const hash_key_type & p)
    {
        std::ostringstream s;
        mapped_type value;
        s << m_cachename << p << ".cache";
        
        std::ifstream in(s.str().c_str());
        container & target = m_innermap[p];
        key_type key;
        // TODO: implement a storageIO
        while( in.read(&key, sizeof(hash_key_type)) )
            in.read(&target[key], sizeof(mapped_type));        
        return target;
    }

    void save( const hash_key_type & p) const
    {
        std::ostringstream s;
        mapped_type value;
        s << m_cachename << p << ".cache";
        
        std::ofstream out(s.str().c_str());
        const container & target = m_innermap[p];
        for(typename container::const_iterator i = target.begin(); target.end(); i++)
            {
            out.write(&i->first, sizeof(key_type));
            out.write(&i->second, sizeof(value_type));
            }
    }
    
    container & access(const key_type & k)
    {
        hash_key_type h = hash::operator()(k);
        typename innermapset::iterator i = m_innermap.find(k);
        if(i!=m_innermap.end())
            return i->second;
        else
        {
            // remove old container
            return load(h);
        }
    }
    
    public:
        
    typedef cachemap_iterator<_Key, _Tp, hash> iterator;
    typedef cachemap_iterator<_Key, _Tp, hash> const_iterator;    
    
    public:
        cachemap(const std::string & cachename, unsigned int nmap) : m_cachename(cachename), m_nmap(nmap) { }
        ~cachemap() { }
        
        mapped_type & operator[](const key_type & k)
            {
                container & c = access(k);
                return c[k];
            }
            
        iterator find(const key_type & k)
            {
                container & c = access(k);
                return c.find(k);
            }
            
        iterator begin()
            {
                
            }

        iterator end()
            {
                
            }

 };

}

#endif