make add_torrent_params::flags_t an enum class and move it out into its own header

Author: arvidn

bindings/python/client.py

@@ -237,8 +237,8 @@ def main():
         atp = {}
         atp["save_path"] = options.save_path
         atp["storage_mode"] = lt.storage_mode_t.storage_mode_sparse
-        atp["flags"] = lt.add_torrent_params_flags_t.flag_duplicate_is_error \
-            | lt.add_torrent_params_flags_t.flag_auto_managed
+        atp["flags"] = lt.torrent_flags.duplicate_is_error \
+            | lt.torrent_flags.auto_managed
         if f.startswith('magnet:') or f.startswith(
                 'http://') or f.startswith('https://'):
             atp["url"] = f

bindings/python/src/converters.cpp

@@ -8,6 +8,7 @@
 #include "libtorrent/error_code.hpp"
 #include "libtorrent/session_stats.hpp" // for stats_metric
 #include "libtorrent/time.hpp"
+#include "libtorrent/torrent_flags.hpp"
 #include "libtorrent/units.hpp"
 #include "libtorrent/sha1_hash.hpp"
 #include "libtorrent/disk_interface.hpp" // for open_file_state
@@ -229,6 +230,43 @@ struct to_strong_typedef
     }
 };
 
+template<class T>
+struct from_bitfield_flag
+{
+    using underlying_type = typename T::underlying_type;
+
+    static PyObject* convert(T const v)
+    {
+        object o(static_cast<underlying_type>(v));
+        return incref(o.ptr());
+    }
+};
+
+template<typename T>
+struct to_bitfield_flag
+{
+   using underlying_type = typename T::underlying_type;
+
+   to_bitfield_flag()
+   {
+        converter::registry::push_back(
+            &convertible, &construct, type_id<T>()
+        );
+    }
+
+    static void* convertible(PyObject* x)
+    {
+        return PyNumber_Check(x) ? x : nullptr;
+    }
+
+    static void construct(PyObject* x, converter::rvalue_from_python_stage1_data* data)
+    {
+        void* storage = ((converter::rvalue_from_python_storage<T>*)data)->storage.bytes;
+        new (storage) T(extract<underlying_type>(object(borrowed(x))));
+        data->convertible = storage;
+    }
+};
+
 void bind_converters()
 {
     // C++ -> python conversions
@@ -251,6 +289,7 @@ void bind_converters()
 
     to_python_converter<lt::piece_index_t, from_strong_typedef<lt::piece_index_t>>();
     to_python_converter<lt::file_index_t, from_strong_typedef<lt::file_index_t>>();
+    to_python_converter<lt::torrent_flags_t, from_bitfield_flag<lt::torrent_flags_t>>();
 
     // work-around types
     to_python_converter<lt::aux::noexcept_movable<lt::address>, address_to_tuple<
@@ -293,4 +332,5 @@ void bind_converters()
 
     to_strong_typedef<lt::piece_index_t>();
     to_strong_typedef<lt::file_index_t>();
+    to_bitfield_flag<lt::torrent_flags_t>();
 }

bindings/python/src/module.cpp

@@ -34,6 +34,7 @@ BOOST_PYTHON_MODULE(libtorrent)
     Py_Initialize();
     PyEval_InitThreads();
 
+    bind_converters();
     bind_error_code();
     bind_utility();
     bind_fingerprint();
@@ -51,6 +52,5 @@ BOOST_PYTHON_MODULE(libtorrent)
     bind_peer_info();
     bind_ip_filter();
     bind_magnet_uri();
-    bind_converters();
     bind_create_torrent();
 }

bindings/python/src/session.cpp

@@ -229,7 +229,7 @@ namespace
             object const value = item[1];
             // torrent_info objects are always held by a shared_ptr in the
             // python binding, skip it if it is a object
-            if(key == "ti" && value != boost::python::object())
+            if (key == "ti" && value != boost::python::object())
             {
                 // make a copy here. We don't want to end up holding a python-owned
                 // object inside libtorrent. If the last reference goes out of scope
@@ -308,7 +308,7 @@ namespace
             }
             else if(key == "flags")
             {
-                p.flags = extract<std::uint64_t>(value);
+                p.flags = extract<lt::torrent_flags_t>(value);
                 continue;
             }
             else if(key == "trackerid")
@@ -560,6 +560,10 @@ namespace
 
 } // namespace unnamed
 
+struct dummy1 {};
+#ifndef TORRENT_NO_DEPRECATE
+struct dummy2 {};
+#endif
 
 void bind_session()
 {
@@ -706,28 +710,48 @@ void bind_session()
         .value("start_default_features", lt::session::start_default_features)
     ;
 
-    enum_<add_torrent_params::flags_t>("add_torrent_params_flags_t")
-        .value("flag_seed_mode", add_torrent_params::flag_seed_mode)
-        .value("flag_upload_mode", add_torrent_params::flag_upload_mode)
-        .value("flag_share_mode", add_torrent_params::flag_share_mode)
-        .value("flag_apply_ip_filter", add_torrent_params::flag_apply_ip_filter)
-        .value("flag_paused", add_torrent_params::flag_paused)
-        .value("flag_auto_managed", add_torrent_params::flag_auto_managed)
-        .value("flag_duplicate_is_error", add_torrent_params::flag_duplicate_is_error)
-        .value("flag_update_subscribe", add_torrent_params::flag_update_subscribe)
-        .value("flag_super_seeding", add_torrent_params::flag_super_seeding)
-        .value("flag_sequential_download", add_torrent_params::flag_sequential_download)
-        .value("flag_stop_when_ready", add_torrent_params::flag_stop_when_ready)
-        .value("flag_override_trackers", add_torrent_params::flag_override_trackers)
-        .value("flag_override_web_seeds", add_torrent_params::flag_override_web_seeds)
+
+    {
+    scope s = class_<dummy1>("torrent_flags");
+    s.attr("seed_mode") = torrent_flags::seed_mode;
+    s.attr("upload_mode") = torrent_flags::upload_mode;
+    s.attr("share_mode") = torrent_flags::share_mode;
+    s.attr("apply_ip_filter") = torrent_flags::apply_ip_filter;
+    s.attr("paused") = torrent_flags::paused;
+    s.attr("auto_managed") = torrent_flags::auto_managed;
+    s.attr("duplicate_is_error") = torrent_flags::duplicate_is_error;
+    s.attr("update_subscribe") = torrent_flags::update_subscribe;
+    s.attr("super_seeding") = torrent_flags::super_seeding;
+    s.attr("sequential_download") = torrent_flags::sequential_download;
+    s.attr("stop_when_ready") = torrent_flags::stop_when_ready;
+    s.attr("override_trackers") = torrent_flags::override_trackers;
+    s.attr("override_web_seeds") = torrent_flags::override_web_seeds;
+    }
+
 #ifndef TORRENT_NO_DEPRECATE
-        .value("flag_pinned", add_torrent_params::flag_pinned)
-        .value("flag_override_resume_data", add_torrent_params::flag_override_resume_data)
-        .value("flag_merge_resume_trackers", add_torrent_params::flag_merge_resume_trackers)
-        .value("flag_use_resume_save_path", add_torrent_params::flag_use_resume_save_path)
-        .value("flag_merge_resume_http_seeds", add_torrent_params::flag_merge_resume_http_seeds)
+    {
+    scope s = class_<dummy2>("add_torrent_params_flags_t");
+    s.attr("flag_seed_mode") = add_torrent_params::flag_seed_mode;
+    s.attr("flag_upload_mode") = add_torrent_params::flag_upload_mode;
+    s.attr("flag_share_mode") = add_torrent_params::flag_share_mode;
+    s.attr("flag_apply_ip_filter") = add_torrent_params::flag_apply_ip_filter;
+    s.attr("flag_paused") = add_torrent_params::flag_paused;
+    s.attr("flag_auto_managed") = add_torrent_params::flag_auto_managed;
+    s.attr("flag_duplicate_is_error") = add_torrent_params::flag_duplicate_is_error;
+    s.attr("flag_update_subscribe") = add_torrent_params::flag_update_subscribe;
+    s.attr("flag_super_seeding") = add_torrent_params::flag_super_seeding;
+    s.attr("flag_sequential_download") = add_torrent_params::flag_sequential_download;
+    s.attr("flag_stop_when_ready") = add_torrent_params::flag_stop_when_ready;
+    s.attr("flag_override_trackers") = add_torrent_params::flag_override_trackers;
+    s.attr("flag_override_web_seeds") = add_torrent_params::flag_override_web_seeds;
+    s.attr("flag_pinned") = add_torrent_params::flag_pinned;
+    s.attr("flag_override_resume_data") = add_torrent_params::flag_override_resume_data;
+    s.attr("flag_merge_resume_trackers") = add_torrent_params::flag_merge_resume_trackers;
+    s.attr("flag_use_resume_save_path") = add_torrent_params::flag_use_resume_save_path;
+    s.attr("flag_merge_resume_http_seeds") = add_torrent_params::flag_merge_resume_http_seeds;
+    }
 #endif
-    ;
+
     class_<cache_status>("cache_status")
         .add_property("pieces", cache_status_pieces)
 #ifndef TORRENT_NO_DEPRECATE

bindings/python/src/torrent_handle.cpp

@@ -437,8 +437,8 @@ void bind_torrent_handle()
     bool (torrent_handle::*super_seeding0)() const = &torrent_handle::super_seeding;
     void (torrent_handle::*super_seeding1)(bool) const = &torrent_handle::super_seeding;
 #endif
-    void (torrent_handle::*set_flags0)(boost::uint64_t) const = &torrent_handle::set_flags;
-    void (torrent_handle::*set_flags1)(boost::uint64_t, boost::uint64_t) const = &torrent_handle::set_flags;
+    void (torrent_handle::*set_flags0)(torrent_flags_t) const = &torrent_handle::set_flags;
+    void (torrent_handle::*set_flags1)(torrent_flags_t, torrent_flags_t) const = &torrent_handle::set_flags;
 
     int (torrent_handle::*piece_priority0)(piece_index_t) const = &torrent_handle::piece_priority;
     void (torrent_handle::*piece_priority1)(piece_index_t, int) const = &torrent_handle::piece_priority;
@@ -491,39 +491,13 @@ void bind_torrent_handle()
         .def("is_valid", _(&torrent_handle::is_valid))
         .def("pause", _(&torrent_handle::pause), arg("flags") = 0)
         .def("resume", _(&torrent_handle::resume))
-#ifndef TORRENT_NO_DEPRECATE
-        .def("stop_when_ready", _(&torrent_handle::stop_when_ready))
-#endif
         .def("clear_error", _(&torrent_handle::clear_error))
-#ifndef TORRENT_NO_DEPRECATE
-        .def("super_seeding", super_seeding1)
-
-        .def("auto_managed", _(&torrent_handle::auto_managed))
-#endif
         .def("queue_position", _(&torrent_handle::queue_position))
         .def("queue_position_up", _(&torrent_handle::queue_position_up))
         .def("queue_position_down", _(&torrent_handle::queue_position_down))
         .def("queue_position_top", _(&torrent_handle::queue_position_top))
         .def("queue_position_bottom", _(&torrent_handle::queue_position_bottom))
 
-        // deprecated
-#ifndef TORRENT_NO_DEPRECATE
-        .def("set_priority", _(&torrent_handle::set_priority))
-        .def("get_torrent_info", &get_torrent_info)
-#ifndef TORRENT_NO_DEPRECATE
-        .def("super_seeding", super_seeding0)
-#endif
-        .def("write_resume_data", _(&torrent_handle::write_resume_data))
-        .def("is_seed", _(&torrent_handle::is_seed))
-        .def("is_finished", _(&torrent_handle::is_finished))
-#ifndef TORRENT_NO_DEPRECATE
-        .def("is_paused", _(&torrent_handle::is_paused))
-        .def("is_auto_managed", _(&torrent_handle::is_auto_managed))
-#endif
-        .def("has_metadata", _(&torrent_handle::has_metadata))
-        .def("use_interface", &torrent_handle::use_interface)
-        .def("name", _(&torrent_handle::name))
-#endif
         .def("add_piece", add_piece)
         .def("read_piece", _(&torrent_handle::read_piece))
         .def("have_piece", _(&torrent_handle::have_piece))
@@ -549,46 +523,53 @@ void bind_torrent_handle()
         .def("force_dht_announce", _(&torrent_handle::force_dht_announce))
 #endif
         .def("scrape_tracker", _(&torrent_handle::scrape_tracker), arg("index") = -1)
-#ifndef TORRENT_NO_DEPRECATE
-        .def("set_upload_mode", _(&torrent_handle::set_upload_mode))
-        .def("set_share_mode", _(&torrent_handle::set_share_mode))
-#endif
         .def("flush_cache", &torrent_handle::flush_cache)
-#ifndef TORRENT_NO_DEPRECATE
-        .def("apply_ip_filter", &torrent_handle::apply_ip_filter)
-#endif
         .def("set_upload_limit", _(&torrent_handle::set_upload_limit))
         .def("upload_limit", _(&torrent_handle::upload_limit))
         .def("set_download_limit", _(&torrent_handle::set_download_limit))
         .def("download_limit", _(&torrent_handle::download_limit))
-#ifndef TORRENT_NO_DEPRECATE
-        .def("set_sequential_download", _(&torrent_handle::set_sequential_download))
-        .def("set_peer_upload_limit", &torrent_handle::set_peer_upload_limit)
-        .def("set_peer_download_limit", &torrent_handle::set_peer_download_limit)
-        .def("set_ratio", _(&torrent_handle::set_ratio))
-        .def("save_path", _(&torrent_handle::save_path))
-#endif
         .def("connect_peer", &torrent_handle::connect_peer, (arg("endpoint"), arg("source")=0, arg("flags")=0xd))
         .def("set_max_uploads", &torrent_handle::set_max_uploads)
         .def("max_uploads", _(&torrent_handle::max_uploads))
         .def("set_max_connections", &torrent_handle::set_max_connections)
         .def("max_connections", _(&torrent_handle::max_connections))
-#ifndef TORRENT_NO_DEPRECATE
-        .def("set_tracker_login", &torrent_handle::set_tracker_login)
-#endif
         .def("move_storage", _(move_storage0), (arg("path"), arg("flags") = move_flags_t::always_replace_files))
         .def("info_hash", _(&torrent_handle::info_hash))
         .def("force_recheck", _(&torrent_handle::force_recheck))
         .def("rename_file", _(rename_file0))
         .def("set_ssl_certificate", &torrent_handle::set_ssl_certificate, (arg("cert"), arg("private_key"), arg("dh_params"), arg("passphrase")=""))
-#if !defined TORRENT_NO_DEPRECATE
-        .def("move_storage", _(move_storage1), (arg("path"), arg("flags") = always_replace_files))
-        .def("rename_file", _(rename_file1))
-#endif
         .def("flags", _(&torrent_handle::flags))
         .def("set_flags", _(set_flags0))
         .def("set_flags", _(set_flags1))
         .def("unset_flags", _(&torrent_handle::unset_flags))
+        // deprecated
+#ifndef TORRENT_NO_DEPRECATE
+        .def("stop_when_ready", _(&torrent_handle::stop_when_ready))
+        .def("super_seeding", super_seeding1)
+        .def("auto_managed", _(&torrent_handle::auto_managed))
+        .def("set_priority", _(&torrent_handle::set_priority))
+        .def("get_torrent_info", &get_torrent_info)
+        .def("super_seeding", super_seeding0)
+        .def("write_resume_data", _(&torrent_handle::write_resume_data))
+        .def("is_seed", _(&torrent_handle::is_seed))
+        .def("is_finished", _(&torrent_handle::is_finished))
+        .def("has_metadata", _(&torrent_handle::has_metadata))
+        .def("use_interface", &torrent_handle::use_interface)
+        .def("name", _(&torrent_handle::name))
+        .def("is_paused", _(&torrent_handle::is_paused))
+        .def("is_auto_managed", _(&torrent_handle::is_auto_managed))
+        .def("set_upload_mode", _(&torrent_handle::set_upload_mode))
+        .def("set_share_mode", _(&torrent_handle::set_share_mode))
+        .def("apply_ip_filter", &torrent_handle::apply_ip_filter)
+        .def("set_sequential_download", _(&torrent_handle::set_sequential_download))
+        .def("set_peer_upload_limit", &torrent_handle::set_peer_upload_limit)
+        .def("set_peer_download_limit", &torrent_handle::set_peer_download_limit)
+        .def("set_ratio", _(&torrent_handle::set_ratio))
+        .def("save_path", _(&torrent_handle::save_path))
+        .def("set_tracker_login", &torrent_handle::set_tracker_login)
+        .def("move_storage", _(move_storage1), (arg("path"), arg("flags") = always_replace_files))
+        .def("rename_file", _(rename_file1))
+#endif
         ;
 
     class_<open_file_state>("open_file_state")

docs/hunspell/libtorrent.dic

@@ -201,4 +201,3 @@ crypto
 uri
 infohashes
 rw
-0xffffffffffffffff