From 10dd1c73b2bb86dcafb55c411707ebe2d68bf4df Mon Sep 17 00:00:00 2001 From: Kjell Ahlstedt Date: Mon, 15 Aug 2022 16:20:30 +0200 Subject: Fix build with -Dbuild-deprecated-api=false Fixes #82 --- examples/meson.build | 2 +- meson.build | 2 +- tests/test_cpp11_lambda.cc | 12 ++++++------ tests/test_track_obj.cc | 29 ++++++++++++++++++++++++++++- 4 files changed, 36 insertions(+), 9 deletions(-) diff --git a/examples/meson.build b/examples/meson.build index c55bfdd..3c575ae 100644 --- a/examples/meson.build +++ b/examples/meson.build @@ -20,7 +20,7 @@ foreach ex : examples endforeach exe_file = executable(ex_name, ex_sources, - cpp_args: '-DSIGCXX_DISABLE_DEPRECATED', + cpp_args: '-DSIGCXX_DISABLE_DEPRECATED=1', dependencies: sigcxx_own_dep, implicit_include_directories: false, build_by_default: build_examples diff --git a/meson.build b/meson.build index bd1b771..c1b0c90 100644 --- a/meson.build +++ b/meson.build @@ -225,7 +225,7 @@ pkg_conf_data.set('PACKAGE_VERSION', meson.project_version()) pkg_conf_data.set('SIGCXX_API_VERSION', sigcxx_api_version) if not build_deprecated_api - pkg_conf_data.set('SIGCXX_DISABLE_DEPRECATED', true) + pkg_conf_data.set('SIGCXX_DISABLE_DEPRECATED', 1) endif pkg_conf_data.set('SIGCXX_MAJOR_VERSION', sigcxx_major_version) pkg_conf_data.set('SIGCXX_MINOR_VERSION', sigcxx_minor_version) diff --git a/tests/test_cpp11_lambda.cc b/tests/test_cpp11_lambda.cc index ed12536..40534e2 100644 --- a/tests/test_cpp11_lambda.cc +++ b/tests/test_cpp11_lambda.cc @@ -32,7 +32,7 @@ // The only real disadvantage of the C++11 lambda expressions is that a slot that // contains an object derived from sigc::trackable is not automatically disconnected // when the object is deleted, if a reference to the object is stored in a C++11 -// lambda expression, connected to the slot. But if you use sigc::track_obj(), +// lambda expression, connected to the slot. But if you use sigc::track_object(), // the slot is automatically disconnected. Thus, the disadvantage is insignificant. // // To test the C++11 lambda expressions with gcc 4.6.3 (and probably some later @@ -270,14 +270,14 @@ main(int argc, char* argv[]) // Here's an area where the libsigc++ lambda expressions are advantageous. // If you want to auto-disconnect a slot with a C++11 lambda expression // that contains references to sigc::trackable-derived objects, you must use - // sigc::track_obj(). + // sigc::track_object(). sigc::slot sl1; { book guest_book("karl"); // sl1 = (sigc::var(std::cout) << std::ref(guest_book) << sigc::var("\n")); // sl1 = [&guest_book](std::ostringstream& stream){ stream << guest_book << "\n"; }; // no // auto-disconnect - sl1 = sigc::track_obj( + sl1 = sigc::track_object( [&guest_book](std::ostringstream& stream) { stream << guest_book << "\n"; }, guest_book); sl1(result_stream); util->check_result(result_stream, "karl\n"); @@ -332,7 +332,7 @@ main(int argc, char* argv[]) // sl2 = sigc::group(&egon, std::ref(guest_book)); // sl2 = [&guest_book] () { egon(guest_book); }; // no auto-disconnect // sl2 = std::bind(&egon, std::ref(guest_book)); // does not compile (gcc 4.6.3) - sl2 = sigc::track_obj([&guest_book]() { egon(guest_book); }, guest_book); + sl2 = sigc::track_object([&guest_book]() { egon(guest_book); }, guest_book); sl2(); util->check_result(result_stream, "egon(string 'karl')"); @@ -352,7 +352,7 @@ main(int argc, char* argv[]) // sl2 = std::bind(&egon, std::ref(guest_book)); // does not compile (gcc 4.6.3) auto fn2 = std::bind(&egon, std::ref(guest_book)); // sl2 = fn2; // no auto-disconnect - sl2 = sigc::track_obj(fn2, guest_book); + sl2 = sigc::track_object(fn2, guest_book); sl2(); util->check_result(result_stream, "egon(string 'charlie')"); @@ -502,7 +502,7 @@ main(int argc, char* argv[]) // some_signal.connect([&some_bar](){ foo_group4(some_bar); }); // no auto-disconnect // some_signal.connect(sigc::bind(&foo_group4, std::ref(some_bar))); // auto-disconnects, but // we prefer C++11 lambda - some_signal.connect(sigc::track_obj([&some_bar]() { foo_group4(some_bar); }, some_bar)); + some_signal.connect(sigc::track_object([&some_bar]() { foo_group4(some_bar); }, some_bar)); some_signal.emit(); util->check_result(result_stream, "foo_group4(bar_group4&)"); } diff --git a/tests/test_track_obj.cc b/tests/test_track_obj.cc index 54b4430..5d91953 100644 --- a/tests/test_track_obj.cc +++ b/tests/test_track_obj.cc @@ -28,6 +28,12 @@ // // If test_track_obj writes nothing and the return code is 0, the test has passed. +// sigc::track_obj() is deprecated, but let's keep the test if possible. +// If libsigc++ is configured with -Dbuild-deprecated-api=false +// (--disable-deprecated-api), SIGCXX_DISABLE_DEPRECATED is defined in +// sigc++config.h. An undef at the start of this file has no effect. +#undef SIGCXX_DISABLE_DEPRECATED + #include "testutilities.h" #include #include @@ -118,7 +124,11 @@ main(int argc, char* argv[]) sigc::slot sl2; { bar_group4 bar4; +#ifndef SIGCXX_DISABLE_DEPRECATED sl1 = sigc::track_obj(Functor1(bar4), bar4); +#else + sl1 = sigc::track_object(Functor1(bar4), bar4); +#endif sl2 = sigc::track_object(Functor1(bar4), bar4); result_stream << sl1(-2) << ", " << sl2(2); util->check_result(result_stream, "negative, positive"); @@ -134,7 +144,11 @@ main(int argc, char* argv[]) auto psl4 = new sigc::slot; auto pbar4 = new bar_group4; auto pbook4 = new book("A Book"); +#ifndef SIGCXX_DISABLE_DEPRECATED *psl3 = sigc::track_obj(Functor2(*pbar4, *pbook4), *pbar4, *pbook4); +#else + *psl3 = sigc::track_object(Functor2(*pbar4, *pbook4), *pbar4, *pbook4); +#endif *psl4 = sigc::track_object(Functor2(*pbar4, *pbook4), *pbar4, *pbook4); result_stream << (*psl3)(0, "Book title: ") << ", " << (*psl4)(1, "Title: "); util->check_result(result_stream, "zero, Book title: A Book, positive, Title: A Book"); @@ -162,8 +176,13 @@ main(int argc, char* argv[]) book guest_book("karl"); // no auto-disconnect // sl1 = [&guest_book](std::ostringstream& stream){ stream << guest_book << "\n"; }; +#ifndef SIGCXX_DISABLE_DEPRECATED sl11 = sigc::track_obj( [&guest_book](std::ostringstream& stream) { stream << guest_book; }, guest_book); +#else + sl11 = sigc::track_object( + [&guest_book](std::ostringstream& stream) { stream << guest_book; }, guest_book); +#endif sl12 = sigc::track_object( [&guest_book](std::ostringstream& stream) { stream << guest_book; }, guest_book); sl11(result_stream); @@ -183,8 +202,12 @@ main(int argc, char* argv[]) book guest_book("karl"); // sl2 = [&guest_book] () { egon(guest_book); }; // no auto-disconnect // sl2 = std::bind(&egon, std::ref(guest_book)); // does not compile (gcc 4.6.3) +#ifndef SIGCXX_DISABLE_DEPRECATED sl21 = sigc::track_obj([&guest_book]() { egon(guest_book); }, guest_book); - sl22 = sigc::track_obj([&guest_book]() { egon(guest_book); }, guest_book); +#else + sl21 = sigc::track_object([&guest_book]() { egon(guest_book); }, guest_book); +#endif + sl22 = sigc::track_object([&guest_book]() { egon(guest_book); }, guest_book); sl21(); sl22(); util->check_result(result_stream, "egon(string 'karl')egon(string 'egon was here')"); @@ -208,7 +231,11 @@ main(int argc, char* argv[]) // some_signal.connect([&some_bar](){ foo_group4(some_bar); }); // no auto-disconnect // some_signal.connect(sigc::bind(&foo_group4, std::ref(some_bar))); // auto-disconnects, // but we prefer C++11 lambda +#ifndef SIGCXX_DISABLE_DEPRECATED some_signal.connect(sigc::track_obj([&some_bar]() { foo_group4(some_bar); }, some_bar)); +#else + some_signal.connect(sigc::track_object([&some_bar]() { foo_group4(some_bar); }, some_bar)); +#endif some_signal.connect(sigc::track_object([&some_bar]() { foo_group4(some_bar); }, some_bar)); some_signal.emit(); util->check_result(result_stream, "foo_group4(bar_group4&)foo_group4(bar_group4&)"); -- cgit v1.2.1