缓存淘汰器类

AbstractCacheLimiter.h

#pragma once

#include <functional>

template <typename T>
class AbstractCacheLimiter {
public:
	virtual bool contains(T cache)												= 0;
	virtual void clearCache()													= 0;
	virtual void addCache(T cache)												= 0;
	virtual void removeCache(T cache)											= 0;
	virtual uint64_t getMaxCacheCount()											= 0;
	virtual void setMaxCacheCount(uint64_t maxCount)							= 0;
	virtual void setCacheDiscardCallback(std::function<void(T cache)> callback) = 0;

	virtual ~AbstractCacheLimiter() = default;
};

FIFOCacheLimiter.hpp

#pragma once

#include "AbstractCacheLimiter.h"

#include <list>
#include <memory>

template <typename T>
class FIFOCacheLimiter : public AbstractCacheLimiter<T> {
public:
	FIFOCacheLimiter();
	virtual bool contains(T cache) override;
	virtual void clearCache() override;
	virtual void addCache(T cache) override;
	virtual void removeCache(T cache) override;

	virtual void setCacheDiscardCallback(std::function<void(T cache)> callback) override;
	virtual void setMaxCacheCount(uint64_t maxCount) override;
	virtual uint64_t getMaxCacheCount() override;
private:
	void discardEarliestCache();

	std::list<T> m_cacheList;
	uint64_t m_maxCacheCount = 100;
	std::function<void(T cache)> m_cacheDiscardCallback;
};

template <typename T>
uint64_t
FIFOCacheLimiter<T>::getMaxCacheCount()
{
	return m_maxCacheCount;
}

template <typename T>
bool
FIFOCacheLimiter<T>::contains(T cache)
{
	return std::find(m_cacheList.begin(), m_cacheList.end(), cache) != m_cacheList.end();
}

template <typename T>
void
FIFOCacheLimiter<T>::clearCache()
{
	for (T &item : m_cacheList) {
		removeCache(item);
	}
}

template <typename T>
FIFOCacheLimiter<T>::FIFOCacheLimiter()
{
}

template <typename T>
void
FIFOCacheLimiter<T>::addCache(T cache)
{
	auto it = std::find(m_cacheList.begin(), m_cacheList.end(), cache);
	if (it != m_cacheList.end()) {
		m_cacheList.splice(m_cacheList.end(), m_cacheList, it);
		return;
	}

	if (m_cacheList.size() >= m_maxCacheCount) {
		discardEarliestCache();
	}
	m_cacheList.insert(m_cacheList.end(), cache);
}

template <typename T>
void
FIFOCacheLimiter<T>::removeCache(T cache)
{
	m_cacheList.remove(cache);
}

template <typename T>
void
FIFOCacheLimiter<T>::setCacheDiscardCallback(std::function<void(T cache)> callback)
{
	m_cacheDiscardCallback = callback;
}

template <typename T>
void
FIFOCacheLimiter<T>::setMaxCacheCount(uint64_t maxCount)
{
	m_maxCacheCount = maxCount;
}

template <typename T>
void
FIFOCacheLimiter<T>::discardEarliestCache()
{
	T discardedCache = std::move(m_cacheList.front());
	m_cacheList.erase(m_cacheList.begin());
	if (m_cacheDiscardCallback) {
		m_cacheDiscardCallback(discardedCache);
	}
}