- Boost-users - lists.boost.org

Boost.Parameter BOOST_PARAMETER_MEMBER_FUNCTION warning
by Joost Kraaijeveld 26 Jun '10

26 Jun '10

Hi, When using the BOOST_PARAMETER_MEMBER_FUNCTION as shown in the code below I get a compiler warning "unused parameter args" (see also below). Because the way my IDE works (Eclipse 3.6 with CDT 7.0), this warning is expanded to a lot of errors. Is it possible to get ride of the warning? Am I using the macro OK (it works but I don't know if that is just a coincidence;-))? TIA The code: > BOOST_PARAMETER_MEMBER_FUNCTION((UserCreator::UserCreationArguments*), > static newCreationArguments, > UserCreator::tag, > (optional > (objectId, ( const ObjectId&), ObjectId()) > (userId, ( const int&), 0) > (userName, ( const std::string&), std::string()) > (password, ( const std::string&), std::string()) > (firstName, ( const std::string&), std::string()) > (infix, ( const std::string&), std::string()) > (lastName, ( const std::string&), std::string()) > )) > { > return new UserCreator::UserCreationArguments( objectId, > userId, > userName, > password, > firstName, > infix, > lastName); > } The warning: > /home/jkr/Programming/C++/Danu/include/Danu/DanuModelObjects/User.hpp: In instantiation of ‘static ResultType Danu::User::boost_param_default_105newCreationArguments(ResultType (*)(), const Args&, int, objectId_type&, userId_type&, userName_type&, password_type&, firstName_type&, infix_type&, lastName_type&) [with ResultType = Danu::UserCreator::UserCreationArguments*, Args = boost::parameter::aux::empty_arg_list, objectId_type = const Danu::ObjectId, userId_type = const int, userName_type = const std::basic_string<char, std::char_traits<char>, std::allocator<char> >, password_type = const std::basic_string<char, std::char_traits<char>, std::allocator<char> >, firstName_type = const std::basic_string<char, std::char_traits<char>, std::allocator<char> >, infix_type = const std::basic_string<char, std::char_traits<char>, std::allocator<char> >, lastName_type = const std::basic_string<char, std::char_traits<char>, std::allocator<char> >]’: > /home/jkr/Programming/C++/Danu/include/Danu/DanuModelObjects/User.hpp:94: instantiated from ‘static ResultType Danu::User::boost_param_default_105newCreationArguments(ResultType (*)(), const Args&, long int, objectId_type&, userId_type&, userName_type&, password_type&, firstName_type&, infix_type&, boost::parameter::aux::use_default_tag) [with ResultType = Danu::UserCreator::UserCreationArguments*, Args = boost::parameter::aux::empty_arg_list, objectId_type = const Danu::ObjectId, userId_type = const int, userName_type = const std::basic_string<char, std::char_traits<char>, std::allocator<char> >, password_type = const std::basic_string<char, std::char_traits<char>, std::allocator<char> >, firstName_type = const std::basic_string<char, std::char_traits<char>, std::allocator<char> >, infix_type = const std::basic_string<char, std::char_traits<char>, std::allocator<char> >]’ > /home/jkr/Programming/C++/Danu/include/Danu/DanuModelObjects/User.hpp:94: instantiated from ‘static ResultType Danu::User::boost_param_default_105newCreationArguments(ResultType (*)(), const Args&, int, objectId_type&, userId_type&, userName_type&, password_type&, firstName_type&, infix_type&) [with ResultType = Danu::UserCreator::UserCreationArguments*, Args = boost::parameter::aux::empty_arg_list, objectId_type = const Danu::ObjectId, userId_type = const int, userName_type = const std::basic_string<char, std::char_traits<char>, std::allocator<char> >, password_type = const std::basic_string<char, std::char_traits<char>, std::allocator<char> >, firstName_type = const std::basic_string<char, std::char_traits<char>, std::allocator<char> >, infix_type = const std::basic_string<char, std::char_traits<char>, std::allocator<char> >]’ > /home/jkr/Programming/C++/Danu/include/Danu/DanuModelObjects/User.hpp:94: instantiated from ‘static ResultType Danu::User::boost_param_default_105newCreationArguments(ResultType (*)(), const Args&, long int, objectId_type&, userId_type&, userName_type&, password_type&, firstName_type&, boost::parameter::aux::use_default_tag) [with ResultType = Danu::UserCreator::UserCreationArguments*, Args = boost::parameter::aux::empty_arg_list, objectId_type = const Danu::ObjectId, userId_type = const int, userName_type = const std::basic_string<char, std::char_traits<char>, std::allocator<char> >, password_type = const std::basic_string<char, std::char_traits<char>, std::allocator<char> >, firstName_type = const std::basic_string<char, std::char_traits<char>, std::allocator<char> >]’ > /home/jkr/Programming/C++/Danu/include/Danu/DanuModelObjects/User.hpp:94: instantiated from ‘static ResultType Danu::User::boost_param_default_105newCreationArguments(ResultType (*)(), const Args&, int, objectId_type&, userId_type&, userName_type&, password_type&, firstName_type&) [with ResultType = Danu::UserCreator::UserCreationArguments*, Args = boost::parameter::aux::empty_arg_list, objectId_type = const Danu::ObjectId, userId_type = const int, userName_type = const std::basic_string<char, std::char_traits<char>, std::allocator<char> >, password_type = const std::basic_string<char, std::char_traits<char>, std::allocator<char> >, firstName_type = const std::basic_string<char, std::char_traits<char>, std::allocator<char> >]’ > /home/jkr/Programming/C++/Danu/include/Danu/DanuModelObjects/User.hpp:94: instantiated from ‘static ResultType Danu::User::boost_param_default_105newCreationArguments(ResultType (*)(), const Args&, long int, objectId_type&, userId_type&, userName_type&, password_type&, boost::parameter::aux::use_default_tag) [with ResultType = Danu::UserCreator::UserCreationArguments*, Args = boost::parameter::aux::empty_arg_list, objectId_type = const Danu::ObjectId, userId_type = const int, userName_type = const std::basic_string<char, std::char_traits<char>, std::allocator<char> >, password_type = const std::basic_string<char, std::char_traits<char>, std::allocator<char> >]’ > /home/jkr/Programming/C++/Danu/include/Danu/DanuModelObjects/User.hpp:94: instantiated from ‘static ResultType Danu::User::boost_param_default_105newCreationArguments(ResultType (*)(), const Args&, int, objectId_type&, userId_type&, userName_type&, password_type&) [with ResultType = Danu::UserCreator::UserCreationArguments*, Args = boost::parameter::aux::empty_arg_list, objectId_type = const Danu::ObjectId, userId_type = const int, userName_type = const std::basic_string<char, std::char_traits<char>, std::allocator<char> >, password_type = const std::basic_string<char, std::char_traits<char>, std::allocator<char> >]’ > /home/jkr/Programming/C++/Danu/include/Danu/DanuModelObjects/User.hpp:94: instantiated from ‘static ResultType Danu::User::boost_param_default_105newCreationArguments(ResultType (*)(), const Args&, long int, objectId_type&, userId_type&, userName_type&, boost::parameter::aux::use_default_tag) [with ResultType = Danu::UserCreator::UserCreationArguments*, Args = boost::parameter::aux::empty_arg_list, objectId_type = const Danu::ObjectId, userId_type = const int, userName_type = const std::basic_string<char, std::char_traits<char>, std::allocator<char> >]’ > /home/jkr/Programming/C++/Danu/include/Danu/DanuModelObjects/User.hpp:94: instantiated from ‘static ResultType Danu::User::boost_param_default_105newCreationArguments(ResultType (*)(), const Args&, int, objectId_type&, userId_type&, userName_type&) [with ResultType = Danu::UserCreator::UserCreationArguments*, Args = boost::parameter::aux::empty_arg_list, objectId_type = const Danu::ObjectId, userId_type = const int, userName_type = const std::basic_string<char, std::char_traits<char>, std::allocator<char> >]’ > /home/jkr/Programming/C++/Danu/include/Danu/DanuModelObjects/User.hpp:94: instantiated from ‘static ResultType Danu::User::boost_param_default_105newCreationArguments(ResultType (*)(), const Args&, long int, objectId_type&, userId_type&, boost::parameter::aux::use_default_tag) [with ResultType = Danu::UserCreator::UserCreationArguments*, Args = boost::parameter::aux::empty_arg_list, objectId_type = const Danu::ObjectId, userId_type = const int]’ > /home/jkr/Programming/C++/Danu/include/Danu/DanuModelObjects/User.hpp:94: instantiated from ‘static ResultType Danu::User::boost_param_default_105newCreationArguments(ResultType (*)(), const Args&, int, objectId_type&, userId_type&) [with ResultType = Danu::UserCreator::UserCreationArguments*, Args = boost::parameter::aux::empty_arg_list, objectId_type = const Danu::ObjectId, userId_type = const int]’ > /home/jkr/Programming/C++/Danu/include/Danu/DanuModelObjects/User.hpp:94: instantiated from ‘static ResultType Danu::User::boost_param_default_105newCreationArguments(ResultType (*)(), const Args&, long int, objectId_type&, boost::parameter::aux::use_default_tag) [with ResultType = Danu::UserCreator::UserCreationArguments*, Args = boost::parameter::aux::empty_arg_list, objectId_type = const Danu::ObjectId]’ > /home/jkr/Programming/C++/Danu/include/Danu/DanuModelObjects/User.hpp:94: instantiated from ‘static ResultType Danu::User::boost_param_default_105newCreationArguments(ResultType (*)(), const Args&, int, objectId_type&) [with ResultType = Danu::UserCreator::UserCreationArguments*, Args = boost::parameter::aux::empty_arg_list, objectId_type = const Danu::ObjectId]’ > /home/jkr/Programming/C++/Danu/include/Danu/DanuModelObjects/User.hpp:94: instantiated from ‘static ResultType Danu::User::boost_param_default_105newCreationArguments(ResultType (*)(), const Args&, long int, boost::parameter::aux::use_default_tag) [with ResultType = Danu::UserCreator::UserCreationArguments*, Args = boost::parameter::aux::empty_arg_list]’ > /home/jkr/Programming/C++/Danu/include/Danu/DanuModelObjects/User.hpp:94: instantiated from ‘static ResultType Danu::User::boost_param_default_105newCreationArguments(ResultType (*)(), const Args&, int) [with ResultType = Danu::UserCreator::UserCreationArguments*, Args = boost::parameter::aux::empty_arg_list]’ > /home/jkr/Programming/C++/Danu/include/Danu/DanuModelObjects/User.hpp:94: instantiated from ‘static typename Danu::User::boost_param_result_105newCreationArguments<Args>::type Danu::User::boost_param_implnewCreationArguments(const Args&) [with Args = boost::parameter::aux::empty_arg_list]’ > /home/jkr/Programming/C++/Danu/include/Danu/DanuModelObjects/User.hpp:94: instantiated from here > /home/jkr/Programming/C++/Danu/include/Danu/DanuModelObjects/User.hpp:94: warning: unused parameter ‘args’ -- Groeten, Joost Kraaijeveld Askesis B.V. Molukkenstraat 14 6524NB Nijmegen tel: 024-3888063 / 06-51855277 fax: 024-3608416 web: www.askesis.nl

1 0

[signals2] scoped_connection strangeness
by liamv7 25 Jun '10

25 Jun '10

Hi list, I'm using the signals2 library in the arrangement shown below. Connections are using the scoped_connection class. When I call Disconnect on an instant of X I expect that it won't be referenced anymore (by the signaller object.) But it generally doesn't seem to be the case. For the object "a" it is correctly destructed but "b" isn't destructed until the signaller object is destructed. I am using signals2 correctly? [Basically, I have a asio socket objects that I want to close when the service is stopped so I'm signaling the objects this way] Thanks, Liam. ------------------------------------------------------------------------------------- #include <iostream> #include <boost/shared_ptr.hpp> #include <boost/signals2.hpp> #include <boost/enable_shared_from_this.hpp> struct X : public boost::enable_shared_from_this<X> { X(std::string S) : s_(S) { std::cout << "X() " << s_ << std::endl; } ~X() { std::cout << "~X() " << s_ << std::endl; } void Signal() { std::cout << "signal " << s_ << std::endl; } void Start(boost::signals2::signal<void ()>& Signaller) { connection_ = Signaller.connect(boost::bind(&X::Signal, shared_from_this())); } void Disconnect() { connection_.disconnect(); //connection_.release(); } std::string s_; boost::signals2::scoped_connection connection_; }; typedef boost::shared_ptr<X> SX; void TestSignals() { boost::signals2::signal<void ()> signaller; //boost::signals2::scoped_connection a, b, c, d; { SX a(new X("a")), b(new X("b")), c(new X("c")), d(new X("d")); a->Start(signaller); a->Disconnect(); b->Start(signaller); c->Start(signaller); b->Disconnect(); } // a's destructor is called but not b's std::cout << "b's destructor should of been called" << std::endl; // std::cout << "->signaller" << std::endl; signaller(); std::cout << "<-signaller" << std::endl; } int main() { TestSignals(); return 0; } ------------------------------------------------------------- output: $ ./Signal X() a X() b X() c X() d ~X() d ~X() a b's destructor should of been called ->signaller ~X() b signal c <-signaller ~X() c ---------------------------------------------------

3 7

Re: [Boost-users] Making boost.bind take more arguments
by Pete Bartlett 25 Jun '10

25 Jun '10

>I need Boost.Bind to take up to 12 arguments (right now it only goes up >to 10). How? > >(before you criticize me for "too many arguments", this is in >auto-generated code. So shush ;) ) > If it really has to be Boost.Bind you'd have to hack the source. If you can use Boost.Phoenix.Bind there is a define (PHOENIX_COMPOSITE_LIMIT) you can set to control the number of available arguments.

2 1

boost::interprocess locks: crashes causing deadlock
by Jonathon 25 Jun '10

25 Jun '10

Hello, I am currently using boost::inteprocess locks for the windows platform. I've used both the named_recursive_mutex and the interprocess_recursive_mutex. Both implementations use the code below: inline void interprocess_mutex::lock(void) { do{ boost::uint32_t prev_s = detail::atomic_cas32((boost::uint32_t*)&m_s, 1, 0); if (m_s == 1 && prev_s == 0){ break; } // relinquish current timeslice detail::thread_yield(); }while (true); } One issue that I noticed was that if a thread crashes while holding the lock, all other threads stay blocked. If I rerun my process again, my process just hangs at the detail::atomic_cas32() which causes a deadlock. I've tried looking through all the other interprocess locks, and they all seem to filter down to this call. Can someone suggest a locking mechanism where I could lock a resource from all other processes, but if a process crashes that currently owns the lock, other threads will be allowed to acquire the lock? It seems like "file lock" might do what I want, but I wasn't to sure. any suggestions? thx, J

2 2

boost.xpressive: using placeholders with custom (check()) assertions
by Alex Dubov 25 Jun '10

25 Jun '10

Greetings. Xpressive allows the use of object placeholders in semantic actions, which are being replaced by actual object references during the match, like in this simple example: placeholder<string> p_string; sregex r = (expr)[do_something(p_string, _)]; When executed, do_something() functor will receive a reference to string, as expected. However, if functor is wrapped with assertion, this won't work: sregex r = (expr)[check(do_something(p_string, _))]; Compilation will fail, because do_something has no method which accepts xpressive::placeholder<> objects. And even if such method was to be added, there's no obvious way to obtain a run-time reference to actual object out of placeholder. This leads to some question: 1. Is there any trick allowing to use placeholders within check() assertions? 2. Alternatively, may there be a way to declare a semantic action functor, returning bool, in such a way, that it will act as custom assertion? It seems to me, that some cunning trick involving boost::proto construct may exist, even though I can't think of any particular way to do so. In light of the above, I also thought about sort of feature request: 3. Sometimes, custom assertion applies only to a part of the match, something like: *((expr)[check(cond)] | _) That is, a desire is to consume everything, until some specific "expr" token matches a precondition. However, raised assertion will not stop the matching, because it only applies to one branch of the regexp. It could be very handy if there was a way to signal from assertion that a larger containing expression matched it results. Thanks.

2 6

[boost][exception] Wide-character design considerations
by Christoph Heindl 25 Jun '10

25 Jun '10

Hello, How do you guys deal with boost.exceptions and wide-character strings? Currently, I convert, all wide-character strings are narrowed to their single-byte variants before passing them to boost::error_info tags. This however leads to a) partially unreadable strings: when narrowing a boost::filesystem::wpath to fit into a boost::errinfo_file_name b) potential throw from the narrowing code. c) calls narrowing code all around our code-basis. Best regards, Christoph

5 18

Boost's direction regarding UTF8 -> UTF32 and UTF32 -> UTF8
by Rodrigo Madera 25 Jun '10

25 Jun '10

Dear boosters, What is the consensus on best-practice regarding the conversion of UTFx to/from UTFy? I see that Boost Regex uses ICU for some conversions, but is there any user exported interface for conversions? There are several points in which being able to convert between UTFs is interesting. While I could stick to one of the several solutions and façades on the Web (including some Boost Vault projects), I would rather know the current community opinion on the subject. Any sandbox and/or vault projects that catched any veterans eyes? Kind regards, Rodrigo

6 15

is_range / is_range_of metafunctions
by Duncan Smith 24 Jun '10

24 Jun '10

I'm using the Boost.Range 2.0 library (Boost version 1.43.0), and I was looking for metafunctions to use in conjunction with boost::enable_if. I wasn't able to find anything akin to "is_range" and/or "is_range_of" in Boost.Range or in Boost.TypeTraits. Here is a demonstrative example that uses "is_range_of": class Y, Z; class X { struct enabler {}; public: // Construct from a range of Y. template <class Range> X(const Range &r, typename boost::enable_if < typename boost::is_range_of<Range, Y>::type , enabler >::type = enabler()) { /* ... */ } // Construct from a range of Z. template <class Range> X(const Range &r, typename boost::enable_if < typename boost::is_range_of<Range, Z>::type , enabler >::type = enabler()) { /* ... */ } }; Did I overlook something? Is there an easy way to get this effect? I did find an email in the archives with an implementation of this functionality: http://lists.boost.org/Archives/boost/2007/08/125851.php That implementation works for me. Is there a reason they have not been included? Thanks for any guidance, Duncan

2 2

Re: [Boost-users] Boost.Wave crippling
by Pete Bartlett 24 Jun '10

24 Jun '10

On 06/20/10 20:54, Steven Watanabe wrote: > > // a.hpp > > #ifndef BOOST_PP_IS_ITERATING > > #include <boost/preprocessor/iteration/iterate.hpp> > > #define BOOST_PP_FILENAME_1 "a_impl.hpp" > > #define BOOST_PP_ITERATION_LIMITS (1, 10) > > #include BOOST_PP_ITERATE() > > #else > > // ... > > #endif > Macro expansion is not allowed so such a construct would not work. > Macros are not allowed in the #include directives. Ok you can ban the technique in your libraries, but what happens if you use third-party libraries that do use the technique? Like Boost, for example.

2 1

Serialization, mpl: BOOST_CLASS_VERSION() macro causes gcc compile errors with Boost version 1.43
by Clarke, Carus V 24 Jun '10

24 Jun '10

Using Boost version 1.43 to compile my project caused the following errors to occur. There are more, but they are essentially the same: g++ -o build/ftds_com/calc/DerivedCalculationInformation.o -c -Wall -ansi -Wno-missing-braces -mwin32 -mthreads -DZAF_BOOL_DEFINED -D_WIN32_WINNT=0x0501 -D__USE_W32_SOCKETS -DWIN32_LEAN_AND_MEAN -DNOMINMAX -Iinclude -I/c/dvlp/boost_1_43_0 -I/c/dvlp/vt1413_32/include "-I/c/Program Files/IVI Foundation/VISA/winnt/include" "-I/c/Program Files/Agilent/IO Libraries Suite/include" -I/c/dvlp/zaf6.0/target/h source/ftds_com/calc/DerivedCalculationInformation.cpp In file included from source/ftds_com/calc/DerivedCalculationInformation.cpp:27: include/avgcalc.h:67: error: conflicting declaration 'mpl_assertion_in_line_67' include/addcalc.h:67: error: 'mpl_assertion_in_line_67' has a previous declaration as '<anonymous enum> mpl_assertion_in_line_67' In file included from source/ftds_com/calc/DerivedCalculationInformation.cpp:35: include/dselcalc.h:68: error: conflicting declaration 'mpl_assertion_in_line_68' include/actual_airflow_calc.h:68: error: 'mpl_assertion_in_line_68' has a previous declaration as '<anonymous enum> mpl_assertion_in_line_68' In file included from source/ftds_com/calc/DerivedCalculationInformation.cpp:36: include/epowcalc.h:65: error: conflicting declaration 'mpl_assertion_in_line_65' include/datecalc.h:65: error: 'mpl_assertion_in_line_65' has a previous declaration as '<anonymous enum> mpl_assertion_in_line_65' In file included from source/ftds_com/calc/DerivedCalculationInformation.cpp:37: include/fsdvcalc.h:68: error: conflicting declaration 'mpl_assertion_in_line_68' include/actual_airflow_calc.h:68: error: 'mpl_assertion_in_line_68' has a previous declaration as '<anonymous enum> mpl_assertion_in_line_68' In file included from source/ftds_com/calc/DerivedCalculationInformation.cpp:38: include/gas_density_calc.h:68: error: conflicting declaration 'mpl_assertion_in_line_68' ... I was able to verify that these were caused by the BOOST_CLASS_VERSION macro appearing on the same line in two or more files included by the file being compiled. Using the BOOST_PP_COUNTER from the preprocessor library as the argument to a #line directive on the line preceding the BOOST_PP_COUNTER macro can be used as a workaround. Another was to disable the MPL assertion in the body of the macro. For class versioning to work for gcc, the BOOST_PP_COUNTER macro has to appear in a header file, and I think it is better to put it in the header files for the classes to be serialized. Here is a sample of the workaround: // the next two lines are needed to prevent compile-time errors with gcc #include BOOST_PP_UPDATE_COUNTER() #line BOOST_PP_COUNTER BOOST_CLASS_VERSION(Calculation, 0) Is there a better way to handle the problem? Is this a bug? Thanks, Carus V. (Bud) Clarke carus.v.clarke(a)boeing.com

2 1