src/session.hpp

   1 /* $Id: session.hpp,v 1.10 2005-10-25 21:32:01 adam Exp $
   2    Copyright (c) 2005, Index Data.
   3
   4 %LICENSE%
   5  */
   6
   7 #ifndef SESSION_HPP
   8 #define SESSION_HPP
   9
  10 //#include <stdexcept>
  11 #include <map>
  12 #include <boost/thread/mutex.hpp>
  13
  14 namespace yp2 {
  15
  16     class Session
  17     {
  18         //typedef unsigned long type;
  19     public:
  20
  21         /// create new session with new unique id
  22         Session() {
  23             boost::mutex::scoped_lock scoped_lock(m_mutex);
  24             ++m_global_id;
  25             m_id =  m_global_id;
  26             m_close = false;
  27         };
  28
  29         /// copy session including old id
  30         Session(const Session &s) : m_id(s.m_id), m_close(s.m_close) {};
  31
  32         Session& operator=(const Session &s) {
  33             if (this != &s)
  34             {
  35                 m_id = s.m_id;
  36                 m_close = s.m_close;
  37             }
  38             return *this;
  39         }
  40
  41         bool operator<(const Session &s) const {
  42             return m_id < s.m_id ? true : false;
  43         }
  44
  45         unsigned long id() const {
  46             return m_id;
  47         };
  48
  49         bool is_closed() const {
  50             return m_close;
  51         };
  52
  53         /// mark session closed, can not be unset
  54         void close() {
  55             m_close = true;
  56         };
  57
  58         bool operator == (Session &ses) const {
  59             return ses.m_id == m_id;
  60         }
  61     private:
  62
  63         unsigned long int m_id;
  64         bool m_close;
  65
  66         /// static mutex to lock static m_id
  67         static boost::mutex m_mutex;
  68
  69         /// static m_id to make sure that there is only one id counter
  70         static unsigned long int m_global_id;
  71
  72     };
  73
  74     template <class T> class session_map {
  75     public:
  76         void create(T &t, const yp2::Session &s) {
  77             boost::mutex::scoped_lock lock(m_mutex);
  78             m_map[s] = t;
  79         };
  80         void release(const yp2::Session &s) {
  81             boost::mutex::scoped_lock lock(m_mutex);
  82
  83             m_map.erase(s);
  84         };
  85         bool active(const yp2::Session &s) {
  86             typename std::map<yp2::Session,T>::const_iterator it;
  87             it = m_map.find(s);
  88             return it == m_map.end() ? false : true;
  89         }
  90     private:
  91         boost::mutex m_mutex;
  92         std::map<yp2::Session,T>m_map;
  93     };
  94
  95 }
  96
  97 #endif
  98 /*
  99  * Local variables:
 100  * c-basic-offset: 4
 101  * indent-tabs-mode: nil
 102  * c-file-style: "stroustrup"
 103  * End:
 104  * vim: shiftwidth=4 tabstop=8 expandtab
 105  */