Experiments with session map template.
[metaproxy-moved-to-github.git] / src / session.hpp
1 /* $Id: session.hpp,v 1.11 2005-10-26 18:53:49 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_map_mutex);
78             m_map[s] = SessionItem(t);
79         };
80         void release(const yp2::Session &s) {
81             boost::mutex::scoped_lock lock(m_map_mutex);
82
83             m_map.erase(s);
84         };
85 #if 0
86         T &get_session_data(const yp2::Session &s) {
87             boost::mutex::scoped_lock lock(m_map_mutex);
88
89             typename std::map<yp2::Session,SessionItem>::const_iterator it;
90             it = m_map.find(s);
91             if (it == m_map.end())
92                 return 0;
93             boost::mutx::scoped_lock *scoped_ptr =
94                 new boost::mutex::scoped_lock(it->second->m_item_mutex);
95         };
96 #endif
97         bool exist(const yp2::Session &s) {
98             typename std::map<yp2::Session,SessionItem>::const_iterator it;
99             it = m_map.find(s);
100             return it == m_map.end() ? false : true;
101         }
102     private:
103         class SessionItem {
104         public:
105             SessionItem() {};
106             SessionItem(T &t) : m_t(t) {};
107             SessionItem &operator =(const SessionItem &s) {
108                 if (this != &s) {
109                     m_t = s.m_t;
110                 }
111                 return *this;
112             };
113             SessionItem(const SessionItem &s) {
114                 m_t = s.m_t;
115             };
116             T m_t;
117             boost::mutex m_item_mutex;
118         };
119     private:
120         boost::mutex m_map_mutex;
121         std::map<yp2::Session,SessionItem>m_map;
122     };
123     
124 }
125
126 #endif
127 /*
128  * Local variables:
129  * c-basic-offset: 4
130  * indent-tabs-mode: nil
131  * c-file-style: "stroustrup"
132  * End:
133  * vim: shiftwidth=4 tabstop=8 expandtab
134  */