source: trunk/src/halEvent.hpp @ 404

Revision 404, 7.7 KB checked in by Eoin, 13 years ago (diff)

Some threading bug with the LogListView?!

Line 
1
2//         Copyright Eóin O'Callaghan 2006 - 2008.
3// Distributed under the Boost Software License, Version 1.0.
4//    (See accompanying file LICENSE_1_0.txt or copy at
5//          http://www.boost.org/LICENSE_1_0.txt)
6
7#pragma once
8
9#define HAL_EVENT_BEGIN                                 81000
10#define HAL_EVENT_EXP                   HAL_EVENT_BEGIN + 1
11#define HAL_EVENT_XML_EXP               HAL_EVENT_BEGIN + 2
12#define HAL_EVENT_UNICODE_EXP           HAL_EVENT_BEGIN + 3
13#define HAL_EVENT_DEBUG                 HAL_EVENT_BEGIN + 4
14#define HAL_EVENT_UNCLASSIFIED          HAL_EVENT_BEGIN + 5
15#define HAL_EVENT_PEER                  HAL_EVENT_BEGIN + 6
16#define HAL_EVENT_TRACKER               HAL_EVENT_BEGIN + 7
17#define HAL_EVENT_TORRENTEXP            HAL_EVENT_BEGIN + 8
18#define HAL_EVENT_INVTORRENT            HAL_EVENT_BEGIN + 9
19#define HAL_EVENT_DEV                   HAL_EVENT_BEGIN + 10
20
21#ifndef RC_INVOKED
22
23#include <string>
24#include <vector>
25
26#include <boost/date_time/posix_time/posix_time.hpp>
27#include <boost/smart_ptr.hpp>
28
29#include "global/wtl_app.hpp"
30#include "global/string_conv.hpp"
31
32#include "halTorrent.hpp"
33
34#ifdef TORRENT_LOGGING
35#       define HAL_DEV_MSG(msg) \
36        hal::event().post(boost::shared_ptr<hal::EventDetail>( \
37                        new hal::EventMsg(msg, hal::Event::dev)))
38#else
39#       define HAL_DEV_MSG(msg)
40#endif
41
42namespace hal
43{
44
45class Event
46{
47public:
48        enum eventLevel { dev, debug, info, warning, critical, fatal, none };
49       
50        enum codes {
51                noEvent = 0,
52                unclassified = HAL_EVENT_UNCLASSIFIED,
53                debugEvent = HAL_EVENT_DEBUG,
54                devEvent = HAL_EVENT_DEV,
55                invalidTorrent = HAL_EVENT_INVTORRENT,
56                torrentException = HAL_EVENT_TORRENTEXP,
57                generalException = HAL_EVENT_EXP,
58                xmlException = HAL_EVENT_XML_EXP,
59                unicodeException = HAL_EVENT_UNICODE_EXP,
60                peer = HAL_EVENT_PEER,
61                tracker = HAL_EVENT_TRACKER,
62                infoCode
63        };
64       
65        static std::wstring eventLevelToStr(eventLevel);       
66        void post(boost::shared_ptr<EventDetail> event);
67       
68        boost::signals::connection attach(boost::function<void (boost::shared_ptr<EventDetail>)> fn)
69        {
70                return event_signal_.connect(fn);
71        }
72
73        void signal(boost::shared_ptr<EventDetail> e)
74        {
75                mutex_t::scoped_lock l(mutex_);
76
77                event_signal_(e);
78        }
79       
80private:
81        mutable mutex_t mutex_;
82
83        boost::signal<void (boost::shared_ptr<EventDetail>)> event_signal_;
84};
85
86Event& event();
87
88class EventDetail
89{
90public:
91        EventDetail(Event::eventLevel l, boost::posix_time::ptime t, Event::codes c) :
92                level_(l),
93                timeStamp_(t),
94                code_(c)
95        {}
96        virtual ~EventDetail() 
97        {}
98       
99        virtual std::wstring msg()
100        {
101                return (boost::wformat(L"Code %1%") % code()).str();
102        }
103
104        Event::eventLevel level() { return level_; }
105        boost::posix_time::ptime timeStamp() { return timeStamp_; }
106        Event::codes code() { return code_; }
107       
108private:       
109        Event::eventLevel level_;
110        boost::posix_time::ptime timeStamp_;
111        Event::codes code_;
112};
113
114class EventLibtorrent : public EventDetail
115{
116public:
117        EventLibtorrent(Event::eventLevel l, boost::posix_time::ptime t, Event::codes c, std::wstring m) :
118                EventDetail(l, t, c),
119                msg_(m)
120        {}
121       
122        virtual std::wstring msg()
123        {
124                return (boost::wformat(hal::app().res_wstr(code())) % msg_).str();
125        }
126       
127private:
128        std::wstring msg_;
129};
130
131class EventGeneral : public EventDetail
132{
133public:
134        EventGeneral(Event::eventLevel l, Event::codes c, std::wstring m) :
135                EventDetail(l, boost::posix_time::second_clock::universal_time(), c),
136                msg_(m)
137        {}
138       
139        EventGeneral(Event::eventLevel l, boost::posix_time::ptime t, std::wstring m) :
140                EventDetail(l, t, Event::noEvent),
141                msg_(m)
142        {}
143       
144        template<typename str_t>
145        EventGeneral(Event::eventLevel l, str_t m) :
146                EventDetail(l, boost::posix_time::second_clock::universal_time(), Event::noEvent),
147                msg_(hal::to_wstr_shim(m))
148        {}
149       
150        template<typename str_t>       
151        EventGeneral(Event::eventLevel l, boost::posix_time::ptime t, str_t m) :
152                EventDetail(l, t, Event::noEvent),
153                msg_(hal::to_wstr_shim(m))
154        {}
155       
156        virtual std::wstring msg()
157        {
158                if (Event::noEvent != code())
159                        return (boost::wformat(hal::app().res_wstr(code())) % msg_).str();
160                else
161                        return msg_;
162        }
163       
164private:
165        std::wstring msg_;
166};
167
168class EventMsg : public EventDetail
169{
170public:
171        template<typename str_t>
172        EventMsg(str_t m, Event::eventLevel l=Event::debug, 
173                boost::posix_time::ptime t=boost::posix_time::second_clock::universal_time(), Event::codes c=Event::noEvent) :
174                EventDetail(l, t, c),
175                msg_(hal::to_wstr_shim(m))
176        {}
177       
178        virtual std::wstring msg()
179        {
180                if (Event::noEvent != code())
181                        return (boost::wformat(hal::app().res_wstr(code())) % msg_).str();
182                else
183                        return msg_;
184        }
185       
186private:
187        std::wstring msg_;
188};
189
190class EventPeerAlert : public EventDetail
191{
192public:
193        EventPeerAlert(Event::eventLevel l, boost::posix_time::ptime t, std::wstring m) :
194                EventDetail(l, t, Event::peer),
195                msg_(m)
196        {}
197       
198        virtual std::wstring msg()
199        {
200                return (boost::wformat(hal::app().res_wstr(code())) % msg_).str();
201        }
202       
203private:
204        std::wstring msg_;
205};
206
207class EventXmlException : public EventDetail
208{
209public:
210        EventXmlException(std::wstring e, std::wstring m) :
211                EventDetail(Event::warning, boost::posix_time::second_clock::universal_time(), Event::xmlException),
212                exp_(e),
213                msg_(m)
214        {}
215       
216        virtual std::wstring msg()
217        {
218                return (boost::wformat(hal::app().res_wstr(HAL_EVENT_XML_EXP)) % exp_ % msg_).str();
219        }
220       
221private:
222        std::wstring exp_;
223        std::wstring msg_;
224};
225
226class EventInvalidTorrent : public EventDetail
227{
228public:
229        template<typename t_str, typename f_str>
230        EventInvalidTorrent(Event::eventLevel l, Event::codes code, t_str t, f_str f) :
231                EventDetail(l, boost::posix_time::second_clock::universal_time(), code),
232                torrent_(hal::to_wstr_shim(t)),
233                function_(hal::to_wstr_shim(f))
234        {}
235       
236        virtual std::wstring msg()
237        {
238                return (boost::wformat(hal::app().res_wstr(code())) % torrent_ % function_).str();
239        }
240       
241private:
242        std::wstring function_;
243        std::wstring torrent_;
244        std::wstring exception_;
245};
246
247class EventTorrentException : public EventDetail
248{
249public:
250        template<typename e_str, typename t_str, typename f_str>
251        EventTorrentException(Event::eventLevel l, Event::codes code, e_str e, t_str t, f_str f) :
252                EventDetail(l, boost::posix_time::second_clock::universal_time(), code),
253                torrent_(hal::to_wstr_shim(t)),
254                function_(hal::to_wstr_shim(f)),
255                exception_(hal::to_wstr_shim(e))
256        {}
257       
258        virtual std::wstring msg()
259        {
260                return (boost::wformat(hal::app().res_wstr(code())) % torrent_ % exception_ % function_).str();
261        }
262       
263private:
264        std::wstring torrent_;
265        std::wstring function_;
266        std::wstring exception_;
267};
268
269class EventStdException : public EventDetail
270{
271public:
272        EventStdException(Event::eventLevel l, const std::exception& e, std::wstring from) :
273                EventDetail(l, boost::posix_time::second_clock::universal_time(), Event::generalException),
274                exception_(hal::from_utf8(e.what())),
275                from_(from)
276        {}
277       
278        virtual std::wstring msg()
279        {
280                return (boost::wformat(hal::app().res_wstr(code())) % exception_ % from_).str();
281        }
282       
283private:
284        std::wstring exception_;
285        std::wstring from_;
286};
287
288class EventDebug : public EventDetail
289{
290public:
291        EventDebug(Event::eventLevel l, std::wstring msg) :
292                EventDetail(l, boost::posix_time::second_clock::universal_time(), Event::debugEvent),
293                msg_(msg)
294        {}
295       
296        virtual std::wstring msg()
297        {
298                return (boost::wformat(hal::app().res_wstr(code())) % msg_).str();
299        }
300       
301private:
302        std::wstring msg_;
303};
304
305class EventInfo : public EventDetail
306{
307public:
308        EventInfo(std::wstring msg) :
309                EventDetail(Event::info, boost::posix_time::second_clock::universal_time(), Event::infoCode),
310                msg_(msg)
311        {}
312       
313        virtual std::wstring msg() { return msg_; }
314       
315private:
316        std::wstring msg_;
317};
318
319class EventSession : public EventDetail
320{
321
322};
323
324}// namespace hal
325
326#endif
Note: See TracBrowser for help on using the repository browser.