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

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

[code=C/C++]/*-----------------------------------------------------------------------------
 * 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[/code]