ObjMemCache.h

// This file is part of bes, A C++ back-end server implementation framework
// for the OPeNDAP Data Access Protocol.

// Copyright (c) 2016 OPeNDAP
// Author: James Gallagher <jgallagher@opendap.org>
//
// 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

/*
 * ObjMemCache.h
 *
 *  Created on: May 18, 2016
 *      Author: jimg
 */

#ifndef DAP_OBJMEMCACHE_H_
#define DAP_OBJMEMCACHE_H_

#include <cassert>

#include <string>
#include <map>

#include <DapObj.h>

//namespace bes {

class ObjMemCache {
private:
    struct Entry {
        libdap::DapObj *d_obj; // A weak pointer - we do not manage this storage
        const std::string d_name;

        // We need the string so that we can erase the index entry easily
        Entry(libdap::DapObj *o, const std::string &n): d_obj(o), d_name(n) { }
        // deleting an Entry deletes teh thing it references
        ~Entry() { delete d_obj; d_obj = 0;}
    };

    unsigned int d_count;
    unsigned int d_entries_threshold;
    float d_purge_threshold;

    typedef std::pair<unsigned int, Entry*> cache_pair_t;  // used by map::insert()
    typedef std::map<unsigned int, Entry*> cache_t;
    cache_t cache;

    typedef std::pair<const std::string, unsigned int> index_pair_t;
    // efficiency improvement - use an unordered_map when C++-11 is adopted
    typedef std::map<const std::string, unsigned int> index_t;
    index_t index;

    friend class DDSMemCacheTest;

public:
    ObjMemCache(): d_count(0), d_entries_threshold(0), d_purge_threshold(0.2) { }

    ObjMemCache(unsigned int entries_threshold, float purge_threshold): d_count(0),
        d_entries_threshold(entries_threshold), d_purge_threshold(purge_threshold) { }

    virtual ~ObjMemCache();

    virtual void add(libdap::DapObj *obj, const std::string &key);

    virtual void remove(const std::string &key);

    virtual libdap::DapObj *get(const std::string &key);

    virtual unsigned int size() const {
        assert(cache.size() == index.size());
        return cache.size();
    }

    virtual void purge(float fraction);

    virtual void dump(ostream &os) {
        os << "ObjMemCache" << endl;
        os << "Length of index: " << index.size() << endl;
        for(index_t::const_iterator it = index.begin(); it != index.end(); ++it)  {
            os << it->first << " --> " << it->second << endl;
        }

        os << "Length of cache: " << cache.size() << endl;
        for(cache_t::const_iterator it = cache.begin(); it != cache.end(); ++it)  {
            os << it->first << " --> " << it->second->d_name << endl;
        }
    }
};

// } namespace bes

#endif /* DAP_OBJMEMCACHE_H_ */