source: trunk/src/halEvent.hpp @ 374

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