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 "BESIndent.h"
 
namespace libdap {
    class DapObj;
}
 
//namespace bes {

class ObjMemCache {
    // TODO Make this a template or make a new version of this that is a
    //  template so it's typesafe. jhrg 9/6/23
private:
    struct Entry {
        libdap::DapObj *d_obj;
        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 the thing it references
        ~Entry() { delete d_obj; d_obj = 0;}
    };
 
    // TODO Since d_age is used for both the cache and the index, as the 'int'
    //  it should be an unsigned int or those should be u long longs. It's
    //  unlikely we will ever run a process long enough to need 64-bits. jhrg 9/6/23
 
    unsigned long long d_age;           // When obj was added or last accessed
    unsigned int d_entries_threshold;   // no more than this num of entries
    float d_purge_threshold;            // free up this fraction of the cache
 
    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_age(0), d_entries_threshold(0), d_purge_threshold(0.2) { }

    ObjMemCache(unsigned int entries_threshold, float purge_threshold): d_age(0),
        d_entries_threshold(entries_threshold), d_purge_threshold(purge_threshold) {
        // d_entries_threshold = entries_threshold >> 1; // * 2
    }
 
    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" << std::endl;
        os << "Length of index: " << index.size() << std::endl;
        for(index_t::const_iterator it = index.begin(); it != index.end(); ++it)  {
            os << it->first << " --> " << it->second << std::endl;
        }
 
        os << "Length of cache: " << cache.size() << std::endl;
        for(cache_t::const_iterator it = cache.begin(); it != cache.end(); ++it)  {
            os << it->first << " --> " << it->second->d_name << std::endl;
        }
    }
};
 
// } namespace bes
 
#endif /* DAP_OBJMEMCACHE_H_ */