fix error_code vs. error_condition traits (#1169)

fix error_code vs. error_condition traits. deprecate get_*_category(), instead use *_category()

bindings/python/src/error_code.cpp

@@ -73,30 +73,30 @@ void bind_error_code()
         .def("assign", &error_code::assign)
         ;
 
-    def("get_libtorrent_category", &get_libtorrent_category
+using return_existing = return_value_policy<reference_existing_object>;
-       , return_value_policy<reference_existing_object>());
-
-    def("get_upnp_category", &get_upnp_category
-       , return_value_policy<reference_existing_object>());
-
-    def("get_http_category", &get_http_category
-       , return_value_policy<reference_existing_object>());
-
-    def("get_socks_category", &get_socks_category
-       , return_value_policy<reference_existing_object>());
 
+    def("libtorrent_category", &libtorrent_category, return_existing());
+    def("upnp_category", &upnp_category, return_existing());
+    def("http_category", &http_category, return_existing());
+    def("socks_category", &socks_category, return_existing());
+    def("bdecode_category", &bdecode_category, return_existing());
 #if TORRENT_USE_I2P
-    def("get_i2p_category", &get_i2p_category
+    def("i2p_category", &i2p_category, return_existing());
-       , return_value_policy<reference_existing_object>());
 #endif
 
-    def("get_bdecode_category", &get_bdecode_category
+#ifndef TORRENT_NO_DEPRECATE
-       , return_value_policy<reference_existing_object>());
+    def("get_libtorrent_category", &libtorrent_category, return_existing());
+    def("get_upnp_category", &upnp_category, return_existing());
+    def("get_http_category", &http_category, return_existing());
+    def("get_socks_category", &socks_category, return_existing());
+    def("get_bdecode_category", &bdecode_category, return_existing());
+#if TORRENT_USE_I2P
+    def("get_i2p_category", &i2p_category, return_existing());
+#endif
+#endif // TORRENT_NO_DEPRECATE
 
-    def("generic_category", &boost::system::generic_category
+    def("generic_category", &boost::system::generic_category, return_existing());
-       , return_value_policy<reference_existing_object>());
 
-    def("system_category", &boost::system::system_category
+    def("system_category", &boost::system::system_category, return_existing());
-       , return_value_policy<reference_existing_object>());
 }
 

docs/manual.rst

@@ -117,7 +117,7 @@ for system errors. That is, errors that belong to the generic or system category
 
 Errors that belong to the libtorrent error category are not localized however, they
 are only available in english. In order to translate libtorrent errors, compare the
-error category of the ``error_code`` object against ``libtorrent::get_libtorrent_category()``,
+error category of the ``error_code`` object against ``libtorrent::libtorrent_category()``,
 and if matches, you know the error code refers to the list above. You can provide
 your own mapping from error code to string, which is localized. In this case, you
 cannot rely on ``error_code::message()`` to generate your strings.
@@ -131,7 +131,7 @@ Here's a simple example of how to translate error codes:
 
 	std::string error_code_to_string(boost::system::error_code const& ec)
 	{
-		if (ec.category() != libtorrent::get_libtorrent_category())
+		if (ec.category() != libtorrent::libtorrent_category())
 		{
 			return ec.message();
 		}

examples/client_test.cpp

@@ -934,8 +934,7 @@ bool handle_alert(libtorrent::session& ses, libtorrent::alert* a
 		// handshake. The peers that we successfully connect to and then
 		// disconnect is more interesting.
 		if (pd->operation == op_connect
-			|| pd->error == error_code(errors::timed_out_no_handshake
+			|| pd->error == errors::timed_out_no_handshake)
-				, get_libtorrent_category()))
 			return true;
 	}
 

include/libtorrent/bdecode.hpp

@@ -99,12 +99,18 @@ example layout:
 
 namespace libtorrent {
 
-TORRENT_EXPORT boost::system::error_category& get_bdecode_category();
+TORRENT_EXPORT boost::system::error_category& bdecode_category();
+
+#ifndef TORRENT_NO_DEPRECATED
+TORRENT_DEPRECATED
+inline boost::system::error_category& get_bdecode_category()
+{ return bdecode_category(); }
+#endif
 
 namespace bdecode_errors
 {
 	// libtorrent uses boost.system's ``error_code`` class to represent
-	// errors. libtorrent has its own error category get_bdecode_category()
+	// errors. libtorrent has its own error category bdecode_category()
 	// with the error codes defined by error_code_enum.
 	enum error_code_enum
 	{
@@ -139,8 +145,6 @@ namespace boost { namespace system {
 	template<> struct is_error_code_enum<libtorrent::bdecode_errors::error_code_enum>
 	{ static const bool value = true; };
 
-	template<> struct is_error_condition_enum<libtorrent::bdecode_errors::error_code_enum>
-	{ static const bool value = true; };
 } }
 
 namespace libtorrent {

include/libtorrent/disk_io_thread.hpp

@@ -540,13 +540,13 @@ namespace libtorrent
 		disk_io_thread_pool& pool_for_job(disk_io_job* j);
 
 		// set to true once we start shutting down
-		std::atomic<bool> m_abort;
+		std::atomic<bool> m_abort{false};
 
 		// this is a counter of how many threads are currently running.
 		// it's used to identify the last thread still running while
 		// shutting down. This last thread is responsible for cleanup
 		// must hold the job mutex to access
-		int m_num_running_threads;
+		int m_num_running_threads = 0;
 
 		// std::mutex to protect the m_generic_io_jobs and m_hash_io_jobs lists
 		mutable std::mutex m_job_mutex;
@@ -566,12 +566,12 @@ namespace libtorrent
 		void* m_userdata;
 
 		// the last time we expired write blocks from the cache
-		time_point m_last_cache_expiry;
+		time_point m_last_cache_expiry = min_time();
 
 		time_point m_last_file_check;
 
 		// LRU cache of open files
-		file_pool m_file_pool;
+		file_pool m_file_pool{40};
 
 		// disk cache
 		mutable std::mutex m_cache_mutex;
@@ -582,7 +582,7 @@ namespace libtorrent
 			cache_check_active,
 			cache_check_reinvoke
 		};
-		int m_cache_check_state;
+		int m_cache_check_state = cache_check_idle;
 
 		// total number of blocks in use by both the read
 		// and the write cache. This is not supposed to
@@ -608,7 +608,7 @@ namespace libtorrent
 		io_service& m_ios;
 
 		// used to rate limit disk performance warnings
-		time_point m_last_disk_aio_performance_warning;
+		time_point m_last_disk_aio_performance_warning = min_time();
 
 		// jobs that are completed are put on this queue
 		// whenever the queue size grows from 0 to 1
@@ -626,10 +626,10 @@ namespace libtorrent
 		// when this is true, there is an outstanding message in the
 		// message queue that will reclaim all blocks in
 		// m_blocks_to_reclaim, there's no need to send another one
-		bool m_outstanding_reclaim_message;
+		bool m_outstanding_reclaim_message = false;
 #if TORRENT_USE_ASSERTS
-		int m_magic;
+		int m_magic = 0x1337;
-		std::atomic<bool> m_jobs_aborted;
+		std::atomic<bool> m_jobs_aborted{false};
 #endif
 	};
 }

include/libtorrent/error_code.hpp

@@ -47,7 +47,7 @@ namespace libtorrent
 	{
 		// libtorrent uses boost.system's ``error_code`` class to represent
 		// errors. libtorrent has its own error category
-		// get_libtorrent_category() with the error codes defined by
+		// libtorrent_category() with the error codes defined by
 		// error_code_enum.
 		enum error_code_enum
 		{
@@ -466,10 +466,10 @@ namespace libtorrent
 
 	// return the instance of the libtorrent_error_category which
 	// maps libtorrent error codes to human readable error messages.
-	TORRENT_EXPORT boost::system::error_category& get_libtorrent_category();
+	TORRENT_EXPORT boost::system::error_category& libtorrent_category();
 
 	// returns the error_category for HTTP errors
-	TORRENT_EXPORT boost::system::error_category& get_http_category();
+	TORRENT_EXPORT boost::system::error_category& http_category();
 
 	using boost::system::error_code;
 	using boost::system::error_condition;
@@ -483,6 +483,14 @@ namespace libtorrent
 
 #ifndef TORRENT_NO_DEPRECATE
 	using system_error = boost::system::system_error;
+
+	TORRENT_DEPRECATED
+	inline boost::system::error_category& get_libtorrent_category()
+	{ return libtorrent_category(); }
+
+	TORRENT_DEPRECATED
+	inline boost::system::error_category& get_http_category()
+	{ return http_category(); }
 #endif
 #endif
 
@@ -548,14 +556,8 @@ namespace boost { namespace system {
 	template<> struct is_error_code_enum<libtorrent::errors::error_code_enum>
 	{ static const bool value = true; };
 
-	template<> struct is_error_condition_enum<libtorrent::errors::error_code_enum>
-	{ static const bool value = true; };
-
 	template<> struct is_error_code_enum<libtorrent::errors::http_errors>
 	{ static const bool value = true; };
-
-	template<> struct is_error_condition_enum<libtorrent::errors::http_errors>
-	{ static const bool value = true; };
 } }
 
 #endif

include/libtorrent/gzip.hpp

@@ -48,7 +48,13 @@ namespace libtorrent
 		, error_code& error);
 
 	// get the ``error_category`` for zip errors
-	TORRENT_EXPORT boost::system::error_category& get_gzip_category();
+	TORRENT_EXPORT boost::system::error_category& gzip_category();
+
+#ifndef TORRENT_NO_DEPRECATE
+	TORRENT_DEPRECATED
+	inline boost::system::error_category& get_gzip_category()
+	{ return gzip_category(); }
+#endif
 
 	namespace gzip_errors
 	{

include/libtorrent/i2p_stream.hpp

@@ -70,7 +70,13 @@ namespace libtorrent {
 	}
 
 	// returns the error category for I2P errors
-	TORRENT_EXPORT boost::system::error_category& get_i2p_category();
+	TORRENT_EXPORT boost::system::error_category& i2p_category();
+
+#ifndef TORRENT_NO_DEPRECATE
+	TORRENT_DEPRECATED
+	inline boost::system::error_category& get_i2p_category()
+	{ return i2p_category(); }
+#endif
 
 class i2p_stream : public proxy_base
 {
@@ -227,10 +233,6 @@ template<>
 struct is_error_code_enum<libtorrent::i2p_error::i2p_error_code>
 { static const bool value = true; };
 
-template<>
-struct is_error_condition_enum<libtorrent::i2p_error::i2p_error_code>
-{ static const bool value = true; };
-
 } }
 
 #endif // TORRENT_USE_I2P

include/libtorrent/socks5_stream.hpp

@@ -69,7 +69,13 @@ namespace socks_error {
 } // namespace socks_error
 
 // returns the error_category for SOCKS5 errors
-TORRENT_EXPORT boost::system::error_category& get_socks_category();
+TORRENT_EXPORT boost::system::error_category& socks_category();
+
+#ifndef TORRENT_NO_DEPRECATE
+TORRENT_DEPRECATED
+inline boost::system::error_category& get_socks_category()
+{ return socks_category(); }
+#endif
 
 class socks5_stream : public proxy_base
 {
@@ -254,8 +260,6 @@ namespace boost { namespace system {
 	template<> struct is_error_code_enum<libtorrent::socks_error::socks_error_code>
 	{ static const bool value = true; };
 
-	template<> struct is_error_condition_enum<libtorrent::socks_error::socks_error_code>
-	{ static const bool value = true; };
 } }
 
 #endif

include/libtorrent/upnp.hpp

@@ -91,7 +91,13 @@ namespace libtorrent
 	}
 
 	// the boost.system error category for UPnP errors
-	TORRENT_EXPORT boost::system::error_category& get_upnp_category();
+	TORRENT_EXPORT boost::system::error_category& upnp_category();
+
+#ifndef TORRENT_NO_DEPRECATED
+	TORRENT_DEPRECATED
+	inline boost::system::error_category& get_upnp_category()
+	{ return upnp_category(); }
+#endif
 
 struct parse_state
 {
@@ -193,7 +199,6 @@ private:
 	void next(rootdevice& d, int i);
 	void update_map(rootdevice& d, int i);
 
-
 	void on_upnp_xml(error_code const& e
 		, libtorrent::http_parser const& p, rootdevice& d
 		, http_connection& c);
@@ -377,8 +382,6 @@ namespace boost { namespace system {
 	template<> struct is_error_code_enum<libtorrent::upnp_errors::error_code_enum>
 	{ static const bool value = true; };
 
-	template<> struct is_error_condition_enum<libtorrent::upnp_errors::error_code_enum>
-	{ static const bool value = true; };
 } }
 
 #endif

simulation/test_tracker.cpp

@@ -476,8 +476,7 @@ TORRENT_TEST(test_error)
 			TEST_EQUAL(ae.is_working(), false);
 			TEST_EQUAL(ae.message, "test");
 			TEST_EQUAL(ae.url, "http://tracker.com:8080/announce");
-			TEST_EQUAL(ae.last_error, error_code(errors::tracker_failure
+			TEST_EQUAL(ae.last_error, error_code(errors::tracker_failure));
-				, get_libtorrent_category()));
 			TEST_EQUAL(ae.fails, 1);
 		});
 }
@@ -574,7 +573,7 @@ TORRENT_TEST(test_http_status)
 			TEST_EQUAL(ae.is_working(), false);
 			TEST_EQUAL(ae.message, "Not A Tracker");
 			TEST_EQUAL(ae.url, "http://tracker.com:8080/announce");
-			TEST_EQUAL(ae.last_error, error_code(410, get_http_category()));
+			TEST_EQUAL(ae.last_error, error_code(410, http_category()));
 			TEST_EQUAL(ae.fails, 1);
 		});
 }
@@ -621,7 +620,7 @@ TORRENT_TEST(test_invalid_bencoding)
 			TEST_EQUAL(ae.message, "");
 			TEST_EQUAL(ae.url, "http://tracker.com:8080/announce");
 			TEST_EQUAL(ae.last_error, error_code(bdecode_errors::expected_value
-				, get_bdecode_category()));
+				, bdecode_category()));
 			TEST_EQUAL(ae.fails, 1);
 		});
 }

src/bdecode.cpp

@@ -179,7 +179,7 @@ namespace libtorrent
 		return msgs[ev];
 	}
 
-	boost::system::error_category& get_bdecode_category()
+	boost::system::error_category& bdecode_category()
 	{
 		static bdecode_error_category bdecode_category;
 		return bdecode_category;
@@ -189,7 +189,7 @@ namespace libtorrent
 	{
 		boost::system::error_code make_error_code(error_code_enum e)
 		{
-			return boost::system::error_code(e, get_bdecode_category());
+			return boost::system::error_code(e, bdecode_category());
 		}
 	}
 
@@ -632,7 +632,7 @@ namespace libtorrent
 	}
 
 #define TORRENT_FAIL_BDECODE(code) do { \
-	ec = make_error_code(code); \
+	ec = code; \
 	if (error_pos) *error_pos = start - orig_start; \
 	goto done; \
 	} TORRENT_WHILE_0
@@ -646,7 +646,7 @@ namespace libtorrent
 		if (end - start > bdecode_token::max_offset)
 		{
 			if (error_pos) *error_pos = 0;
-			ec = make_error_code(bdecode_errors::limit_exceeded);
+			ec = bdecode_errors::limit_exceeded;
 			return -1;
 		}
 

src/close_reason.cpp

@@ -39,7 +39,7 @@ namespace libtorrent
 
 	close_reason_t error_to_close_reason(error_code const& ec)
 	{
-		if (ec.category() == get_libtorrent_category())
+		if (ec.category() == libtorrent_category())
 		{
 #define TORRENT_MAP(error, close_reason) \
 	case errors:: error : \
@@ -157,7 +157,7 @@ namespace libtorrent
 					return close_no_memory;
 			}
 		}
-		else if (ec.category() == get_http_category())
+		else if (ec.category() == http_category())
 		{
 			return close_no_memory;
 		}

src/create_torrent.cpp

@@ -252,13 +252,13 @@ namespace libtorrent
 
 		if (t.files().num_files() == 0)
 		{
-			ec = error_code(errors::no_files_in_torrent, get_libtorrent_category());
+			ec = errors::no_files_in_torrent;
 			return;
 		}
 
 		if (t.files().total_size() == 0)
 		{
-			ec = error_code(errors::torrent_invalid_length, get_libtorrent_category());
+			ec = errors::torrent_invalid_length;
 			return;
 		}
 

src/disk_io_thread.cpp

@@ -137,27 +137,16 @@ namespace libtorrent
 	disk_io_thread::disk_io_thread(io_service& ios
 		, counters& cnt
 		, void* userdata
-		, int block_size)
+		, int const block_size)
-		: m_abort(false)
+		: m_generic_io_jobs(*this, generic_thread)
-		, m_num_running_threads(0)
-		, m_generic_io_jobs(*this, generic_thread)
 		, m_generic_threads(m_generic_io_jobs, ios)
 		, m_hash_io_jobs(*this, hasher_thread)
 		, m_hash_threads(m_hash_io_jobs, ios)
 		, m_userdata(userdata)
-		, m_last_cache_expiry(min_time())
 		, m_last_file_check(clock_type::now())
-		, m_file_pool(40)
 		, m_disk_cache(block_size, ios, std::bind(&disk_io_thread::trigger_cache_trim, this))
-		, m_cache_check_state(cache_check_idle)
 		, m_stats_counters(cnt)
 		, m_ios(ios)
-		, m_last_disk_aio_performance_warning(min_time())
-		, m_outstanding_reclaim_message(false)
-#if TORRENT_USE_ASSERTS
-		, m_magic(0x1337)
-		, m_jobs_aborted(false)
-#endif
 	{
 		ADD_OUTSTANDING_ASYNC("disk_io_thread::work");
 		error_code ec;
@@ -168,8 +157,8 @@ namespace libtorrent
 		// futexes, shared objects etc.
 		// 80% of the available file descriptors should go to connections
 		// 20% goes towards regular files
-		const int max_files = (std::min)((std::max)(5
+		const int max_files = std::min(std::max(5
-				, (max_open_files() - 20) * 2 / 10)
+			, (max_open_files() - 20) * 2 / 10)
 			, m_file_pool.size_limit());
 		m_file_pool.resize(max_files);
 	}

src/entry.cpp

@@ -74,8 +74,7 @@ namespace libtorrent
 		TORRENT_NO_RETURN inline void throw_error()
 		{
 #ifndef BOOST_NO_EXCEPTIONS
-			throw system_error(error_code(errors::invalid_entry_type
+			throw system_error(errors::invalid_entry_type);
-					, get_libtorrent_category()));
 #else
 			std::terminate();
 #endif

src/error_code.cpp

@@ -270,7 +270,7 @@ namespace libtorrent
 		return msgs[ev];
 	}
 
-	boost::system::error_category& get_libtorrent_category()
+	boost::system::error_category& libtorrent_category()
 	{
 		static libtorrent_error_category libtorrent_category;
 		return libtorrent_category;
@@ -313,7 +313,7 @@ namespace libtorrent
 		{ return boost::system::error_condition(ev, *this); }
 	};
 
-	boost::system::error_category& get_http_category()
+	boost::system::error_category& http_category()
 	{
 		static http_error_category http_category;
 		return http_category;
@@ -324,7 +324,7 @@ namespace libtorrent
 		// hidden
 		boost::system::error_code make_error_code(error_code_enum e)
 		{
-			return boost::system::error_code(e, get_libtorrent_category());
+			return boost::system::error_code(e, libtorrent_category());
 		}
 	}
 

src/file.cpp

@@ -532,7 +532,7 @@ namespace libtorrent
 		// something failed. Does the filesystem not support hard links?
 		// TODO: 3 find out what error code is reported when the filesystem
 		// does not support hard links.
-		DWORD error = GetLastError();
+		DWORD const error = GetLastError();
 		if (error != ERROR_NOT_SUPPORTED && error != ERROR_ACCESS_DENIED)
 		{
 			// it's possible CreateHardLink will copy the file internally too,

src/gzip.cpp

@@ -95,17 +95,17 @@ namespace libtorrent
 		return msgs[ev];
 	}
 
-	boost::system::error_category& get_gzip_category()
+	boost::system::error_category& gzip_category()
 	{
-		static gzip_error_category gzip_category;
+		static gzip_error_category category;
-		return gzip_category;
+		return category;
 	}
 
 	namespace gzip_errors
 	{
 		boost::system::error_code make_error_code(error_code_enum e)
 		{
-			return boost::system::error_code(e, get_gzip_category());
+			return boost::system::error_code(e, gzip_category());
 		}
 	}
 

src/http_connection.cpp

@@ -298,7 +298,7 @@ void http_connection::start(std::string const& hostname, int port
 		if (is_i2p && i2p_conn->proxy().type != settings_pack::i2p_proxy)
 		{
 			m_timer.get_io_service().post(std::bind(&http_connection::callback
-				, me, error_code(errors::no_i2p_router, get_libtorrent_category()), static_cast<char*>(nullptr), 0));
+				, me, error_code(errors::no_i2p_router), static_cast<char*>(nullptr), 0));
 			return;
 		}
 #endif

src/http_seed_connection.cpp

@@ -279,7 +279,7 @@ namespace libtorrent
 							, error_msg);
 					}
 					received_bytes(0, int(bytes_transferred));
-					disconnect(error_code(m_parser.status_code(), get_http_category()), op_bittorrent, 1);
+					disconnect(error_code(m_parser.status_code(), http_category()), op_bittorrent, 1);
 					return;
 				}
 				if (!m_parser.header_finished())
@@ -414,7 +414,7 @@ namespace libtorrent
 				received_bytes(0, int(bytes_transferred));
 				// temporarily unavailable, retry later
 				t->retry_web_seed(this, retry_time);
-				disconnect(error_code(m_parser.status_code(), get_http_category()), op_bittorrent, 1);
+				disconnect(error_code(m_parser.status_code(), http_category()), op_bittorrent, 1);
 				return;
 			}
 

src/http_tracker_connection.cpp

@@ -85,7 +85,7 @@ namespace libtorrent
 			std::size_t pos = url.find("announce");
 			if (pos == std::string::npos)
 			{
-				tracker_connection::fail(error_code(errors::scrape_not_available));
+				tracker_connection::fail(errors::scrape_not_available);
 				return;
 			}
 			url.replace(pos, 8, "scrape");
@@ -162,7 +162,7 @@ namespace libtorrent
 			{
 				if (tracker_req().i2pconn->local_endpoint().empty())
 				{
-					fail(error_code(errors::no_i2p_endpoint), -1, "Waiting for i2p acceptor from SAM bridge", 5);
+					fail(errors::no_i2p_endpoint, -1, "Waiting for i2p acceptor from SAM bridge", 5);
 					return;
 				}
 				else
@@ -281,7 +281,7 @@ namespace libtorrent
 		}
 #endif
 		if (endpoints.empty())
-			fail(error_code(errors::banned_by_ip_filter));
+			fail(errors::banned_by_ip_filter);
 	}
 
 	void http_tracker_connection::on_connect(http_connection& c)
@@ -312,7 +312,7 @@ namespace libtorrent
 
 		if (parser.status_code() != 200)
 		{
-			fail(error_code(parser.status_code(), get_http_category())
+			fail(error_code(parser.status_code(), http_category())
 				, parser.status_code(), parser.message().c_str());
 			return;
 		}
@@ -378,7 +378,7 @@ namespace libtorrent
 		// extract peer id (if any)
 		if (info.type() != bdecode_node::dict_t)
 		{
-			ec.assign(errors::invalid_peer_dict, get_libtorrent_category());
+			ec = errors::invalid_peer_dict;
 			return false;
 		}
 		bdecode_node i = info.dict_find_string("peer id");
@@ -396,7 +396,7 @@ namespace libtorrent
 		i = info.dict_find_string("ip");
 		if (i == 0)
 		{
-			ec.assign(errors::invalid_tracker_response, get_libtorrent_category());
+			ec = errors::invalid_tracker_response;
 			return false;
 		}
 		ret.hostname = i.string_value().to_string();
@@ -405,7 +405,7 @@ namespace libtorrent
 		i = info.dict_find_int("port");
 		if (i == 0)
 		{
-			ec.assign(errors::invalid_tracker_response, get_libtorrent_category());
+			ec = errors::invalid_tracker_response;
 			return false;
 		}
 		ret.port = std::uint16_t(i.int_value());
@@ -425,7 +425,7 @@ namespace libtorrent
 
 		if (res != 0 || e.type() != bdecode_node::dict_t)
 		{
-			ec.assign(errors::invalid_tracker_response, get_libtorrent_category());
+			ec = errors::invalid_tracker_response;
 			return resp;
 		}
 
@@ -446,7 +446,7 @@ namespace libtorrent
 		if (failure)
 		{
 			resp.failure_reason = failure.string_value().to_string();
-			ec.assign(errors::tracker_failure, get_libtorrent_category());
+			ec = errors::tracker_failure;
 			return resp;
 		}
 
@@ -459,7 +459,7 @@ namespace libtorrent
 			bdecode_node files = e.dict_find_dict("files");
 			if (!files)
 			{
-				ec.assign(errors::invalid_files_entry, get_libtorrent_category());
+				ec = errors::invalid_files_entry;
 				return resp;
 			}
 
@@ -468,7 +468,7 @@ namespace libtorrent
 
 			if (!scrape_data)
 			{
-				ec.assign(errors::invalid_hash_entry, get_libtorrent_category());
+				ec = errors::invalid_hash_entry;
 				return resp;
 			}
 
@@ -573,7 +573,7 @@ namespace libtorrent
 		if (peers_ent == 0 && ipv6_peers == 0
 			&& tracker_req().event != tracker_request::stopped)
 		{
-			ec.assign(errors::invalid_peers_entry, get_libtorrent_category());
+			ec = errors::invalid_peers_entry;
 			return resp;
 		}
 */

src/i2p_stream.cpp

@@ -78,7 +78,7 @@ namespace libtorrent
 	};
 
 
-	boost::system::error_category& get_i2p_category()
+	boost::system::error_category& i2p_category()
 	{
 		static i2p_error_category i2p_category;
 		return i2p_category;
@@ -88,7 +88,7 @@ namespace libtorrent
 	{
 		boost::system::error_code make_error_code(i2p_error_code e)
 		{
-			return error_code(e, get_i2p_category());
+			return error_code(e, i2p_category());
 		}
 	}
 
@@ -307,7 +307,7 @@ namespace libtorrent
 		}
 
 		error_code invalid_response(i2p_error::parse_failed
-			, get_i2p_category());
+			, i2p_category());
 
 		// 0-terminate the string and parse it
 		m_buffer.push_back(0);
@@ -391,7 +391,7 @@ namespace libtorrent
 			}
 		}
 
-		error_code ec(result, get_i2p_category());
+		error_code ec(result, i2p_category());
 		switch (result)
 		{
 			case i2p_error::no_error:

src/natpmp.cpp

@@ -563,7 +563,8 @@ void natpmp::on_reply(error_code const& e
 
 	if (result != 0)
 	{
-		int errors[] =
+		// TODO: 3 it would be nice to have a separate NAT-PMP error category
+		errors::error_code_enum errors[] =
 		{
 			errors::unsupported_protocol_version,
 			errors::natpmp_not_authorized,
@@ -571,21 +572,19 @@ void natpmp::on_reply(error_code const& e
 			errors::no_resources,
 			errors::unsupported_opcode,
 		};
-		int ev = errors::no_error;
+		errors::error_code_enum ev = errors::no_error;
 		if (result >= 1 && result <= 5) ev = errors[result - 1];
 
 		m->expires = aux::time_now() + hours(2);
 		portmap_protocol const proto = m->protocol;
 		m_callback.on_port_mapping(index, address(), 0, proto
-			, error_code(ev, get_libtorrent_category())
+			, ev, aux::portmap_transport::natpmp);
-			, aux::portmap_transport::natpmp);
 	}
 	else if (m->act == mapping_t::action::add)
 	{
 		portmap_protocol const proto = m->protocol;
 		m_callback.on_port_mapping(index, m_external_ip, m->external_port, proto
-			, error_code(errors::no_error, get_libtorrent_category())
+			, errors::no_error, aux::portmap_transport::natpmp);
-			, aux::portmap_transport::natpmp);
 	}
 
 	if (m_abort) return;

src/peer_connection.cpp

@@ -2124,7 +2124,7 @@ namespace libtorrent
 		if (t->share_mode()) return false;
 
 		if (m_upload_only && t->is_upload_only()
-			&& can_disconnect(error_code(errors::upload_upload_connection, get_libtorrent_category())))
+			&& can_disconnect(errors::upload_upload_connection))
 		{
 #ifndef TORRENT_DISABLE_LOGGING
 			peer_log(peer_log_alert::info, "UPLOAD_ONLY", "the peer is upload-only and our torrent is also upload-only");
@@ -2137,7 +2137,7 @@ namespace libtorrent
 			&& !m_interesting
 			&& m_bitfield_received
 			&& t->are_files_checked()
-			&& can_disconnect(error_code(errors::uninteresting_upload_peer, get_libtorrent_category())))
+			&& can_disconnect(errors::uninteresting_upload_peer))
 		{
 #ifndef TORRENT_DISABLE_LOGGING
 			peer_log(peer_log_alert::info, "UPLOAD_ONLY", "the peer is upload-only and we're not interested in it");
@@ -2352,8 +2352,7 @@ namespace libtorrent
 				// may be a legitimate number of requests to have in flight when
 				// getting choked
 				if (m_num_invalid_requests > 300 && !m_peer_choked
-					&& can_disconnect(error_code(errors::too_many_requests_when_choked
+					&& can_disconnect(errors::too_many_requests_when_choked))
-						, get_libtorrent_category())))
 				{
 					disconnect(errors::too_many_requests_when_choked, op_bittorrent, 2);
 					return;
@@ -2375,7 +2374,7 @@ namespace libtorrent
 		// disconnect peers that downloads more than foo times an allowed
 		// fast piece
 		if (m_choked && fast_idx != -1 && m_accept_fast_piece_cnt[fast_idx] >= 3 * blocks_per_piece
-			&& can_disconnect(error_code(errors::too_many_requests_when_choked, get_libtorrent_category())))
+			&& can_disconnect(errors::too_many_requests_when_choked))
 		{
 			disconnect(errors::too_many_requests_when_choked, op_bittorrent, 2);
 			return;
@@ -2394,7 +2393,7 @@ namespace libtorrent
 			// allow peers to send request up to 2 seconds after getting choked,
 			// then disconnect them
 			if (aux::time_now() - seconds(2) > m_last_choke
-				&& can_disconnect(error_code(errors::too_many_requests_when_choked, get_libtorrent_category())))
+				&& can_disconnect(errors::too_many_requests_when_choked))
 			{
 				disconnect(errors::too_many_requests_when_choked, op_bittorrent, 2);
 				return;
@@ -4079,8 +4078,7 @@ namespace libtorrent
 				break;
 			}
 
-			if (ec == error_code(boost::asio::error::eof
+			if (ec == boost::asio::error::eof
-				, boost::asio::error::get_misc_category())
 				&& !in_handshake()
 				&& !is_connecting()
 				&& aux::time_now() - connected_time() < seconds(15))
@@ -4144,29 +4142,29 @@ namespace libtorrent
 			m_counters.inc_stats_counter(counters::invalid_arg_peers);
 		else if (ec == error::operation_aborted)
 			m_counters.inc_stats_counter(counters::aborted_peers);
-		else if (ec == error_code(errors::upload_upload_connection)
+		else if (ec == errors::upload_upload_connection
-			|| ec == error_code(errors::uninteresting_upload_peer)
+			|| ec == errors::uninteresting_upload_peer
-			|| ec == error_code(errors::torrent_aborted)
+			|| ec == errors::torrent_aborted
-			|| ec == error_code(errors::self_connection)
+			|| ec == errors::self_connection
-			|| ec == error_code(errors::torrent_paused))
+			|| ec == errors::torrent_paused)
 			m_counters.inc_stats_counter(counters::uninteresting_peers);
 
-		if (ec == error_code(errors::timed_out)
+		if (ec == errors::timed_out
 			|| ec == error::timed_out)
 			m_counters.inc_stats_counter(counters::transport_timeout_peers);
 
-		if (ec == error_code(errors::timed_out_inactivity)
+		if (ec == errors::timed_out_inactivity
-			|| ec == error_code(errors::timed_out_no_request)
+			|| ec == errors::timed_out_no_request
-			|| ec == error_code(errors::timed_out_no_interest))
+			|| ec == errors::timed_out_no_interest)
 			m_counters.inc_stats_counter(counters::timeout_peers);
 
-		if (ec == error_code(errors::no_memory))
+		if (ec == errors::no_memory)
 			m_counters.inc_stats_counter(counters::no_memory_peers);
 
-		if (ec == error_code(errors::too_many_connections))
+		if (ec == errors::too_many_connections)
 			m_counters.inc_stats_counter(counters::too_many_peers);
 
-		if (ec == error_code(errors::timed_out_no_handshake))
+		if (ec == errors::timed_out_no_handshake)
 			m_counters.inc_stats_counter(counters::connect_timeouts);
 
 		if (error > 0)
@@ -4235,7 +4233,7 @@ namespace libtorrent
 		{
 			if (ec)
 			{
-				if ((error > 1 || ec.category() == get_socks_category())
+				if ((error > 1 || ec.category() == socks_category())
 					&& t->alerts().should_post<peer_error_alert>())
 				{
 					t->alerts().emplace_alert<peer_error_alert>(handle, remote()
@@ -4715,7 +4713,7 @@ namespace libtorrent
 #endif
 
 			if (d > seconds(connect_timeout)
-				&& can_disconnect(error_code(errors::timed_out, get_libtorrent_category())))
+				&& can_disconnect(errors::timed_out))
 			{
 #ifndef TORRENT_DISABLE_LOGGING
 				peer_log(peer_log_alert::info, "CONNECT_FAILED", "waited %d seconds"
@@ -4736,7 +4734,7 @@ namespace libtorrent
 		// because of less work in second_tick(), and might let use remove ticking
 		// entirely eventually
 		if (may_timeout && d > seconds(timeout()) && !m_connecting && m_reading_bytes == 0
-			&& can_disconnect(error_code(errors::timed_out_inactivity, get_libtorrent_category())))
+			&& can_disconnect(errors::timed_out_inactivity))
 		{
 #ifndef TORRENT_DISABLE_LOGGING
 			peer_log(peer_log_alert::info, "LAST_ACTIVITY", "%d seconds ago"
@@ -4779,7 +4777,7 @@ namespace libtorrent
 			&& m_peer_interested
 			&& t && t->is_upload_only()
 			&& d > seconds(60)
-			&& can_disconnect(error_code(errors::timed_out_no_request, get_libtorrent_category())))
+			&& can_disconnect(errors::timed_out_no_request))
 		{
 #ifndef TORRENT_DISABLE_LOGGING
 			peer_log(peer_log_alert::info, "NO_REQUEST", "waited %d seconds"
@@ -4809,7 +4807,7 @@ namespace libtorrent
 			&& d2 > time_limit
 			&& (m_ses.num_connections() >= m_settings.get_int(settings_pack::connections_limit)
 				|| (t && t->num_peers() >= t->max_connections()))
-			&& can_disconnect(error_code(errors::timed_out_no_interest)))
+			&& can_disconnect(errors::timed_out_no_interest))
 		{
 #ifndef TORRENT_DISABLE_LOGGING
 			if (should_log(peer_log_alert::info))
@@ -6402,12 +6400,12 @@ namespace libtorrent
 			&& !t->share_mode())
 		{
 			bool const ok_to_disconnect =
-				can_disconnect(error_code(errors::upload_upload_connection))
+				can_disconnect(errors::upload_upload_connection)
-					|| can_disconnect(error_code(errors::uninteresting_upload_peer))
+					|| can_disconnect(errors::uninteresting_upload_peer)
-					|| can_disconnect(error_code(errors::too_many_requests_when_choked))
+					|| can_disconnect(errors::too_many_requests_when_choked)
-					|| can_disconnect(error_code(errors::timed_out_no_interest))
+					|| can_disconnect(errors::timed_out_no_interest)
-					|| can_disconnect(error_code(errors::timed_out_no_request))
+					|| can_disconnect(errors::timed_out_no_request)
-					|| can_disconnect(error_code(errors::timed_out_inactivity));
+					|| can_disconnect(errors::timed_out_inactivity);
 
 			// make sure upload only peers are disconnected
 			if (t->is_upload_only()

src/read_resume_data.cpp

@@ -72,14 +72,14 @@ namespace libtorrent
 		if (rd.dict_find_string_value("file-format")
 			!= "libtorrent resume file")
 		{
-			ec = error_code(errors::invalid_file_tag, get_libtorrent_category());
+			ec = errors::invalid_file_tag;
 			return ret;
 		}
 
 		auto info_hash = rd.dict_find_string_value("info-hash");
 		if (info_hash.size() != 20)
 		{
-			ec = error_code(errors::missing_info_hash, get_libtorrent_category());
+			ec = errors::missing_info_hash;
 			return ret;
 		}
 

src/session_impl.cpp

@@ -2821,7 +2821,7 @@ namespace aux {
 			{
 				m_alerts.emplace_alert<peer_disconnected_alert>(torrent_handle(), endp, peer_id()
 						, op_bittorrent, s->type()
-						, error_code(errors::too_many_connections, get_libtorrent_category())
+						, error_code(errors::too_many_connections)
 						, close_no_reason);
 			}
 #ifndef TORRENT_DISABLE_LOGGING
@@ -3419,7 +3419,7 @@ namespace aux {
 						int(i->second->num_peers() * m_settings.get_int(settings_pack::peer_turnover) / 100), 1)
 						, i->second->num_connect_candidates());
 					i->second->disconnect_peers(peers_to_disconnect
-						, error_code(errors::optimistic_disconnect, get_libtorrent_category()));
+						, error_code(errors::optimistic_disconnect));
 				}
 				else
 				{
@@ -3441,7 +3441,7 @@ namespace aux {
 							* m_settings.get_int(settings_pack::peer_turnover) / 100), 1)
 							, t->num_connect_candidates());
 						t->disconnect_peers(peers_to_disconnect
-							, error_code(errors::optimistic_disconnect, get_libtorrent_category()));
+							, error_code(errors::optimistic_disconnect));
 					}
 				}
 			}
@@ -6402,7 +6402,7 @@ namespace aux {
 				int const disconnect = std::min(to_disconnect, num - my_average);
 				to_disconnect -= disconnect;
 				t.second->disconnect_peers(disconnect
-					, error_code(errors::too_many_connections, get_libtorrent_category()));
+					, error_code(errors::too_many_connections));
 			}
 		}
 	}

src/socks5_stream.cpp

@@ -42,7 +42,7 @@ namespace libtorrent
 	{
 		boost::system::error_code make_error_code(socks_error_code e)
 		{
-			return error_code(e, get_socks_category());
+			return error_code(e, socks_category());
 		}
 	}
 
@@ -74,10 +74,10 @@ namespace libtorrent
 		{ return boost::system::error_condition(ev, *this); }
 	};
 
-	TORRENT_EXPORT boost::system::error_category& get_socks_category()
+	TORRENT_EXPORT boost::system::error_category& socks_category()
 	{
-		static socks_error_category socks_category;
+		static socks_error_category cat;
-		return socks_category;
+		return cat;
 	}
 
 	namespace
@@ -386,7 +386,7 @@ namespace libtorrent
 			}
 			if (response != 0)
 			{
-				error_code ec(socks_error::general_failure, get_socks_category());
+				error_code ec(socks_error::general_failure);
 				switch (response)
 				{
 					case 2: ec = boost::asio::error::no_permission; break;
@@ -483,7 +483,7 @@ namespace libtorrent
 				return;
 			}
 
-			error_code ec(socks_error::general_failure, get_socks_category());
+			error_code ec(socks_error::general_failure);
 			switch (response)
 			{
 				case 91: ec = boost::asio::error::connection_refused; break;

src/torrent.cpp

@@ -421,7 +421,7 @@ namespace libtorrent
 
 		if (parser.status_code() != 200)
 		{
-			set_error(error_code(parser.status_code(), get_http_category()), torrent_status::error_file_url);
+			set_error(error_code(parser.status_code(), http_category()), torrent_status::error_file_url);
 			pause();
 			return;
 		}
@@ -468,7 +468,7 @@ namespace libtorrent
 			// TODO: if the existing torrent doesn't have metadata, insert
 			// the metadata we just downloaded into it.
 
-			set_error(error_code(errors::duplicate_torrent, get_libtorrent_category()), torrent_status::error_file_url);
+			set_error(errors::duplicate_torrent, torrent_status::error_file_url);
 			abort();
 			return;
 		}
@@ -5638,7 +5638,7 @@ namespace libtorrent
 		{
 			if (alerts().should_post<torrent_error_alert>())
 				alerts().emplace_alert<torrent_error_alert>(get_handle()
-					, error_code(errors::not_an_ssl_torrent), "");
+					, errors::not_an_ssl_torrent, "");
 			return;
 		}
 
@@ -5884,7 +5884,7 @@ namespace libtorrent
 			if (m_ses.alerts().should_post<url_seed_alert>())
 			{
 				m_ses.alerts().emplace_alert<url_seed_alert>(get_handle(), web->url
-					, error_code(libtorrent::errors::peer_banned, get_libtorrent_category()));
+					, libtorrent::errors::peer_banned);
 			}
 			// never try it again
 			remove_web_seed_iter(web);
@@ -6836,8 +6836,7 @@ namespace libtorrent
 				// we have an i2p torrent, but we're not connected to an i2p
 				// SAM proxy.
 				if (alerts().should_post<i2p_alert>())
-					alerts().emplace_alert<i2p_alert>(error_code(errors::no_i2p_router
+					alerts().emplace_alert<i2p_alert>(errors::no_i2p_router);
-						, get_libtorrent_category()));
 				return false;
 			}
 
@@ -7003,7 +7002,7 @@ namespace libtorrent
 			if (alerts().should_post<metadata_failed_alert>())
 			{
 				alerts().emplace_alert<metadata_failed_alert>(get_handle()
-					, error_code(errors::mismatching_info_hash, get_libtorrent_category()));
+					, errors::mismatching_info_hash);
 			}
 			return false;
 		}
@@ -7989,8 +7988,7 @@ namespace libtorrent
 		{
 			if (alerts().should_post<file_rename_failed_alert>())
 				alerts().emplace_alert<file_rename_failed_alert>(get_handle()
-					, index, error_code(errors::session_is_closing
+					, index, errors::session_is_closing);
-						, get_libtorrent_category()));
 			return;
 		}
 
@@ -8414,7 +8412,7 @@ namespace libtorrent
 		if (num_peers() > int(m_max_connections))
 		{
 			disconnect_peers(num_peers() - m_max_connections
-				, error_code(errors::too_many_connections, get_libtorrent_category()));
+				, errors::too_many_connections);
 		}
 
 		if (state_update)

src/upnp.cpp

@@ -62,7 +62,7 @@ namespace upnp_errors
 {
 	boost::system::error_code make_error_code(error_code_enum e)
 	{
-		return error_code(e, get_upnp_category());
+		return error_code(e, upnp_category());
 	}
 
 } // upnp_errors namespace
@@ -1221,7 +1221,7 @@ struct upnp_error_category : boost::system::error_category
 	}
 };
 
-boost::system::error_category& get_upnp_category()
+boost::system::error_category& upnp_category()
 {
 	static upnp_error_category cat;
 	return cat;
@@ -1493,7 +1493,7 @@ void upnp::return_error(int mapping, int code)
 		error_string += e->msg;
 	}
 	portmap_protocol const proto = m_mappings[mapping].protocol;
-	m_callback.on_port_mapping(mapping, address(), 0, proto, error_code(code, get_upnp_category())
+	m_callback.on_port_mapping(mapping, address(), 0, proto, error_code(code, upnp_category())
 		, aux::portmap_transport::upnp);
 }
 
@@ -1558,8 +1558,8 @@ void upnp::on_upnp_unmap_response(error_code const& e
 	portmap_protocol const proto = m_mappings[mapping].protocol;
 
 	m_callback.on_port_mapping(mapping, address(), 0, proto, p.status_code() != 200
-		? error_code(p.status_code(), get_http_category())
+		? error_code(p.status_code(), http_category())
-		: error_code(s.error_code, get_upnp_category())
+		: error_code(s.error_code, upnp_category())
 		, aux::portmap_transport::upnp);
 
 	d.mapping[mapping].protocol = portmap_protocol::none;

src/web_peer_connection.cpp

@@ -557,7 +557,7 @@ void web_peer_connection::handle_error(int bytes_left)
 			, error_msg);
 	}
 	received_bytes(0, bytes_left);
-	disconnect(error_code(m_parser.status_code(), get_http_category()), op_bittorrent, 1);
+	disconnect(error_code(m_parser.status_code(), http_category()), op_bittorrent, 1);
 	return;
 }
 

test/test_primitives.cpp

@@ -83,8 +83,8 @@ TORRENT_TEST(primitives)
 	TEST_CHECK(error_code(errors::http_parse_error).message() == "Invalid HTTP header");
 	TEST_CHECK(error_code(errors::error_code_max).message() == "Unknown error");
 
-	TEST_CHECK(error_code(errors::unauthorized, get_http_category()).message() == "401 Unauthorized");
+	TEST_CHECK(error_code(errors::unauthorized, http_category()).message() == "401 Unauthorized");
-	TEST_CHECK(error_code(errors::service_unavailable, get_http_category()).message() == "503 Service Unavailable");
+	TEST_CHECK(error_code(errors::service_unavailable, http_category()).message() == "503 Service Unavailable");
 
 	// test snprintf
 
@@ -128,11 +128,11 @@ TORRENT_TEST(primitives)
 #if TORRENT_USE_IPV6
 	TEST_EQUAL(print_address(v6("2001:ff::1")), "2001:ff::1");
 	parse_endpoint("[ff::1]", ec);
-	TEST_EQUAL(ec, error_code(errors::invalid_port, get_libtorrent_category()));
+	TEST_EQUAL(ec, error_code(errors::invalid_port));
 #endif
 
 	parse_endpoint("[ff::1:5", ec);
-	TEST_EQUAL(ec, error_code(errors::expected_close_bracket_in_address, get_libtorrent_category()));
+	TEST_EQUAL(ec, error_code(errors::expected_close_bracket_in_address));
 
 	// test address_to_bytes
 	TEST_EQUAL(address_to_bytes(address_v4::from_string("10.11.12.13")), "\x0a\x0b\x0c\x0d");
@@ -166,3 +166,14 @@ TORRENT_TEST(printf_trunc)
 	std::snprintf(buffer, sizeof(buffer), "%d %s", val, "end");
 	TEST_EQUAL(buffer, std::string("184"))
 }
+
+TORRENT_TEST(error_condition)
+{
+#ifdef TORRENT_WINDOWS
+	error_code ec(ERROR_FILE_NOT_FOUND, system_category());
+#else
+	error_code ec(ENOENT, system_category());
+#endif
+	TEST_CHECK(ec == boost::system::errc::no_such_file_or_directory);
+}
+

test/test_read_resume.cpp

@@ -124,7 +124,7 @@ TORRENT_TEST(read_resume_missing_info_hash)
 
 	error_code ec;
 	add_torrent_params atp = read_resume_data(&resume_data[0], int(resume_data.size()), ec);
-	TEST_EQUAL(ec, error_code(errors::missing_info_hash, get_libtorrent_category()));
+	TEST_EQUAL(ec, error_code(errors::missing_info_hash));
 }
 
 TORRENT_TEST(read_resume_missing_file_format)
@@ -140,7 +140,7 @@ TORRENT_TEST(read_resume_missing_file_format)
 
 	error_code ec;
 	add_torrent_params atp = read_resume_data(&resume_data[0], int(resume_data.size()), ec);
-	TEST_EQUAL(ec, error_code(errors::invalid_file_tag, get_libtorrent_category()));
+	TEST_EQUAL(ec, error_code(errors::invalid_file_tag));
 }
 
 TORRENT_TEST(read_resume_mismatching_torrent)

test/test_tracker.cpp

@@ -201,7 +201,7 @@ TORRENT_TEST(parse_failure_reason)
 	tracker_response resp = parse_tracker_response(response, sizeof(response) - 1
 		, ec, false, sha1_hash());
 
-	TEST_EQUAL(ec, error_code(errors::tracker_failure));
+	TEST_EQUAL(ec, errors::tracker_failure);
 	TEST_EQUAL(resp.peers.size(), 0);
 	TEST_EQUAL(resp.failure_reason, "test message");
 }
@@ -296,21 +296,21 @@ TORRENT_TEST(extract_peer_not_a_dictionary)
 {
 	// not a dictionary
 	peer_entry result = extract_peer("2:ip11:example.com"
-		, error_code(errors::invalid_peer_dict, get_libtorrent_category()), false);
+		, errors::invalid_peer_dict, false);
 }
 
 TORRENT_TEST(extract_peer_missing_ip)
 {
 	// missing IP
 	peer_entry result = extract_peer("d7:peer id20:abababababababababab4:porti1337ee"
-		, error_code(errors::invalid_tracker_response, get_libtorrent_category()), false);
+		, errors::invalid_tracker_response, false);
 }
 
 TORRENT_TEST(extract_peer_missing_port)
 {
 	// missing port
 	peer_entry result = extract_peer("d7:peer id20:abababababababababab2:ip4:abcde"
-		, error_code(errors::invalid_tracker_response, get_libtorrent_category()), false);
+		, errors::invalid_tracker_response, false);
 }
 
 TORRENT_TEST(udp_tracker)