fix build against boost-1.69

bindings/python/Jamfile

@@ -12,8 +12,8 @@ BOOST_ROOT = [ modules.peek : BOOST_ROOT ] ;
 # this is used to make bjam use the same version of python which is executing setup.py
 LIBTORRENT_PYTHON_INTERPRETER = [ modules.peek : LIBTORRENT_PYTHON_INTERPRETER ] ;
 
-feature visibility : default hidden : composite ;
-feature.compose <visibility>hidden : <cflags>-fvisibility=hidden <cxxflags>-fvisibility-inlines-hidden ;
+feature lt-visibility : default hidden : composite ;
+feature.compose <lt-visibility>hidden : <cflags>-fvisibility=hidden <cxxflags>-fvisibility-inlines-hidden ;
 
 feature libtorrent-link : shared static : composite propagated ;
 feature libtorrent-python-pic : off on : composite propagated link-incompatible ;
@@ -100,7 +100,7 @@ rule libtorrent_linking ( properties * )
       || <toolset>clang in $(properties)
       || <toolset>clang-darwin in $(properties)
     {
-        result += <visibility>hidden ;
+        result += <lt-visibility>hidden ;
 
         if ( <toolset>gcc in $(properties) )
         {

bindings/python/src/error_code.cpp

@@ -112,11 +112,58 @@ namespace {
 	};
 }
 
+struct category_holder
+{
+	category_holder(boost::system::error_category const& cat) : m_cat(&cat) {}
+	char const* name() const { return m_cat->name(); }
+	std::string message(int const v) const { return m_cat->message(v); }
+
+	friend bool operator==(category_holder const lhs, category_holder const rhs)
+	{ return *lhs.m_cat == *rhs.m_cat; }
+
+	friend bool operator!=(category_holder const lhs, category_holder const rhs)
+	{ return *lhs.m_cat != *rhs.m_cat; }
+
+	friend bool operator<(category_holder const lhs, category_holder const rhs)
+	{ return *lhs.m_cat < *rhs.m_cat; }
+
+	boost::system::error_category const& ref() const { return *m_cat; }
+	operator boost::system::error_category const&() const { return *m_cat; }
+private:
+	boost::system::error_category const* m_cat;
+};
+
+void error_code_assign(boost::system::error_code& self, int const v, category_holder const cat)
+{
+	self.assign(v, cat.ref());
+}
+
+category_holder error_code_category(boost::system::error_code const& self)
+{
+	return category_holder(self.category());
+}
+
+#define WRAP_CAT(name) \
+	category_holder wrap_ ##name## _category() { return category_holder(name## _category()); }
+
+WRAP_CAT(libtorrent)
+WRAP_CAT(upnp)
+WRAP_CAT(http)
+WRAP_CAT(socks)
+WRAP_CAT(bdecode)
+#if TORRENT_USE_I2P
+WRAP_CAT(i2p)
+#endif
+WRAP_CAT(generic)
+WRAP_CAT(system)
+
+#undef WRAP_CAT
+
 void bind_error_code()
 {
-    class_<boost::system::error_category, boost::noncopyable>("error_category", no_init)
-        .def("name", &error_category::name)
-        .def("message", &error_category::message)
+    class_<category_holder>("error_category", no_init)
+        .def("name", &category_holder::name)
+        .def("message", &category_holder::message)
         .def(self == self)
         .def(self < self)
         .def(self != self)
@@ -124,39 +171,37 @@ void bind_error_code()
 
     class_<error_code>("error_code")
         .def(init<>())
-        .def("message", &error_code::message)
+        .def(init<int, category_holder>())
+        .def("message", static_cast<std::string (error_code::*)() const>(&error_code::message))
         .def("value", &error_code::value)
         .def("clear", &error_code::clear)
-        .def("category", &error_code::category
-           , return_internal_reference<>())
-        .def("assign", &error_code::assign)
+        .def("category", &error_code_category)
+        .def("assign", &error_code_assign)
         .def_pickle(ec_pickle_suite())
         ;
 
-typedef return_value_policy<reference_existing_object> return_existing;
-
-    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());
+    def("libtorrent_category", &wrap_libtorrent_category);
+    def("upnp_category", &wrap_upnp_category);
+    def("http_category", &wrap_http_category);
+    def("socks_category", &wrap_socks_category);
+    def("bdecode_category", &wrap_bdecode_category);
 #if TORRENT_USE_I2P
-    def("i2p_category", &i2p_category, return_existing());
+    def("i2p_category", &wrap_i2p_category);
 #endif
 
 #ifndef TORRENT_NO_DEPRECATE
-    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());
+    def("get_libtorrent_category", &wrap_libtorrent_category);
+    def("get_upnp_category", &wrap_upnp_category);
+    def("get_http_category", &wrap_http_category);
+    def("get_socks_category", &wrap_socks_category);
+    def("get_bdecode_category", &wrap_bdecode_category);
 #if TORRENT_USE_I2P
-    def("get_i2p_category", &i2p_category, return_existing());
+    def("get_i2p_category", &wrap_i2p_category);
 #endif
 #endif // TORRENT_NO_DEPRECATE
 
-    def("generic_category", &boost::system::generic_category, return_existing());
+    def("generic_category", &wrap_generic_category);
 
-    def("system_category", &boost::system::system_category, return_existing());
+    def("system_category", &wrap_system_category);
 }
 

bindings/python/test.py

@@ -466,6 +466,22 @@ class test_session(unittest.TestCase):
 		default = lt.default_settings()
 		print(default)
 
+class test_error_code(unittest.TestCase):
+
+	def test_error_code(self):
+
+		a = lt.error_code();
+		a = lt.error_code(10, lt.libtorrent_category())
+		self.assertEqual(a.category().name(), 'libtorrent')
+
+		self.assertEqual(lt.libtorrent_category().name(), 'libtorrent')
+		self.assertEqual(lt.upnp_category().name(), 'upnp')
+		self.assertEqual(lt.http_category().name(), 'http')
+		self.assertEqual(lt.socks_category().name(), 'socks')
+		self.assertEqual(lt.bdecode_category().name(), 'bdecode')
+		self.assertEqual(lt.generic_category().name(), 'generic')
+		self.assertEqual(lt.system_category().name(), 'system')
+
 if __name__ == '__main__':
 	print(lt.__version__)
 	shutil.copy(os.path.join('..', '..', 'test', 'test_torrents', 'url_seed_multi.torrent'), '.')

src/bdecode.cpp

@@ -172,7 +172,7 @@ namespace libtorrent
 
 	const char* bdecode_error_category::name() const BOOST_SYSTEM_NOEXCEPT
 	{
-		return "bdecode error";
+		return "bdecode";
 	}
 
 	std::string bdecode_error_category::message(int ev) const BOOST_SYSTEM_NOEXCEPT

src/error_code.cpp

@@ -290,7 +290,7 @@ namespace libtorrent
 	struct TORRENT_EXPORT http_error_category : boost::system::error_category
 	{
 		virtual const char* name() const BOOST_SYSTEM_NOEXCEPT
-		{ return "http error"; }
+		{ return "http"; }
 		virtual std::string message(int ev) const BOOST_SYSTEM_NOEXCEPT
 		{
 			std::string ret;

src/socks5_stream.cpp

@@ -48,7 +48,7 @@ namespace libtorrent
 	struct socks_error_category : boost::system::error_category
 	{
 		virtual const char* name() const BOOST_SYSTEM_NOEXCEPT
-		{ return "socks error"; }
+		{ return "socks"; }
 		virtual std::string message(int ev) const BOOST_SYSTEM_NOEXCEPT
 		{
 			static char const* messages[] =

src/upnp.cpp

@@ -1159,7 +1159,7 @@ struct upnp_error_category : boost::system::error_category
 {
 	virtual const char* name() const BOOST_SYSTEM_NOEXCEPT
 	{
-		return "UPnP error";
+		return "upnp";
 	}
 
 	virtual std::string message(int ev) const BOOST_SYSTEM_NOEXCEPT

test/test_bdecode.cpp

@@ -338,7 +338,7 @@ TORRENT_TEST(bdecode_error)
 {
 	error_code ec(bdecode_errors::overflow);
 	TEST_EQUAL(ec.message(), "integer overflow");
-	TEST_EQUAL(ec.category().name(), std::string("bdecode error"));
+	TEST_EQUAL(ec.category().name(), std::string("bdecode"));
 	ec.assign(5434, get_bdecode_category());
 	TEST_EQUAL(ec.message(), "Unknown error");
 }