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_error_alert_doc;
  18 extern char const* tracker_warning_alert_doc;
  19 extern char const* tracker_reply_alert_doc;
  20 extern char const* tracker_announce_alert_doc;
  21 extern char const* hash_failed_alert_doc;
  22 extern char const* peer_ban_alert_doc;
  23 extern char const* peer_error_alert_doc;
  24 extern char const* invalid_request_alert_doc;
  25 extern char const* peer_request_doc;
  26 extern char const* torrent_finished_alert_doc;
  27 extern char const* piece_finished_alert_doc;
  28 extern char const* block_finished_alert_doc;
  29 extern char const* block_downloading_alert_doc;
  30 extern char const* storage_moved_alert_doc;
  31 extern char const* torrent_deleted_alert_doc;
  32 extern char const* torrent_paused_alert_doc;
  33 extern char const* torrent_checked_alert_doc;
  34 extern char const* url_seed_alert_doc;
  35 extern char const* file_error_alert_doc;
  36 extern char const* metadata_failed_alert_doc;
  37 extern char const* metadata_received_alert_doc;
  38 extern char const* listen_failed_alert_doc;
  39 extern char const* listen_succeeded_alert_doc;
  40 extern char const* portmap_error_alert_doc;
  41 extern char const* portmap_alert_doc;
  42 extern char const* fastresume_rejected_alert_doc;
  43 extern char const* peer_blocked_alert_doc;
  44 extern char const* scrape_reply_alert_doc;
  45 extern char const* scrape_failed_alert_doc;
  46 extern char const* udp_error_alert_doc;
  47 extern char const* external_ip_alert_doc;
  48 extern char const* save_resume_data_alert_doc;
  49
  50 void bind_alert()
  51 {
  52     using boost::noncopyable;
  53
  54     {
  55         scope alert_scope = class_<alert, noncopyable>("alert", alert_doc, no_init)
  56             .def("message", &alert::message, alert_msg_doc)
  57             .def("what", &alert::what)
  58             .def("category", &alert::category)
  59             .def("severity", &alert::severity, alert_severity_doc)
  60             .def("__str__", &alert::message, alert_msg_doc)
  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         enum_<alert::category_t>("category_t")
  73             .value("error_notification", alert::error_notification)
  74             .value("peer_notification", alert::peer_notification)
  75             .value("port_mapping_notification", alert::port_mapping_notification)
  76             .value("storage_notification", alert::storage_notification)
  77             .value("tracker_notification", alert::tracker_notification)
  78             .value("debug_notification", alert::debug_notification)
  79             .value("status_notification", alert::status_notification)
  80             .value("progress_notification", alert::progress_notification)
  81             .value("ip_block_notification", alert::ip_block_notification)
  82             .value("all_categories", alert::all_categories)
  83             ;
  84     }
  85
  86     class_<torrent_alert, bases<alert>, noncopyable>(
  87         "torrent_alert", torrent_alert_doc, no_init
  88     )
  89         .def_readonly("handle", &torrent_alert::handle)
  90         ;
  91
  92     class_<tracker_alert, bases<torrent_alert>, noncopyable>(
  93         "tracker_alert", tracker_alert_doc, no_init
  94     )
  95         .def_readonly("url", &tracker_alert::url)
  96         ;
  97
  98     class_<peer_alert, bases<torrent_alert>, noncopyable>(
  99         "peer_alert", no_init
 100     )
 101         .def_readonly("ip", &peer_alert::ip)
 102         .def_readonly("pid", &peer_alert::pid)
 103     ;
 104     class_<tracker_error_alert, bases<tracker_alert>, noncopyable>(
 105         "tracker_error_alert", tracker_error_alert_doc, no_init
 106     )
 107         .def_readonly("times_in_row", &tracker_error_alert::times_in_row)
 108         .def_readonly("status_code", &tracker_error_alert::status_code)
 109         ;
 110
 111     class_<tracker_warning_alert, bases<tracker_alert>, noncopyable>(
 112         "tracker_warning_alert", tracker_warning_alert_doc, no_init
 113     );
 114
 115     class_<tracker_reply_alert, bases<tracker_alert>, noncopyable>(
 116         "tracker_reply_alert", tracker_reply_alert_doc, no_init
 117     )
 118         .def_readonly("num_peers", &tracker_reply_alert::num_peers)
 119         ;
 120
 121     class_<tracker_announce_alert, bases<tracker_alert>, noncopyable>(
 122         "tracker_announce_alert", tracker_announce_alert_doc, no_init
 123     );
 124
 125     class_<hash_failed_alert, bases<torrent_alert>, noncopyable>(
 126         "hash_failed_alert", hash_failed_alert_doc, no_init
 127     )
 128         .def_readonly("piece_index", &hash_failed_alert::piece_index)
 129         ;
 130
 131     class_<peer_ban_alert, bases<peer_alert>, noncopyable>(
 132         "peer_ban_alert", peer_ban_alert_doc, no_init
 133     );
 134
 135     class_<peer_error_alert, bases<peer_alert>, noncopyable>(
 136         "peer_error_alert", peer_error_alert_doc, no_init
 137     );
 138
 139     class_<invalid_request_alert, bases<peer_alert>, noncopyable>(
 140         "invalid_request_alert", invalid_request_alert_doc, no_init
 141     )
 142         .def_readonly("request", &invalid_request_alert::request)
 143         ;
 144
 145     class_<peer_request>("peer_request", peer_request_doc)
 146         .def_readonly("piece", &peer_request::piece)
 147         .def_readonly("start", &peer_request::start)
 148         .def_readonly("length", &peer_request::length)
 149         .def(self == self)
 150         ;
 151
 152     class_<torrent_finished_alert, bases<torrent_alert>, noncopyable>(
 153         "torrent_finished_alert", torrent_finished_alert_doc, no_init
 154     );
 155
 156     class_<piece_finished_alert, bases<torrent_alert>, noncopyable>(
 157         "piece_finished_alert", piece_finished_alert_doc, no_init
 158     )
 159         .def_readonly("piece_index", &piece_finished_alert::piece_index)
 160         ;
 161
 162     class_<block_finished_alert, bases<peer_alert>, noncopyable>(
 163         "block_finished_alert", block_finished_alert_doc, no_init
 164     )
 165         .def_readonly("block_index", &block_finished_alert::block_index)
 166         .def_readonly("piece_index", &block_finished_alert::piece_index)
 167         ;
 168
 169     class_<block_downloading_alert, bases<peer_alert>, noncopyable>(
 170         "block_downloading_alert", block_downloading_alert_doc, no_init
 171     )
 172         .def_readonly("peer_speedmsg", &block_downloading_alert::peer_speedmsg)
 173         .def_readonly("block_index", &block_downloading_alert::block_index)
 174         .def_readonly("piece_index", &block_downloading_alert::piece_index)
 175         ;
 176
 177     class_<storage_moved_alert, bases<torrent_alert>, noncopyable>(
 178         "storage_moved_alert", storage_moved_alert_doc, no_init
 179     );
 180
 181     class_<torrent_deleted_alert, bases<torrent_alert>, noncopyable>(
 182         "torrent_deleted_alert", torrent_deleted_alert_doc, no_init
 183     );
 184
 185     class_<torrent_paused_alert, bases<torrent_alert>, noncopyable>(
 186         "torrent_paused_alert", torrent_paused_alert_doc, no_init
 187     );
 188
 189     class_<torrent_checked_alert, bases<torrent_alert>, noncopyable>(
 190         "torrent_checked_alert", torrent_checked_alert_doc, no_init
 191     );
 192
 193     class_<url_seed_alert, bases<torrent_alert>, noncopyable>(
 194         "url_seed_alert", url_seed_alert_doc, no_init
 195     )
 196         .def_readonly("url", &url_seed_alert::url)
 197         ;
 198
 199     class_<file_error_alert, bases<torrent_alert>, noncopyable>(
 200         "file_error_alert", file_error_alert_doc, no_init
 201     )
 202         .def_readonly("file", &file_error_alert::file)
 203         ;
 204
 205     class_<metadata_failed_alert, bases<torrent_alert>, noncopyable>(
 206         "metadata_failed_alert", metadata_failed_alert_doc, no_init
 207     );
 208
 209     class_<metadata_received_alert, bases<torrent_alert>, noncopyable>(
 210         "metadata_received_alert", metadata_received_alert_doc, no_init
 211     );
 212
 213     class_<listen_failed_alert, bases<alert>, noncopyable>(
 214         "listen_failed_alert", listen_failed_alert_doc, no_init
 215     );
 216
 217     class_<listen_succeeded_alert, bases<alert>, noncopyable>(
 218         "listen_succeeded_alert", listen_succeeded_alert_doc, no_init
 219     )
 220         .def_readonly("endpoint", &listen_succeeded_alert::endpoint)
 221         ;
 222
 223     class_<portmap_error_alert, bases<alert>, noncopyable>(
 224         "portmap_error_alert", portmap_error_alert_doc, no_init
 225     )
 226         .def_readonly("mapping", &portmap_error_alert::mapping)
 227         .def_readonly("type", &portmap_error_alert::type)
 228         ;
 229
 230     class_<portmap_alert, bases<alert>, noncopyable>(
 231         "portmap_alert", portmap_alert_doc, no_init
 232     )
 233         .def_readonly("mapping", &portmap_alert::mapping)
 234         .def_readonly("external_port", &portmap_alert::external_port)
 235         .def_readonly("type", &portmap_alert::type)
 236         ;
 237
 238     class_<fastresume_rejected_alert, bases<torrent_alert>, noncopyable>(
 239         "fastresume_rejected_alert", fastresume_rejected_alert_doc, no_init
 240     );
 241
 242     class_<peer_blocked_alert, bases<alert>, noncopyable>(
 243         "peer_blocked_alert", peer_blocked_alert_doc, no_init
 244     )
 245         .def_readonly("ip", &peer_blocked_alert::ip)
 246         ;
 247
 248     class_<scrape_reply_alert, bases<tracker_alert>, noncopyable>(
 249         "scrape_reply_alert", scrape_reply_alert_doc, no_init
 250     )
 251         .def_readonly("incomplete", &scrape_reply_alert::incomplete)
 252         .def_readonly("complete", &scrape_reply_alert::complete)
 253         ;
 254
 255     class_<scrape_failed_alert, bases<tracker_alert>, noncopyable>(
 256         "scrape_failed_alert", scrape_failed_alert_doc, no_init
 257     );
 258
 259     class_<udp_error_alert, bases<alert>, noncopyable>(
 260         "udp_error_alert", udp_error_alert_doc, no_init
 261     )
 262         .def_readonly("endpoint", &udp_error_alert::endpoint)
 263         ;
 264
 265     class_<external_ip_alert, bases<alert>, noncopyable>(
 266         "external_ip_alert", external_ip_alert_doc, no_init
 267     )
 268         .def_readonly("external_address", &external_ip_alert::external_address)
 269         ;
 270
 271     class_<save_resume_data_alert, bases<torrent_alert>, noncopyable>(
 272         "save_resume_data_alert", save_resume_data_alert_doc, no_init
 273     )
 274         .def_readonly("resume_data", &save_resume_data_alert::resume_data)
 275         ;
 276
 277     class_<file_renamed_alert, bases<torrent_alert>, noncopyable>(
 278         "file_renamed_alert", no_init
 279     )
 280         .def_readonly("name", &file_renamed_alert::name)
 281         ;
 282
 283     class_<file_rename_failed_alert, bases<torrent_alert>, noncopyable>(
 284         "file_rename_failed_alert", no_init
 285     )
 286         .def_readonly("index", &file_rename_failed_alert::index)
 287         ;
 288
 289     class_<torrent_resumed_alert, bases<torrent_alert>, noncopyable>(
 290         "torrent_resumed_alert", no_init
 291         );
 292
 293         class_<state_changed_alert, bases<torrent_alert>, noncopyable>(
 294             "state_changed_alert", no_init
 295         )
 296             .def_readonly("state", &state_changed_alert::state)
 297             ;
 298
 299         class_<dht_reply_alert, bases<tracker_alert>, noncopyable>(
 300             "dht_reply_alert", no_init
 301         )
 302             .def_readonly("num_peers", &dht_reply_alert::num_peers)
 303             ;
 304
 305         class_<peer_unsnubbed_alert, bases<peer_alert>, noncopyable>(
 306             "peer_unsnubbed_alert", no_init
 307         );
 308
 309         class_<peer_snubbed_alert, bases<peer_alert>, noncopyable>(
 310             "peer_snubbed_alert", no_init
 311         );
 312
 313     class_<peer_connect_alert, bases<peer_alert>, noncopyable>(
 314         "peer_connect_alert", no_init
 315     );
 316
 317     class_<peer_disconnected_alert, bases<peer_alert>, noncopyable>(
 318         "peer_disconnected_alert", no_init
 319     );
 320
 321     class_<request_dropped_alert, bases<peer_alert>, noncopyable>(
 322         "request_dropped_alert", no_init
 323     )
 324         .def_readonly("block_index", &request_dropped_alert::block_index)
 325         .def_readonly("piece_index", &request_dropped_alert::piece_index)
 326     ;
 327
 328     class_<block_timeout_alert, bases<peer_alert>, noncopyable>(
 329         "block_timeout_alert", no_init
 330     )
 331         .def_readonly("block_index", &block_timeout_alert::block_index)
 332         .def_readonly("piece_index", &block_timeout_alert::piece_index)
 333     ;
 334
 335     class_<unwanted_block_alert, bases<peer_alert>, noncopyable>(
 336         "unwanted_block_alert", no_init
 337     )
 338         .def_readonly("block_index", &unwanted_block_alert::block_index)
 339         .def_readonly("piece_index", &unwanted_block_alert::piece_index)
 340     ;
 341
 342     class_<torrent_delete_failed_alert, bases<torrent_alert>, noncopyable>(
 343         "torrent_delete_failed_alert", no_init
 344     );
 345
 346     class_<save_resume_data_failed_alert, bases<torrent_alert>, noncopyable>(
 347         "save_resume_data_failed_alert", no_init
 348     );
 349
 350 }