make alert category flags be a strong type

Author: arvidn

bindings/python/src/alert.cpp

@@ -235,6 +235,8 @@ namespace boost
 #undef POLY
 }
 
+struct dummy3 {};
+
 void bind_alert()
 {
     using boost::noncopyable;
@@ -263,31 +265,28 @@ void bind_alert()
             ;
 #endif
 
-        enum_<alert::category_t>("category_t")
-            .value("error_notification", alert::error_notification)
-            .value("peer_notification", alert::peer_notification)
-            .value("port_mapping_notification", alert::port_mapping_notification)
-            .value("storage_notification", alert::storage_notification)
-            .value("tracker_notification", alert::tracker_notification)
-            .value("debug_notification", alert::debug_notification)
-            .value("status_notification", alert::status_notification)
-            .value("progress_notification", alert::progress_notification)
-            .value("ip_block_notification", alert::ip_block_notification)
-            .value("performance_warning", alert::performance_warning)
-            .value("dht_notification", alert::dht_notification)
-            .value("stats_notification", alert::stats_notification)
-            .value("session_log_notification", alert::session_log_notification)
-            .value("torrent_log_notification", alert::torrent_log_notification)
-            .value("peer_log_notification", alert::peer_log_notification)
-            .value("incoming_request_notification", alert::incoming_request_notification)
-            .value("dht_log_notification", alert::dht_log_notification)
-            .value("dht_operation_notification", alert::dht_operation_notification)
-            .value("port_mapping_log_notification", alert::port_mapping_log_notification)
-            .value("picker_log_notification", alert::picker_log_notification)
-            // deliberately not INT_MAX. Arch linux crash while throwing an exception
-            .value("all_categories", (alert::category_t)0xfffffff)
-            ;
-
+        scope s = class_<dummy3>("category_t");
+        s.attr("error_notification") = alert::error_notification;
+        s.attr("peer_notification") = alert::peer_notification;
+        s.attr("port_mapping_notification") = alert::port_mapping_notification;
+        s.attr("storage_notification") = alert::storage_notification;
+        s.attr("tracker_notification") = alert::tracker_notification;
+        s.attr("debug_notification") = alert::debug_notification;
+        s.attr("status_notification") = alert::status_notification;
+        s.attr("progress_notification") = alert::progress_notification;
+        s.attr("ip_block_notification") = alert::ip_block_notification;
+        s.attr("performance_warning") = alert::performance_warning;
+        s.attr("dht_notification") = alert::dht_notification;
+        s.attr("stats_notification") = alert::stats_notification;
+        s.attr("session_log_notification") = alert::session_log_notification;
+        s.attr("torrent_log_notification") = alert::torrent_log_notification;
+        s.attr("peer_log_notification") = alert::peer_log_notification;
+        s.attr("incoming_request_notification") = alert::incoming_request_notification;
+        s.attr("dht_log_notification") = alert::dht_log_notification;
+        s.attr("dht_operation_notification") = alert::dht_operation_notification;
+        s.attr("port_mapping_log_notification") = alert::port_mapping_log_notification;
+        s.attr("picker_log_notification") = alert::picker_log_notification;
+        s.attr("all_categories") = alert::all_categories;
     }
 
     enum_<operation_t>("operation_t")

bindings/python/src/converters.cpp

@@ -15,6 +15,7 @@
 #include "libtorrent/aux_/noexcept_movable.hpp"
 #include "libtorrent/peer_info.hpp"
 #include "libtorrent/alert_types.hpp" // for picker_flags_t
+#include "libtorrent/alert.hpp"
 #include <vector>
 
 using namespace boost::python;
@@ -297,6 +298,7 @@ void bind_converters()
     to_python_converter<lt::bandwidth_state_flags_t, from_bitfield_flag<lt::bandwidth_state_flags_t>>();
     to_python_converter<lt::file_open_mode_t, from_bitfield_flag<lt::file_open_mode_t>>();
     to_python_converter<lt::picker_flags_t, from_bitfield_flag<lt::picker_flags_t>>();
+    to_python_converter<lt::alert_category_t, from_bitfield_flag<lt::alert_category_t>>();
 
     // work-around types
     to_python_converter<lt::aux::noexcept_movable<lt::address>, address_to_tuple<
@@ -345,4 +347,5 @@ void bind_converters()
     to_bitfield_flag<lt::bandwidth_state_flags_t>();
     to_bitfield_flag<lt::file_open_mode_t>();
     to_bitfield_flag<lt::picker_flags_t>();
+    to_bitfield_flag<lt::alert_category_t>();
 }

examples/client_test.cpp

@@ -1260,13 +1260,13 @@ MAGNETURL is a magnet link
 	settings.set_str(settings_pack::user_agent, "client_test/" LIBTORRENT_VERSION);
 	settings.set_int(settings_pack::alert_mask, alert::all_categories
 		& ~(alert::dht_notification
-		+ alert::progress_notification
-		+ alert::stats_notification
-		+ alert::session_log_notification
-		+ alert::torrent_log_notification
-		+ alert::peer_log_notification
-		+ alert::dht_log_notification
-		+ alert::picker_log_notification
+		| alert::progress_notification
+		| alert::stats_notification
+		| alert::session_log_notification
+		| alert::torrent_log_notification
+		| alert::peer_log_notification
+		| alert::dht_log_notification
+		| alert::picker_log_notification
 		));
 
 	lt::session ses(std::move(params));

include/libtorrent/alert.hpp

@@ -43,7 +43,7 @@ POSSIBILITY OF SUCH DAMAGE.
 //
 // By default, only errors are reported. settings_pack::alert_mask can be
 // used to specify which kinds of events should be reported. The alert mask is
-// comprised by bits from the category_t enum.
+// a combination of the alert_category_t flags in the alert class.
 //
 // Every alert belongs to one or more category. There is a cost associated with
 // posting alerts. Only alerts that belong to an enabled category are
@@ -63,9 +63,14 @@ POSSIBILITY OF SUCH DAMAGE.
 
 #include "libtorrent/time.hpp"
 #include "libtorrent/config.hpp"
+#include "libtorrent/flags.hpp"
 
 namespace libtorrent {
 
+	// hidden
+	struct alert_category_tag;
+	using alert_category_t = flags::bitfield_flag<std::uint32_t, alert_category_tag>;
+
 	// The ``alert`` class is the base class that specific messages are derived from.
 	// alert types are not copyable, and cannot be constructed by the client. The
 	// pointers returned by libtorrent are short lived (the details are described
@@ -83,112 +88,107 @@ namespace libtorrent {
 		enum TORRENT_DEPRECATED severity_t { debug, info, warning, critical, fatal, none };
 #endif
 
-		// these are bits for the alert_mask used by the session. See
-		// settings_pack::alert_mask.
-		enum category_t
-		{
-			// Enables alerts that report an error. This includes:
-			//
-			// * tracker errors
-			// * tracker warnings
-			// * file errors
-			// * resume data failures
-			// * web seed errors
-			// * .torrent files errors
-			// * listen socket errors
-			// * port mapping errors
-			error_notification            = 0x1,
-
-			// Enables alerts when peers send invalid requests, get banned or
-			// snubbed.
-			peer_notification             = 0x2,
-
-			// Enables alerts for port mapping events. For NAT-PMP and UPnP.
-			port_mapping_notification     = 0x4,
-
-			// Enables alerts for events related to the storage. File errors and
-			// synchronization events for moving the storage, renaming files etc.
-			storage_notification          = 0x8,
-
-			// Enables all tracker events. Includes announcing to trackers,
-			// receiving responses, warnings and errors.
-			tracker_notification          = 0x10,
-
-			// Low level alerts for when peers are connected and disconnected.
-			debug_notification            = 0x20,
-
-			// Enables alerts for when a torrent or the session changes state.
-			status_notification           = 0x40,
-
-			// Alerts for when blocks are requested and completed. Also when
-			// pieces are completed.
-			progress_notification         = 0x80,
-
-			// Alerts when a peer is blocked by the ip blocker or port blocker.
-			ip_block_notification         = 0x100,
-
-			// Alerts when some limit is reached that might limit the download
-			// or upload rate.
-			performance_warning           = 0x200,
-
-			// Alerts on events in the DHT node. For incoming searches or
-			// bootstrapping being done etc.
-			dht_notification              = 0x400,
-
-			// If you enable these alerts, you will receive a stats_alert
-			// approximately once every second, for every active torrent.
-			// These alerts contain all statistics counters for the interval since
-			// the lasts stats alert.
-			stats_notification            = 0x800,
+		// Enables alerts that report an error. This includes:
+		//
+		// * tracker errors
+		// * tracker warnings
+		// * file errors
+		// * resume data failures
+		// * web seed errors
+		// * .torrent files errors
+		// * listen socket errors
+		// * port mapping errors
+		static constexpr alert_category_t error_notification{0x1};
+
+		// Enables alerts when peers send invalid requests, get banned or
+		// snubbed.
+		static constexpr alert_category_t peer_notification{0x2};
+
+		// Enables alerts for port mapping events. For NAT-PMP and UPnP.
+		static constexpr alert_category_t port_mapping_notification{0x4};
+
+		// Enables alerts for events related to the storage. File errors and
+		// synchronization events for moving the storage, renaming files etc.
+		static constexpr alert_category_t storage_notification{0x8};
+
+		// Enables all tracker events. Includes announcing to trackers,
+		// receiving responses, warnings and errors.
+		static constexpr alert_category_t tracker_notification{0x10};
+
+		// Low level alerts for when peers are connected and disconnected.
+		static constexpr alert_category_t debug_notification{0x20};
+
+		// Enables alerts for when a torrent or the session changes state.
+		static constexpr alert_category_t status_notification{0x40};
+
+		// Alerts for when blocks are requested and completed. Also when
+		// pieces are completed.
+		static constexpr alert_category_t progress_notification{0x80};
+
+		// Alerts when a peer is blocked by the ip blocker or port blocker.
+		static constexpr alert_category_t ip_block_notification{0x100};
+
+		// Alerts when some limit is reached that might limit the download
+		// or upload rate.
+		static constexpr alert_category_t performance_warning{0x200};
+
+		// Alerts on events in the DHT node. For incoming searches or
+		// bootstrapping being done etc.
+		static constexpr alert_category_t dht_notification{0x400};
+
+		// If you enable these alerts, you will receive a stats_alert
+		// approximately once every second, for every active torrent.
+		// These alerts contain all statistics counters for the interval since
+		// the lasts stats alert.
+		static constexpr alert_category_t stats_notification{0x800};
 
 #ifndef TORRENT_NO_DEPRECATE
-			// Alerts on RSS related events, like feeds being updated, feed error
-			// conditions and successful RSS feed updates. Enabling this category
-			// will make you receive rss_alert alerts.
-			rss_notification TORRENT_DEPRECATED_ENUM = 0x1000,
+		// Alerts on RSS related events, like feeds being updated, feed error
+		// conditions and successful RSS feed updates. Enabling this category
+		// will make you receive rss_alert alerts.
+		static constexpr alert_category_t TORRENT_DEPRECATED_MEMBER rss_notification{0x1000};
 #endif
 
-			// Enables debug logging alerts. These are available unless libtorrent
-			// was built with logging disabled (``TORRENT_DISABLE_LOGGING``). The
-			// alerts being posted are log_alert and are session wide.
-			session_log_notification      = 0x2000,
+		// Enables debug logging alerts. These are available unless libtorrent
+		// was built with logging disabled (``TORRENT_DISABLE_LOGGING``). The
+		// alerts being posted are log_alert and are session wide.
+		static constexpr alert_category_t session_log_notification{0x2000};
 
-			// Enables debug logging alerts for torrents. These are available
-			// unless libtorrent was built with logging disabled
-			// (``TORRENT_DISABLE_LOGGING``). The alerts being posted are
-			// torrent_log_alert and are torrent wide debug events.
-			torrent_log_notification      = 0x4000,
+		// Enables debug logging alerts for torrents. These are available
+		// unless libtorrent was built with logging disabled
+		// (``TORRENT_DISABLE_LOGGING``). The alerts being posted are
+		// torrent_log_alert and are torrent wide debug events.
+		static constexpr alert_category_t torrent_log_notification{0x4000};
 
-			// Enables debug logging alerts for peers. These are available unless
-			// libtorrent was built with logging disabled
-			// (``TORRENT_DISABLE_LOGGING``). The alerts being posted are
-			// peer_log_alert and low-level peer events and messages.
-			peer_log_notification         = 0x8000,
+		// Enables debug logging alerts for peers. These are available unless
+		// libtorrent was built with logging disabled
+		// (``TORRENT_DISABLE_LOGGING``). The alerts being posted are
+		// peer_log_alert and low-level peer events and messages.
+		static constexpr alert_category_t peer_log_notification{0x8000};
 
-			// enables the incoming_request_alert.
-			incoming_request_notification = 0x10000,
+		// enables the incoming_request_alert.
+		static constexpr alert_category_t incoming_request_notification{0x10000};
 
-			// enables dht_log_alert, debug logging for the DHT
-			dht_log_notification          = 0x20000,
+		// enables dht_log_alert, debug logging for the DHT
+		static constexpr alert_category_t dht_log_notification{0x20000};
 
-			// enable events from pure dht operations not related to torrents
-			dht_operation_notification    = 0x40000,
+		// enable events from pure dht operations not related to torrents
+		static constexpr alert_category_t dht_operation_notification{0x40000};
 
-			// enables port mapping log events. This log is useful
-			// for debugging the UPnP or NAT-PMP implementation
-			port_mapping_log_notification = 0x80000,
+		// enables port mapping log events. This log is useful
+		// for debugging the UPnP or NAT-PMP implementation
+		static constexpr alert_category_t port_mapping_log_notification{0x80000};
 
-			// enables verbose logging from the piece picker.
-			picker_log_notification       = 0x100000,
+		// enables verbose logging from the piece picker.
+		static constexpr alert_category_t picker_log_notification{0x100000};
 
-			// The full bitmask, representing all available categories.
-			//
-			// since the enum is signed, make sure this isn't
-			// interpreted as -1. For instance, boost.python
-			// does that and fails when assigning it to an
-			// unsigned parameter.
-			all_categories = 0x7fffffff
-		};
+		// The full bitmask, representing all available categories.
+		//
+		// since the enum is signed, make sure this isn't
+		// interpreted as -1. For instance, boost.python
+		// does that and fails when assigning it to an
+		// unsigned parameter.
+		static constexpr alert_category_t all_categories{0x7fffffff};
 
 		// hidden
 		alert();
@@ -242,7 +242,7 @@ namespace libtorrent {
 		virtual std::string message() const = 0;
 
 		// returns a bitmask specifying which categories this alert belong to.
-		virtual int category() const = 0;
+		virtual alert_category_t category() const = 0;
 
 #ifndef TORRENT_NO_DEPRECATE
 

include/libtorrent/alert_manager.hpp

@@ -55,7 +55,7 @@ namespace libtorrent {
 	{
 	public:
 		alert_manager(int queue_limit
-			, std::uint32_t alert_mask = alert::error_notification);
+			, alert_category_t alert_mask = alert::error_notification);
 		~alert_manager();
 
 		template <class T, typename... Args>
@@ -90,8 +90,7 @@ namespace libtorrent {
 		template <class T>
 		bool should_post() const
 		{
-			if ((m_alert_mask.load(std::memory_order_relaxed)
-				& T::static_category) == 0)
+			if (!(m_alert_mask.load(std::memory_order_relaxed) & T::static_category))
 			{
 				return false;
 			}
@@ -101,12 +100,12 @@ namespace libtorrent {
 
 		alert* wait_for_alert(time_duration max_wait);
 
-		void set_alert_mask(std::uint32_t m)
+		void set_alert_mask(alert_category_t const m)
 		{
 			m_alert_mask = m;
 		}
 
-		std::uint32_t alert_mask() const
+		alert_category_t alert_mask() const
 		{
 			return m_alert_mask;
 		}
@@ -131,7 +130,7 @@ namespace libtorrent {
 
 		mutable std::mutex m_mutex;
 		std::condition_variable m_condition;
-		std::atomic<std::uint32_t> m_alert_mask;
+		std::atomic<alert_category_t> m_alert_mask;
 		int m_queue_size_limit;
 
 		// this function (if set) is called whenever the number of alerts in