source: trunk/src/halEvent.hpp @ 370

Revision 370, 7.3 KB checked in by Eoin, 12 years ago (diff)

Updated some (not all!) copyright dates.

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