source: trunk/src/halEvent.hpp @ 503

Revision 503, 8.0 KB checked in by Eoin, 11 years ago (diff)

Cleaned up trunk alert handler code.

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