MemoryCache.h

// -*- mode: c++; c-basic-offset:4 -*-
 
// This file is part of ngap_module, A C++ module that can be loaded in to
// the OPeNDAP Back-End Server (BES) and is able to handle remote requests.
 
// Copyright (c) 2023 OPeNDAP, Inc.
// 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
//
// You can contact OPeNDAP, Inc. at PO Box 112, Saunderstown, RI. 02874-0112.
 
//
// Created by James Gallagher on 10/16/23.
//
 
#ifndef BES_MEMORYCACHE_H
#define BES_MEMORYCACHE_H
 
#include <string>
#include <unordered_map>
#include <deque>
 
#ifndef BESInternalError_h_
#include "BESInternalError.h"
#endif
 
namespace ngap {

template <typename VALUE>
class MemoryCache {
    unsigned int d_max_items = 100;       //< Max number of items to cache (not bytes, but items)
    unsigned int d_purge_items = 20;     //< When purging, remove this many items
    
    std::deque<std::string> d_fifo_keys; //< FIFO queue of keys; used by purge()
    std::unordered_map<std::string, VALUE> d_cache;

    void purge() {
        // if number of elements > threshold, purge
        for (int entries = 0; entries < d_purge_items; ++entries) {
            std::string key = d_fifo_keys.front();
 
            d_cache.erase(d_cache.find(key));
            d_fifo_keys.pop_front();
        }
    }

    bool invariant(bool expensive = true) const {
        if (d_cache.size() > d_max_items)
            return false;
        if (d_fifo_keys.size() > d_max_items)
            return false;
        if (d_cache.size() != d_fifo_keys.size())
            return false;
 
        if (expensive) {
            // check that the keys in the queue are also in the map
            for (const auto &key : d_fifo_keys) {
                if (d_cache.find(key) == d_cache.end())
                    return false;
            }
        }
 
        return true;
    }
 
    friend class MemoryCacheTest;
 
public:
    MemoryCache() = default;    // this makes testing easier
    MemoryCache(const MemoryCache *src) = delete;
 
    virtual ~MemoryCache() = default;
    MemoryCache &operator=(const MemoryCache *src) = delete;

    virtual bool initialize(int max_items, int purge_items) {
        if (max_items <= 0 || purge_items <= 0)
            return false;
 
        d_max_items = (unsigned int)max_items;
        d_purge_items = (unsigned int)purge_items;
        return true;
    }

    virtual bool get(const std::string &key, VALUE &value) {
        if (d_cache.find(key) != d_cache.end()) {
            value = d_cache[key];
            return true;
        }
        else {
            return false;
        }
    }

    virtual void put(const std::string &key, const VALUE &value) {
        // add key, value to the queue of entries if key is not in the cache
        // add or overwrite/update the value associated with key
        if (d_cache.find(key) == d_cache.end()) {
            d_cache.insert(std::pair<std::string, VALUE>(key, value));
            d_fifo_keys.push_back(key);
            if (d_cache.size() > d_max_items)
                purge();
        }
        else
            d_cache[key] = value;
    }

    virtual unsigned long size() const { return d_cache.size(); }

    virtual void clear() { d_cache.clear(); d_fifo_keys.clear(); }
};
 
} // ngap
 
#endif //BES_MEMORYCACHE_H