基于Boost.MultiIndex实现的Session管理器

#ifndef SESSION_MANAGER_
#define SESSION_MANAGER_

#include <boost/multi_index_container.hpp>
#include <boost/multi_index/hashed_index.hpp>
#include <boost/multi_index/ordered_index.hpp>
#include <boost/multi_index/member.hpp>
#include <stdint.h>

template <typename T>
class SessionManager
{
public:
SessionManager(size_t max_size = 10000, uint64_t timeout = 3) : max_size_(max_size), timeout_(timeout) {}
private:
SessionManager(const SessionManager &);
SessionManager & operator = (const SessionManager &);

public:
int Init(size_t max_size, uint64_t timeout)
{
storage_.clear();
max_size_ = max_size;
timeout_ = timeout;
return 0;
}

int Insert(uint64_t id, uint64_t time, const T &entry, bool force = false)
{
IdIndex &index = storage_.template get<IdTag>();
typename IdIndex::iterator iter = index.find(id);
if (iter != index.end()) return -1;
if (index.size() >= max_size_) {
if (!force) return -2;
TimeIndex &time_index = storage_.template get<TimeTag>();
time_index.erase(time_index.begin());
}
index.insert(Entry(id, time, entry));
return 0;
}

int Fetch(uint64_t id, uint64_t time, T &entry)
{
IdIndex &index = storage_.template get<IdTag>();
typename IdIndex::iterator iter = index.find(id);
if (iter == index.end()) return -1;
if (time != 0) index.modify(iter, TimeModifier(time));
entry = iter->entry;
return 0;
}

void Delete(uint64_t id)
{
IdIndex &index = storage_.template get<IdTag>();
index.erase(id);
}

void Scan(uint64_t time)
{
TimeIndex &index = storage_.template get<TimeTag>();
for (typename TimeIndex::iterator iter = index.begin(); iter != index.end(); ) {
if (iter->time + timeout_ > time) return;
iter = index.erase(iter);
}
}

size_t Size() const { return storage_.size(); }

private:
struct Entry
{
uint64_t id;
uint64_t time;
T entry;
Entry(uint64_t id, uint64_t time, const T &entry) : id(id), time(time), entry(entry) {}
};

struct TimeModifier
{
int new_time;
TimeModifier(int new_time) : new_time(new_time) {}
void operator () (Entry &entry)
{
entry.time = new_time;
}
};

struct IdTag {};
struct TimeTag {};

typedef boost::multi_index_container<
Entry,
boost::multi_index::indexed_by<
boost::multi_index::hashed_unique<boost::multi_index::tag<IdTag>, boost::multi_index::member<Entry, uint64_t, &Entry::id> >,
boost::multi_index::ordered_non_unique<boost::multi_index::tag<TimeTag>, boost::multi_index::member<Entry, uint64_t, &Entry::time> >
>
> Storage;

typedef typename Storage::template index<IdTag>::type IdIndex;
typedef typename Storage::template index<TimeTag>::type TimeIndex;

private:
Storage storage_;
size_t max_size_;
uint64_t timeout_;
};

#endif