一个消息队列类的实现C++

重新粘贴：
消息队列类，该类是用STL的std::list和std::map实现的，写得有点复杂，
同时还有一个时间类，时间也是模仿boost::time 写出来的，请大家不要见笑!但是
boost的time类是以CPU时钟为计时的，而我的是以系统时间计时的

/*-----------------------------------------------------------------------------
* FILE: queue.h
* AUTH: xuwannian@gmail.com
* TIME: 2008-04-29
*---------------------------------------------------------------------------*/
#ifndef __QUEUE_QUEUE_HPP__
#define __QUEUE_QUEUE_HPP__

#include "mutex.h"
#include <list>
#include <map>
#include <string>
#include <time.h>

namespace xuwn
{
//////////////////////////////////////////////////////////////////////////
class times
{
public:
times () { restart();       };
virtual ~times () {         };
double  elapsed() { return (double)(time(NULL) - __tx);};
void  restart() { __tx = time(NULL);     };
private:
time_t __tx;
};

/*
int main()
{
times t;
Sleep(10000);

int d = t.elapsed();
printf("elapsed = %d/n", d);

getchar();
return 0;
}

打印结果为：elapsed = 10
*/

// 定义消息队列结构体
template<typename T>
struct __BODY
{
public:
__BODY(T t) : t(t) {};

bool IsTimeOut(int timeout=1200)
{
return ((timeout - ts.elapsed()) >= 0) ? false : true;
}
public:
T t;
private:
times ts;
};
//////////////////////////////////////////////////////////////////////////
// CList应用std::list编写的消息队列
// 2008-03-04
template<typename T>
class CList
{
public:
CList() { clear(); };
virtual    ~CList() { clear(); };
public:
int   put(T t);
int   get(T& t, bool bRemove=true);
int   size();
void  cleartimeout();
private:
void  clear();
private:
std::list<__BODY<T> > __q;
mutex     __m;
}; // END CLASS CLQUEUE

//-------------------------实现-------------------------//
template<typename T>
int CList<T>::put(T t)
{
lock l(__m);

__BODY<T> body(t);
__q.push_back(body);

return 0;
}

template<typename T>
int CList<T>::get(T& t, bool bRemove/* =true */)
{
lock l(__m);

std::list<__BODY<T> >::iterator it = __q.begin();

if (it == __q.end())
return -1;

__BODY<T> a = (__BODY<T>)*it;

t = (T)a.t;

if (bRemove)
__q.erase(it);

return 0;
}

template<typename T>
int CList<T>::size()
{
lock l(__m);
return __q.size();
}

template<typename T>
void CList<T>::clear()
{
lock l(__m);
__q.clear();
}

template<typename T>
void CList<T>::cleartimeout()
{
lock l(__m);
std::list<__BODY<T> >::iterator it;

for (it = __q.begin(); it != __q.end(); )
{
__BODY<T> a = (__BODY<T>)*it;

if (a.IsTimeOut())
{
__q.erase(it);

it = __q.begin();
}
else
{
it++;
}
}
}
//////////////////////////////////////////////////////////////////////////
// CMap 应用std::map 编写的消息队列
// 2008-03-04
template<typename T>
class CMap
{
public:
CMap() { clear(); };
virtual    ~CMap() { clear(); };
public:
int   put(std::string key, T  t, bool bRemove=true);
int   get(std::string key, T& t, bool bRemove=true);
int   erase(std::string key);
int   has(std::string key);
int   gets(std::list<T>& ls, bool bRemove=false);
int   size();
void  cleartimeout();
private:
void  clear();
private:
std::map<std::string, __BODY<T> > __q;
mutex        __m;
}; // END CLASS CMQUEUE
//-------------------------实现-------------------------//
template<typename T>
int CMap<T>::put(std::string key, T t, bool bRemove/* =true */)
{
lock l(__m);

std::map<std::string, __BODY<T> >::iterator it = __q.find(key);

if (it == __q.end())
{
__q.insert(std::map<std::string, __BODY<T> >::value_type(key, t));
return 0;
}

if (bRemove)
{
__q.erase(it);
__q.insert(std::map<std::string, __BODY<T> >::value_type(key, t));

return 0;
}
else
{
return -2;
}
}

template<typename T>
int CMap<T>::get(std::string key, T& t, bool bRemove/* =true */)
{
lock l(__m);

std::map<std::string, __BODY<T> >::iterator it = __q.find(key);

if (it == __q.end())
{
return -1;
}

__BODY<T> a = (__BODY<T>)it->second;

t = (T)a.t;

if (bRemove)
{
__q.erase(it);
}

return 0;
}

template<typename T>
int CMap<T>::size()
{
lock l(__m);
return __q.size();
}

template<typename T>
void CMap<T>::clear()
{
lock l(__m);
__q.clear();
}

template<typename T>
void CMap<T>::cleartimeout()
{
lock l(__m);
std::map<std::string, __BODY<T> >::iterator it = __q.begin();

for (; it != __q.end(); )
{
__BODY<T> a = (__BODY<T>)it->second;

if (a.IsTimeOut())
{
__q.erase(it);

it = __q.begin();
}
else
it++;
}
}

template<typename T>
int CMap<T>::erase(std::string key)
{
lock l(__m);
std::map<std::string, __BODY<T> >::iterator it = __q.find(key);

if (it != __q.end())
{
__q.erase(it);

return 0;
}

// 没有元素可以删除
return -3;
}

template<typename T>
int CMap<T>::has(std::string key)
{
lock l(__m);
std::map<std::string, __BODY<T> >::iterator it = __q.find(key);

if (it != __q.end())
{
return 0;
}

// 没有元素可以删除
return -3;
}

template<typename T>
int CMap<T>::gets(std::list<T>& ls, bool bRemove)
{
lock l(__m);
std::map<std::string, __BODY<T> >::iterator it = __q.begin();

for (; it != __q.end(); it++)
{
__BODY<T> a = (__BODY<T>)it->second;

ls.push_back(a.t);
}

if (bRemove)
__q.clear();

return ls.size();
}
}; // END xuwn

#endif