source: trunk/src/halEvent.hpp @ 658

Revision 658, 9.4 KB checked in by Eoin, 11 years ago (diff)

All sorting playing nice. Now gotta expand code to other listviews.

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