source: src/halEvent.hpp @ 345

Revision 345, 6.7 KB checked in by Eoin, 12 years ago (diff)

Minor renaming and attempts to decouple GUI from Torrents.

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