← Back to branch summary

~ubuntu-branches/ubuntu/maverick/libtorrent-rasterbar/maverick

« back to all changes in this revision

Viewing changes to bindings/python/src/alert.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Cristian Greco
  • Date: 2008-07-02 10:46:21 UTC
  • Revision ID: james.westby@ubuntu.com-20080702104621-jzx3pfke9lkcxfxn
Tags: upstream-0.13.1
Import upstream version 0.13.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
bindings/python/src/alert.cpp
 
1
// Copyright Daniel Wallin 2006. Use, modification and distribution is
 
2
// subject to the Boost Software License, Version 1.0. (See accompanying
 
3
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
4
 
 
5
#include <libtorrent/alert.hpp>
 
6
#include <libtorrent/alert_types.hpp>
 
7
#include <boost/python.hpp>
 
8
 
 
9
using namespace boost::python;
 
10
using namespace libtorrent;
 
11
 
 
12
extern char const* alert_doc;
 
13
extern char const* alert_msg_doc;
 
14
extern char const* alert_severity_doc;
 
15
extern char const* torrent_alert_doc;
 
16
extern char const* tracker_alert_doc;
 
17
extern char const* tracker_warning_alert_doc;
 
18
extern char const* tracker_reply_alert_doc;
 
19
extern char const* tracker_announce_alert_doc;
 
20
extern char const* hash_failed_alert_doc;
 
21
extern char const* peer_ban_alert_doc;
 
22
extern char const* peer_error_alert_doc;
 
23
extern char const* invalid_request_alert_doc;
 
24
extern char const* peer_request_doc;
 
25
extern char const* torrent_finished_alert_doc;
 
26
extern char const* piece_finished_alert_doc;
 
27
extern char const* block_finished_alert_doc;
 
28
extern char const* block_downloading_alert_doc;
 
29
extern char const* storage_moved_alert_doc;
 
30
extern char const* torrent_deleted_alert_doc;
 
31
extern char const* torrent_paused_alert_doc;
 
32
extern char const* torrent_checked_alert_doc;
 
33
extern char const* url_seed_alert_doc;
 
34
extern char const* file_error_alert_doc;
 
35
extern char const* metadata_failed_alert_doc;
 
36
extern char const* metadata_received_alert_doc;
 
37
extern char const* listen_failed_alert_doc;
 
38
extern char const* listen_succeeded_alert_doc;
 
39
extern char const* portmap_error_alert_doc;
 
40
extern char const* portmap_alert_doc;
 
41
extern char const* fastresume_rejected_alert_doc;
 
42
extern char const* peer_blocked_alert_doc;
 
43
extern char const* scrape_reply_alert_doc;
 
44
extern char const* scrape_failed_alert_doc;
 
45
 
 
46
void bind_alert()
 
47
{
 
48
    using boost::noncopyable;
 
49
 
 
50
    {
 
51
        scope alert_scope = class_<alert, noncopyable>("alert", alert_doc, no_init)
 
52
            .def(
 
53
                "msg", &alert::msg, return_value_policy<copy_const_reference>()
 
54
              , alert_msg_doc
 
55
            )
 
56
            .def("severity", &alert::severity, alert_severity_doc)
 
57
            .def(
 
58
                "__str__", &alert::msg, return_value_policy<copy_const_reference>()
 
59
              , alert_msg_doc
 
60
            )
 
61
            ;
 
62
 
 
63
        enum_<alert::severity_t>("severity_levels")
 
64
            .value("debug", alert::debug)
 
65
            .value("info", alert::info)
 
66
            .value("warning", alert::warning)
 
67
            .value("critical", alert::critical)
 
68
            .value("fatal", alert::fatal)
 
69
            .value("none", alert::none)
 
70
            ; 
 
71
    }
 
72
 
 
73
    class_<torrent_alert, bases<alert>, noncopyable>(
 
74
        "torrent_alert", torrent_alert_doc, no_init
 
75
    )
 
76
        .def_readonly("handle", &torrent_alert::handle)
 
77
        ;
 
78
 
 
79
    class_<tracker_alert, bases<torrent_alert>, noncopyable>(
 
80
        "tracker_alert", tracker_alert_doc, no_init
 
81
    )
 
82
        .def_readonly("times_in_row", &tracker_alert::times_in_row)
 
83
        .def_readonly("status_code", &tracker_alert::status_code)
 
84
        ;
 
85
 
 
86
    class_<tracker_warning_alert, bases<torrent_alert>, noncopyable>(
 
87
        "tracker_warning_alert", tracker_warning_alert_doc, no_init
 
88
    );
 
89
 
 
90
    class_<tracker_reply_alert, bases<torrent_alert>, noncopyable>(
 
91
        "tracker_reply_alert", tracker_reply_alert_doc, no_init
 
92
    )
 
93
        .def_readonly("num_peers", &tracker_reply_alert::num_peers)
 
94
        ;
 
95
 
 
96
    class_<tracker_announce_alert, bases<torrent_alert>, noncopyable>(
 
97
        "tracker_announce_alert", tracker_announce_alert_doc, no_init
 
98
    );
 
99
 
 
100
    class_<hash_failed_alert, bases<torrent_alert>, noncopyable>(
 
101
        "hash_failed_alert", hash_failed_alert_doc, no_init
 
102
    )
 
103
        .def_readonly("piece_index", &hash_failed_alert::piece_index)
 
104
        ;
 
105
 
 
106
    class_<peer_ban_alert, bases<torrent_alert>, noncopyable>(
 
107
        "peer_ban_alert", peer_ban_alert_doc, no_init
 
108
    )
 
109
        .def_readonly("ip", &peer_ban_alert::ip)
 
110
        ;
 
111
 
 
112
    class_<peer_error_alert, bases<alert>, noncopyable>(
 
113
        "peer_error_alert", peer_error_alert_doc, no_init
 
114
    )
 
115
        .def_readonly("ip", &peer_error_alert::ip)
 
116
        .def_readonly("pid", &peer_error_alert::pid)
 
117
        ;
 
118
 
 
119
    class_<invalid_request_alert, bases<torrent_alert>, noncopyable>(
 
120
        "invalid_request_alert", invalid_request_alert_doc, no_init
 
121
    )
 
122
        .def_readonly("ip", &invalid_request_alert::ip)
 
123
        .def_readonly("request", &invalid_request_alert::request)
 
124
        .def_readonly("pid", &invalid_request_alert::pid)
 
125
        ;
 
126
 
 
127
    class_<peer_request>("peer_request", peer_request_doc)
 
128
        .def_readonly("piece", &peer_request::piece)
 
129
        .def_readonly("start", &peer_request::start)
 
130
        .def_readonly("length", &peer_request::length)
 
131
        .def(self == self)
 
132
        ;
 
133
 
 
134
    class_<torrent_finished_alert, bases<torrent_alert>, noncopyable>(
 
135
        "torrent_finished_alert", torrent_finished_alert_doc, no_init
 
136
    );
 
137
    
 
138
    class_<piece_finished_alert, bases<torrent_alert>, noncopyable>(
 
139
        "piece_finished_alert", piece_finished_alert_doc, no_init
 
140
    )
 
141
        .def_readonly("piece_index", &piece_finished_alert::piece_index)
 
142
        ;
 
143
    
 
144
    class_<block_finished_alert, bases<torrent_alert>, noncopyable>(
 
145
        "block_finished_alert", block_finished_alert_doc, no_init
 
146
    )
 
147
        .def_readonly("block_index", &block_finished_alert::block_index)
 
148
        .def_readonly("piece_index", &block_finished_alert::piece_index)
 
149
        ;
 
150
    
 
151
    class_<block_downloading_alert, bases<torrent_alert>, noncopyable>(
 
152
        "block_downloading_alert", block_downloading_alert_doc, no_init
 
153
    )
 
154
        .def_readonly("peer_speedmsg", &block_downloading_alert::peer_speedmsg)
 
155
        .def_readonly("block_index", &block_downloading_alert::block_index)
 
156
        .def_readonly("piece_index", &block_downloading_alert::piece_index)
 
157
        ;
 
158
        
 
159
    class_<storage_moved_alert, bases<torrent_alert>, noncopyable>(
 
160
        "storage_moved_alert", storage_moved_alert_doc, no_init
 
161
    );
 
162
 
 
163
    class_<torrent_deleted_alert, bases<torrent_alert>, noncopyable>(
 
164
        "torrent_deleted_alert", torrent_deleted_alert_doc, no_init
 
165
    );
 
166
    
 
167
    class_<torrent_paused_alert, bases<torrent_alert>, noncopyable>(
 
168
        "torrent_paused_alert", torrent_paused_alert_doc, no_init
 
169
    );
 
170
 
 
171
    class_<torrent_checked_alert, bases<torrent_alert>, noncopyable>(
 
172
        "torrent_checked_alert", torrent_checked_alert_doc, no_init
 
173
    );
 
174
    
 
175
    class_<url_seed_alert, bases<torrent_alert>, noncopyable>(
 
176
        "url_seed_alert", url_seed_alert_doc, no_init
 
177
    )
 
178
        .def_readonly("url", &url_seed_alert::url)
 
179
        ;
 
180
        
 
181
    class_<file_error_alert, bases<torrent_alert>, noncopyable>(
 
182
        "file_error_alert", file_error_alert_doc, no_init
 
183
    );
 
184
    
 
185
    class_<metadata_failed_alert, bases<torrent_alert>, noncopyable>(
 
186
        "metadata_failed_alert", metadata_failed_alert_doc, no_init
 
187
    );
 
188
 
 
189
    class_<metadata_received_alert, bases<torrent_alert>, noncopyable>(
 
190
        "metadata_received_alert", metadata_received_alert_doc, no_init
 
191
    );
 
192
 
 
193
    class_<listen_failed_alert, bases<alert>, noncopyable>(
 
194
        "listen_failed_alert", listen_failed_alert_doc, no_init
 
195
    );
 
196
    
 
197
    class_<listen_succeeded_alert, bases<alert>, noncopyable>(
 
198
        "listen_succeeded_alert", listen_succeeded_alert_doc, no_init
 
199
    )
 
200
        .def_readonly("endpoint", &listen_succeeded_alert::endpoint)
 
201
        ;
 
202
    
 
203
    class_<portmap_error_alert, bases<alert>, noncopyable>(
 
204
        "portmap_error_alert", portmap_error_alert_doc, no_init
 
205
    );
 
206
 
 
207
    class_<portmap_alert, bases<alert>, noncopyable>(
 
208
        "portmap_alert", portmap_alert_doc, no_init
 
209
    );
 
210
            
 
211
    class_<fastresume_rejected_alert, bases<torrent_alert>, noncopyable>(
 
212
        "fastresume_rejected_alert", fastresume_rejected_alert_doc, no_init
 
213
    );
 
214
    
 
215
    class_<peer_blocked_alert, bases<alert>, noncopyable>(
 
216
        "peer_blocked_alert", peer_blocked_alert_doc, no_init
 
217
    )
 
218
        .def_readonly("ip", &peer_blocked_alert::ip)
 
219
        ;
 
220
        
 
221
    class_<scrape_reply_alert, bases<torrent_alert>, noncopyable>(
 
222
        "scrape_reply_alert", scrape_reply_alert_doc, no_init
 
223
    )
 
224
        .def_readonly("incomplete", &scrape_reply_alert::incomplete)
 
225
        .def_readonly("complete", &scrape_reply_alert::complete)
 
226
        ;
 
227
    
 
228
    class_<scrape_failed_alert, bases<torrent_alert>, noncopyable>(
 
229
        "scrape_failed_alert", scrape_failed_alert_doc, no_init
 
230
    );
 
231
}