- Boost-users - lists.preview.boost.org

choosing boost libs to link on iPhone based on selected OS target?
by Kenny Riddile 10 Apr '09

10 Apr '09

I've built boost as static libs for both iPhone(ARM) and the iPhone simulator(x86). I'm trying to figure out how to configure XCode so that it will know which set of libraries to link against based on which OS target I choose in the IDE. Is there anyone with experience using boost on the iPhone that can shed some light on this? Rene?

2 1

[serialization] save/load split between 2 different classes
by Robert Dailey 10 Apr '09

10 Apr '09

I've got a particular issue I cannot seem to find a solution to. I'm using boost.serialization to deserialize audio data into an object that wraps OpenAL. For example, the data I'm writing out would be (in order) a single INT representing the size of the raw data and then the data buffer after that. However, in my "Sound" object, I do not keep the data and length information as state in the class. Instead, I just keep the OpenAL buffer handle. In order for this class to be able to implement save(), it would need to have extra state, which would not be appropriate. Basically, I need to have a separate object dedicated to saving the sound data, and another for loading it. Is this possible? Perhaps there is a recommended design?

2 4

[ASIO] How to terminate a io_service inside a library.
by Daniele Barzotti 10 Apr '09

10 Apr '09

Hi, I'm sorry if this is not a question specifically about ASIO, but I need a suggestion.. I have a library that can be built like a Dynamic or static. Inside I have the following code: ---------------------------------------------------------- // Main io_service static boost::asio::io_service io_service; static boost::scoped_ptr<boost::thread> io_service_thread; static boost::asio::io_service::work work(io_service); static bool thread_started; EXTERN_C EUROATLIB_API MyObjHandl CALL GetMyObj() { if (!thread_started) { try { // run the IO service as a separate thread io_service_thread.reset(new boost::thread( boost::bind(&boost::asio::io_service::run, &io_service) )); thread_started = !thread_started; } catch (boost::thread_resource_error e) { // Failed to create the new thread return 0; } } // create the new object return new MyObj(io_service); }; ---------------------------------------------------------- Ok, now I need a way to stop the io_service thread when all MyObj are destroyed. In the clients I use: boost::scoped_ptr<MyObj> _devMyObj( GetMyObj() ); How can I accomplish this in a right way? Thanks, Daniele.

2 3

Parallel port Class needed
by master master 10 Apr '09

10 Apr '09

Which class I can use for parallel port communication. I know for serial it is "serial_port". I worked with it and it is working fine. For parallel communication; which class(library) is needed. -Rahul To create something exceptional ________________________________ -Master4Master "Confidentiality Warning: This message and any attachments are intended only for the use of the intended recipient(s), are confidential, and may be privileged. If you are not the intended recipient, you are hereby notified that any review, re-transmission, conversion to hard copy, copying, circulation or other use of this message and any attachments is strictly prohibited. If you are not the intended recipient, please notify the sender immediately by return email, and delete this message and any attachments from your system. Virus Warning: Although I have taken reasonable precautions to ensure no viruses are present in this email, I cannot accept responsibility for any loss or damage arising from the use of this email or attachment." Speak out for justice and peace, even if your voice trembles. Add more friends to your messenger and enjoy! Go to http://messenger.yahoo.com/invite/

1 0

[ASIO] serial_port read seems to lost packets
by Daniele Barzotti 10 Apr '09

10 Apr '09

Hi, I'm sure that is a my issue but I need your help.. In my project I have to talk with a modem. In answer to my AT command it responds: +CMGS: 0 OK +CMGS: 0,4,26 +CTSDSR: 40,123,0,456,0,152 231270F2204AAADC1234663E8DE77708FC5F3E where the +CTSDSR arrives some milliseconds after the last +CMGS. The problem is that I catch the two +CMGS but i miss completely the +CTSDSR and I don't know why! the reading code is: void SerialPort::read_start() { // Start an asynchronous read _serialPort.async_read_some(boost::asio::buffer(_buf, m_buffer_size), boost::bind(&SerialPort::read_complete, this, boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred)); }; void SerialPort::read_complete(const boost::system::error_code& error, size_t bytes_transferred) { // the asynchronous read operation has now completed if (!error) { // saving data to vector _read_buffer.append(_buf, bytes_transferred); cout << _read_buffer << endl; } // start waiting for another asynchronous read again read_start(); }; Could someone give me some suggestions? Thanks! Daniele.

2 2

help with BOOST_DISABLE_ASSERTS
by er 10 Apr '09

10 Apr '09

Hi All, #define BOOST_DISABLE_ASSERTS #include <boost/assert.hpp> #include <call.h> int main(){ call(); return 0; }; If, for testing purposes, I define call() as BOOST_ASSERT(false); with or without -O2 as a compiler option, there are no assert failed messages during execution, as desired. In my actual program, however, call depends on many headers. If I artificially add BOOST_ASSERT(false); in one of them, it is not ignored with -O2 i.e. I get Assertion failed: (false), function call. I use i686-apple-darwin9-gcc-4.0.1. Am I using BOOST_DISABLE_ASSERTS correctly? How do I go about fixing this problem?

2 2

Spirit documentation as one file
by Roger House 10 Apr '09

10 Apr '09

Does the Spirit documentation exist as a single file that can be downloaded and printed? Roger House

4 3

[interprocess] synchronize startup
by Brent Arias 09 Apr '09

09 Apr '09

Researching boost user archives, I see this has been discussed before...but I'm not sure a clear answer was decided. What is the *recommended* way to have several processes synchronize their initialization, before using shared memory. Consider this example problem: 1) several writers to a boost.interprocess.message_queue will use "open_only" and need to wait until the queue is created (otherwise an exception will be thrown). 2) one reader of a boost.interprocess.message_queue will use "open_or_create" and then somehow signal other processes that the queue is now ready to be opened. The question is: what is the recommended way for the signal to be given to the other processes? Brent Arias

1 0

[Polynomial] Review Result
by John Maddock 09 Apr '09

09 Apr '09

Apologies for the delay in putting this together... First off I'd like to thank the author for submitting this for review - I wish all our SOC students were similarly diligent! :-) We received a number of reviews of this library, but none were in favor of acceptance in its current form, and most thought that there was still a fair bit of work to do to get the library into shape. However, most thought that the library could be accepted into Boost given sufficient changes/enhancements. Therefore the library is not accepted into Boost at this time, but I would like to encourage the author to continue to work on the library and resubmit at a future time. In no particular order the main review comments are summarized below: Principal comments: * Documentation, especially the background is inadequate and needs a good proofreading a) From the examples are nothing that a competent programmer couldn't figure out from the declarations. Some more interesting or useful examples would be nice, particularly for things like the special forms. It's not exactly clear what I would do with those functions. b) There is no documentation or references to the various algorithms used. Those, too, would be nice. c) Doc.html appear to have been created 'the Hard Way'. Would be much more useful and look nicer if produced with the Quickbook, Doxygen... toolchain. And make it maintainable by other people. * Use of constructors and assignment operators that modify their arguments isn't acceptable - best to find another interface for this. * Several reviewers noted that the code didn't build for them, in particular log2 isn't available on all platforms/compilers. * evaluate_polynomial() and evaluate_polynomial_faithfully() take their coefficient arguments in the opposite order of all the other functions/constructors in the library, without providing any reason for that choice. That's seems somewhat surprising. I'd suggest fixing that, or at the very least providing an argument in the documentation why this makes some sense. * Rename evaluate() to horner() and provide evaluate() as an inline call to horner(). * Rename evaluate_faithfully() to compensated_horner(). * Things that say "Be careful about this" generally need fixing. * It would be nice to have operator* and operator/ as well as *= and /=. * Considering they share the same core algorithm, it might be nice to have a function that could do division and return the remainder at the same time. Something like poly::divide(P &divisor, P &quotient, P &remainer) * FFTs are good for multiplying polynomials above a certain size, but they are rather heavy for small polynomials and can lead to unexpected crosstalk between terms. There should be an option for * that doesn't use the FFT, and it should be the default for small polynomials. * operator/= has a hardcoded "std::vector<double> new_coefficients" that later gets rounded?? This should be fixed to work with any type that fulfills the necessary conceptual requirements (and tested and documented what those requirements are - it would be nice if they were the same as the rest of Boost.Math). * The name FieldType is mathematically misleading since the instantiating type is very likely not to be a field (e.g. int or a multiple precision integer type). * the Polynomial class provides a fairly minimalist set of supported functions. This may well be deliberate (if so, apologies), but I would like to see a richer interface including such things as - content (gcd of coefficients, where that makes sense) - polynomial discriminant - resultant of 2 polynomials - evaluation of homogeneous polynomial ( f(x) = sum c_i x^i,f(a,b) = sum c_i a^i b^(d-i) ) - evaluation at a polynomial (f(g(x))) - Pseudo-division of polynomials - finding roots over C - finding roots over F_p - factorisation over Z - factorisation over F_p * We had one feature request for extending support to finite fields. * This constructor: template<typename U> polynomial(const U& v); had me a little confused at first - is there any advantage to making this a template rather than simply accepting a const FieldType& as the single argument? * It's not clear from the documentation what this constructor does: polynomial(InputIterator first1, InputIterator last1, InputIterator first2); It needs to clearly state the degree of the resulting polynomial and whether it passes through all/any of the points - in fact maybe the constructor should have a final parameter for the degree of the polynomial and use least-squares fitting when required? Likewise for the member function template<typename InputIterator> void interpolate(InputIterator first1, InputIterator last1, InputIterator first2); * Operators: the / and % operators need good descriptions of what they do, given that no exact division is possible. As someone else has already noted, a function to calculate divide and remainder in one step would be useful too. * GCD: presumably this is restricted to polynomials with integer coefficients? If so it should say so. * Evaluation: The docs should say what method is used for the evaluate_faithfully method and give a reference. Renaming as someone else suggested may be better too, but personally I'm easy either way on that. I'm not sure whether there should be an evaluate_by_preconditioning method, shouldn't the polynomial "know" that it has been preconditioned and react accordingly. I haven't looked/checked but do the usual arithmetic operators still work if the polynomial has been preconditioned? I assume probably not, but if that's the case there should be a stern warning to that effect, *and* checks in code to prevent us from doing something stupid :-) BTW, preconditioning can be applied to polynomials of any degree I believe it's just that it gets hard to implement in the generic case. In addition I'd like to see the evaluation functions templated, so that the type being evaluated can differ from FieldType - it would surely be quite common for example to create and manipulate polynomials with integer coefficients, but then want to evaluate on a floating point type. There is machinery in Boost.Math BTW to handle the mixed argument-promotion and calculation of the result type, let me know if you need help in using this. * Special Forms: the functions provided do *not* generate polynomials in the alternative forms, but rather generate the named polynomial of order N, which is rather less useful, but at the very least the docs need updating to reflect this. * test_arithmetics.cpp fails on cygwin: or at least it did once I added a using std::pow; to start of operator*= to get things compiling. * None of the code builds with msvc: there are a couple of issues here: friend polynomial<FieldType> boost::math::tools::gcd<>(polynomial<FieldType> u, polynomial<FieldType> v); Needs to be changed to: friend polynomial<FieldType> boost::math::tools::gcd<FieldType>(polynomial<FieldType> u, polynomial<FieldType> v); to get msvc to Grok the code. After that there are a bunch of failures due to the use of log2 which msvc doesn't support (and since it's not part of the std other compilers are likely to complain too). * I haven't looked too hard at the implementation, except to echo the comments posted previously that the Conceptual requirements for FieldType need documenting and *testing*. There are concept checking classes and archetypes in Boost.Math which may be of use here. Again, shout if you need help in figuring out how to use these. I did notice that operator*= for example uses std::complex<double> internally which effectively limits the precision that can be achieved - to be useful to me - and to replace the existing "implementation detail" polynomial class in Boost.Math - I would need the polynomial class to be usable with arbitrary precision types such as NTL::RR or mpfr_class. Also as previously noted, multiplication of small polynomials may well be more efficient with the "naive" algorithm, so some performance tests and experimenting is required here. Related to this, use of "round" should be restricted to types that are known to be integers? Regards, John Maddock Review Manager for Polynomial Library.

1 0

[lambda] Massive Windows warnings with containers of smart pointers
by Allen Cronce 09 Apr '09

09 Apr '09

Hi all, I'm seeing massive C4181 warnings using boost lambda on containers of smart pointers under Windows VS2005 with Boost 1.36. The warnings do not happen under GCC, with all warning options at maximum. I can see from the archives that Noah Roberts posted this issue, as well as other lambda related problems, to the list back in 2006. I can't find an answer to the warning issue. Our development team has a policy of zero-warning tolerance. While it's clear that the code is working on all platforms, the warnings are troublesome. I'm hoping that there is a work around other than just suppressing the 4181 warnings. Sample code and the resulting warning follows below. Thank you in advance for any suggestions. Best, -- Allen Cronce = = = = = = = = = = ======================================================================== /* The following is test code that generates a massive warning under Windows: warning C4181: qualifier applied to reference type; ignored */ class Foo { public: Foo(void): mValue(0) { }; ~Foo(void) { }; int getValue(void) const { return mValue; } protected: int mValue; }; void TestBoostLambdaWarnings(void) { typedef boost::shared_ptr<Foo> SharedFoo_T; vector<SharedFoo_T> fooVect; vector<SharedFoo_T>::iterator fooFound; fooFound = find_if(fooVect.begin(), fooVect.end(), boost::lambda::bind(&Foo::getValue, *boost::lambda::_1) == 3); } = = = = = = = = = = ======================================================================== 1>c:\sources\client\thirdpartylibs\installedwin32\individual\boost \include\boost\lambda\detail\operator_return_type_traits.hpp(240) : warning C4181: qualifier applied to reference type; ignored 1> c:\sources\client\thirdpartylibs\installedwin32\individual \boost\include\boost\lambda\detail\lambda_traits.hpp(45) : see reference to class template instantiation 'boost::lambda::detail::contentsof_type<A>' being compiled 1> with 1> [ 1> A=const boost::shared_ptr<Foo> 1> ] 1> c:\sources\client\thirdpartylibs\installedwin32\individual \boost\include\boost\lambda\detail\lambda_traits.hpp(53) : see reference to class template instantiation 'boost::lambda::detail::IF_type_<T>' being compiled 1> with 1> [ 1> T=boost::lambda::detail::contentsof_type<const boost::shared_ptr<Foo>> 1> ] 1> c:\sources\client\thirdpartylibs\installedwin32\individual \boost\include\boost\lambda\detail \operator_return_type_traits.hpp(314) : see reference to class template instantiation 'boost::lambda::detail::IF_type<C,T,E>' being compiled 1> with 1> [ 1> C=true, 1> T=boost::lambda::detail::contentsof_type<const boost::shared_ptr<Foo>>, 1> E = boost ::lambda::detail::identity_mapping<boost::lambda::detail::unspecified> 1> ] 1> c:\sources\client\thirdpartylibs\installedwin32\individual \boost\include\boost\lambda\detail\return_type_traits.hpp(88) : see reference to class template instantiation 'boost::lambda::return_type_1<Act,A>' being compiled 1> with 1> [ 1> Act=boost::lambda::other_action<boost::lambda::contentsof_action>, 1> A=const boost::shared_ptr<Foo> & 1> ] 1> c:\sources\client\thirdpartylibs\installedwin32\individual \boost\include\boost\lambda\detail\operator_lambda_func_base.hpp(79) : see reference to class template instantiation 'boost::lambda::return_type_1_prot<Act,A>' being compiled 1> with 1> [ 1> Act=boost::lambda::other_action<boost::lambda::contentsof_action>, 1> A=const boost::shared_ptr<Foo> & 1> ] 1> c:\sources\client\thirdpartylibs\installedwin32\individual \boost\include\boost\lambda\detail \operator_lambda_func_base.hpp(248) : see reference to class template instantiation 'boost::lambda::detail::unary_rt<Action,Bound,Open>' being compiled 1> with 1> [ 1> Action=boost::lambda::other_action<boost::lambda::contentsof_action>, 1> Bound=boost::tuples::tuple<boost::lambda::lambda_functor<boost::lambda::placeholder<1>>,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type>, 1> Open=boost::tuples::tuple<const boost::shared_ptr<Foo> &,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type> 1> ] 1> c:\sources\client\thirdpartylibs\installedwin32\individual \boost\include\boost\lambda\detail\lambda_functor_base.hpp(191) : see reference to class template instantiation 'boost::lambda::lambda_functor_base<Act,Args>::sig<SigArgs>' being compiled 1> with 1> [ 1> Act=boost::lambda::other_action<boost::lambda::contentsof_action>, 1> Args=boost::tuples::tuple<boost::lambda::lambda_functor<boost::lambda::placeholder<1>>,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type>, 1> SigArgs=boost::tuples::tuple<const boost::shared_ptr<Foo> &,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type> 1> ] 1> c:\sources\client\thirdpartylibs\installedwin32\individual \boost\include\boost\lambda\detail\lambda_functor_base.hpp(197) : see reference to class template instantiation 'boost::lambda::detail::deduce_non_ref_argument_types_<Args,SigArgs>' being compiled 1> with 1> [ 1> Args=boost::tuples::cons<const boost::lambda::lambda_functor<boost::lambda::lambda_functor_base<boost::lambda::other_action<boost::lambda::contentsof_action>,boost::tuples::tuple<boost::lambda::lambda_functor<boost::lambda::placeholder<1>>,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type>>>,boost::tuples::detail::map_tuple_to_cons<boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type>::type>, 1> SigArgs=boost::tuples::tuple<const boost::shared_ptr<Foo> &,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type> 1> ] 1> c:\sources\client\thirdpartylibs\installedwin32\individual \boost\include\boost\lambda\detail\lambda_functor_base.hpp(225) : see reference to class template instantiation 'boost::lambda::detail::deduce_non_ref_argument_types_<Args,SigArgs>' being compiled 1> with 1> [ 1> Args=boost::tuples::tuple<int (__thiscall Foo::* const ) (void) const,const boost::lambda::lambda_functor<boost::lambda::lambda_functor_base<boost::lambda::other_action<boost::lambda::contentsof_action>,boost::tuples::tuple<boost::lambda::lambda_functor<boost::lambda::placeholder<1>>,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type>>>,boost::lambda::detail::bind_traits<boost::tuples::null_type>::type,boost::lambda::detail::bind_traits<boost::tuples::null_type>::type,boost::lambda::detail::bind_traits<boost::tuples::null_type>::type,boost::lambda::detail::bind_traits<boost::tuples::null_type>::type,boost::lambda::detail::bind_traits<boost::tuples::null_type>::type,boost::lambda::detail::bind_traits<boost::tuples::null_type>::type,boost::lambda::detail::bind_traits<boost::tuples::null_type>::type,boost::lambda::detail::bind_traits<boost::tuples::null_type>::type>, 1> SigArgs=boost::tuples::tuple<const boost::shared_ptr<Foo> &,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type> 1> ] 1> c:\sources\client\thirdpartylibs\installedwin32\individual \boost\include\boost\lambda\detail\lambda_functor_base.hpp(398) : see reference to class template instantiation 'boost::lambda::detail::deduce_non_ref_argument_types<Args,SigArgs>' being compiled 1> with 1> [ 1> Args=boost::tuples::tuple<int (__thiscall Foo::* const ) (void) const,const boost::lambda::lambda_functor<boost::lambda::lambda_functor_base<boost::lambda::other_action<boost::lambda::contentsof_action>,boost::tuples::tuple<boost::lambda::lambda_functor<boost::lambda::placeholder<1>>,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type>>>,boost::lambda::detail::bind_traits<boost::tuples::null_type>::type,boost::lambda::detail::bind_traits<boost::tuples::null_type>::type,boost::lambda::detail::bind_traits<boost::tuples::null_type>::type,boost::lambda::detail::bind_traits<boost::tuples::null_type>::type,boost::lambda::detail::bind_traits<boost::tuples::null_type>::type,boost::lambda::detail::bind_traits<boost::tuples::null_type>::type,boost::lambda::detail::bind_traits<boost::tuples::null_type>::type,boost::lambda::detail::bind_traits<boost::tuples::null_type>::type>, 1> SigArgs=boost::tuples::tuple<const boost::shared_ptr<Foo> &,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type> 1> ] 1> c:\sources\client\thirdpartylibs\installedwin32\individual \boost\include\boost\lambda\detail\lambda_functor_base.hpp(164) : see reference to class template instantiation 'boost::lambda::lambda_functor_base<Act,Args>::sig<SigArgs>' being compiled 1> with 1> [ 1> Act=boost::lambda::action<2,boost::lambda::function_action<2>>, 1> Args=boost::tuples::tuple<int (__thiscall Foo::* const ) (void) const,const boost::lambda::lambda_functor<boost::lambda::lambda_functor_base<boost::lambda::other_action<boost::lambda::contentsof_action>,boost::tuples::tuple<boost::lambda::lambda_functor<boost::lambda::placeholder<1>>,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type>>>,boost::lambda::detail::bind_traits<boost::tuples::null_type>::type,boost::lambda::detail::bind_traits<boost::tuples::null_type>::type,boost::lambda::detail::bind_traits<boost::tuples::null_type>::type,boost::lambda::detail::bind_traits<boost::tuples::null_type>::type,boost::lambda::detail::bind_traits<boost::tuples::null_type>::type,boost::lambda::detail::bind_traits<boost::tuples::null_type>::type,boost::lambda::detail::bind_traits<boost::tuples::null_type>::type,boost::lambda::detail::bind_traits<boost::tuples::null_type>::type>, 1> SigArgs=boost::tuples::tuple<const boost::shared_ptr<Foo> &,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type> 1> ] 1> c:\sources\client\thirdpartylibs\installedwin32\individual \boost\include\boost\lambda\detail\lambda_functor_base.hpp(213) : see reference to class template instantiation 'boost::lambda::detail::deduce_argument_types_<Args,SigArgs>' being compiled 1> with 1> [ 1> Args = boost ::tuples ::tuple < boost ::lambda ::lambda_functor < boost ::lambda ::lambda_functor_base < boost ::lambda ::action<2,boost::lambda::function_action<2>>,boost::tuples::tuple<int (__thiscall Foo::* const )(void) const,const boost ::lambda ::lambda_functor < boost ::lambda ::lambda_functor_base < boost ::lambda ::other_action < boost ::lambda ::contentsof_action > ,boost ::tuples ::tuple < boost ::lambda ::lambda_functor < boost ::lambda ::placeholder < 1 > > ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type > > > ,boost ::lambda ::detail ::bind_traits < boost ::tuples ::null_type > ::type ,boost ::lambda ::detail ::bind_traits < boost ::tuples ::null_type > ::type ,boost ::lambda ::detail ::bind_traits < boost ::tuples ::null_type > ::type ,boost ::lambda ::detail ::bind_traits < boost ::tuples ::null_type > ::type ,boost ::lambda ::detail ::bind_traits < boost ::tuples ::null_type > ::type ,boost ::lambda ::detail ::bind_traits < boost ::tuples ::null_type > ::type ,boost ::lambda ::detail ::bind_traits < boost ::tuples ::null_type > ::type ,boost ::lambda::detail::bind_traits<boost::tuples::null_type>::type>>>,const int ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type>, 1> SigArgs=boost::tuples::tuple<const boost::shared_ptr<Foo> &,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type> 1> ] 1> c:\sources\client\thirdpartylibs\installedwin32\individual \boost\include\boost\lambda\detail\operator_lambda_func_base.hpp(60) : see reference to class template instantiation 'boost::lambda::detail::deduce_argument_types<Args,SigArgs>' being compiled 1> with 1> [ 1> Args = boost ::tuples ::tuple < boost ::lambda ::lambda_functor < boost ::lambda ::lambda_functor_base < boost ::lambda ::action<2,boost::lambda::function_action<2>>,boost::tuples::tuple<int (__thiscall Foo::* const )(void) const,const boost ::lambda ::lambda_functor < boost ::lambda ::lambda_functor_base < boost ::lambda ::other_action < boost ::lambda ::contentsof_action > ,boost ::tuples ::tuple < boost ::lambda ::lambda_functor < boost ::lambda ::placeholder < 1 > > ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type > > > ,boost ::lambda ::detail ::bind_traits < boost ::tuples ::null_type > ::type ,boost ::lambda ::detail ::bind_traits < boost ::tuples ::null_type > ::type ,boost ::lambda ::detail ::bind_traits < boost ::tuples ::null_type > ::type ,boost ::lambda ::detail ::bind_traits < boost ::tuples ::null_type > ::type ,boost ::lambda ::detail ::bind_traits < boost ::tuples ::null_type > ::type ,boost ::lambda ::detail ::bind_traits < boost ::tuples ::null_type > ::type ,boost ::lambda ::detail ::bind_traits < boost ::tuples ::null_type > ::type ,boost ::lambda::detail::bind_traits<boost::tuples::null_type>::type>>>,const int ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type>, 1> SigArgs=boost::tuples::tuple<const boost::shared_ptr<Foo> &,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type> 1> ] 1> c:\sources\client\thirdpartylibs\installedwin32\individual \boost\include\boost\lambda\detail \operator_lambda_func_base.hpp(222) : see reference to class template instantiation 'boost::lambda::detail::binary_rt<Action,Bound,Open>' being compiled 1> with 1> [ 1> Action=boost::lambda::relational_action<boost::lambda::equal_action>, 1> Bound = boost ::tuples ::tuple < boost ::lambda ::lambda_functor < boost ::lambda ::lambda_functor_base < boost ::lambda ::action<2,boost::lambda::function_action<2>>,boost::tuples::tuple<int (__thiscall Foo::* const )(void) const,const boost ::lambda ::lambda_functor < boost ::lambda ::lambda_functor_base < boost ::lambda ::other_action < boost ::lambda ::contentsof_action > ,boost ::tuples ::tuple < boost ::lambda ::lambda_functor < boost ::lambda ::placeholder < 1 > > ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type > > > ,boost ::lambda ::detail ::bind_traits < boost ::tuples ::null_type > ::type ,boost ::lambda ::detail ::bind_traits < boost ::tuples ::null_type > ::type ,boost ::lambda ::detail ::bind_traits < boost ::tuples ::null_type > ::type ,boost ::lambda ::detail ::bind_traits < boost ::tuples ::null_type > ::type ,boost ::lambda ::detail ::bind_traits < boost ::tuples ::null_type > ::type ,boost ::lambda ::detail ::bind_traits < boost ::tuples ::null_type > ::type ,boost ::lambda ::detail ::bind_traits < boost ::tuples ::null_type > ::type ,boost ::lambda::detail::bind_traits<boost::tuples::null_type>::type>>>,const int ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type>, 1> Open=boost::tuples::tuple<const boost::shared_ptr<Foo> &,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type> 1> ] 1> c:\program files (x86)\microsoft visual studio 8\vc\include \algorithm(87) : see reference to class template instantiation 'boost::lambda::lambda_functor_base<Act,Args>::sig<SigArgs>' being compiled 1> with 1> [ 1> Act=boost::lambda::relational_action<boost::lambda::equal_action>, 1> Args = boost ::tuples ::tuple < boost ::lambda ::lambda_functor < boost ::lambda ::lambda_functor_base < boost ::lambda ::action<2,boost::lambda::function_action<2>>,boost::tuples::tuple<int (__thiscall Foo::* const )(void) const,const boost ::lambda ::lambda_functor < boost ::lambda ::lambda_functor_base < boost ::lambda ::other_action < boost ::lambda ::contentsof_action > ,boost ::tuples ::tuple < boost ::lambda ::lambda_functor < boost ::lambda ::placeholder < 1 > > ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type > > > ,boost ::lambda ::detail ::bind_traits < boost ::tuples ::null_type > ::type ,boost ::lambda ::detail ::bind_traits < boost ::tuples ::null_type > ::type ,boost ::lambda ::detail ::bind_traits < boost ::tuples ::null_type > ::type ,boost ::lambda ::detail ::bind_traits < boost ::tuples ::null_type > ::type ,boost ::lambda ::detail ::bind_traits < boost ::tuples ::null_type > ::type ,boost ::lambda ::detail ::bind_traits < boost ::tuples ::null_type > ::type ,boost ::lambda ::detail ::bind_traits < boost ::tuples ::null_type > ::type ,boost ::lambda::detail::bind_traits<boost::tuples::null_type>::type>>>,const int ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type>, 1> SigArgs=boost::tuples::tuple<const boost::shared_ptr<Foo> &,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type> 1> ] 1> c:\program files (x86)\microsoft visual studio 8\vc\include \algorithm(96) : see reference to function template instantiation '_InIt std::_Find_if<std::_Vector_iterator<_Ty,_Alloc>,_Pr>(_InIt,_InIt,_Pr)' being compiled 1> with 1> [ 1> _InIt=std::_Vector_iterator<SharedFoo_T,std::allocator<SharedFoo_T>>, 1> _Ty=SharedFoo_T, 1> _Alloc=std::allocator<SharedFoo_T>, 1> _Pr = boost ::lambda ::lambda_functor < boost ::lambda ::lambda_functor_base < boost ::lambda ::relational_action < boost ::lambda ::equal_action > ,boost ::tuples ::tuple < boost ::lambda ::lambda_functor < boost ::lambda ::lambda_functor_base < boost ::lambda ::action<2,boost::lambda::function_action<2>>,boost::tuples::tuple<int (__thiscall Foo::* const )(void) const,const boost ::lambda ::lambda_functor < boost ::lambda ::lambda_functor_base < boost ::lambda ::other_action < boost ::lambda ::contentsof_action > ,boost ::tuples ::tuple < boost ::lambda ::lambda_functor < boost ::lambda ::placeholder < 1 > > ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type > > > ,boost ::lambda ::detail ::bind_traits < boost ::tuples ::null_type > ::type ,boost ::lambda ::detail ::bind_traits < boost ::tuples ::null_type > ::type ,boost ::lambda ::detail ::bind_traits < boost ::tuples ::null_type > ::type ,boost ::lambda ::detail ::bind_traits < boost ::tuples ::null_type > ::type ,boost ::lambda ::detail ::bind_traits < boost ::tuples ::null_type > ::type ,boost ::lambda ::detail ::bind_traits < boost ::tuples ::null_type > ::type ,boost ::lambda ::detail ::bind_traits < boost ::tuples ::null_type > ::type ,boost ::lambda::detail::bind_traits<boost::tuples::null_type>::type>>>,const int ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type>>> 1> ] 1> c:\sources\client\pace\libraries\src\libpaceutil \libpaceutil_test.cpp(2213) : see reference to function template instantiation '_InIt std ::find_if < std ::_Vector_iterator <_Ty,_Alloc>,boost::lambda::lambda_functor<T>>(_InIt,_InIt,_Pr)' being compiled 1> with 1> [ 1> _InIt=std::_Vector_iterator<SharedFoo_T,std::allocator<SharedFoo_T>>, 1> _Ty=SharedFoo_T, 1> _Alloc=std::allocator<SharedFoo_T>, 1> T = boost ::lambda ::lambda_functor_base < boost ::lambda ::relational_action < boost ::lambda ::equal_action > ,boost ::tuples ::tuple < boost ::lambda ::lambda_functor < boost ::lambda ::lambda_functor_base < boost ::lambda ::action<2,boost::lambda::function_action<2>>,boost::tuples::tuple<int (__thiscall Foo::* const )(void) const,const boost ::lambda ::lambda_functor < boost ::lambda ::lambda_functor_base < boost ::lambda ::other_action < boost ::lambda ::contentsof_action > ,boost ::tuples ::tuple < boost ::lambda ::lambda_functor < boost ::lambda ::placeholder < 1 > > ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type > > > ,boost ::lambda ::detail ::bind_traits < boost ::tuples ::null_type > ::type ,boost ::lambda ::detail ::bind_traits < boost ::tuples ::null_type > ::type ,boost ::lambda ::detail ::bind_traits < boost ::tuples ::null_type > ::type ,boost ::lambda ::detail ::bind_traits < boost ::tuples ::null_type > ::type ,boost ::lambda ::detail ::bind_traits < boost ::tuples ::null_type > ::type ,boost ::lambda ::detail ::bind_traits < boost ::tuples ::null_type > ::type ,boost ::lambda ::detail ::bind_traits < boost ::tuples ::null_type > ::type ,boost ::lambda::detail::bind_traits<boost::tuples::null_type>::type>>>,const int ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type>>, 1> _Pr = boost ::lambda ::lambda_functor < boost ::lambda ::lambda_functor_base < boost ::lambda ::relational_action < boost ::lambda ::equal_action > ,boost ::tuples ::tuple < boost ::lambda ::lambda_functor < boost ::lambda ::lambda_functor_base < boost ::lambda ::action<2,boost::lambda::function_action<2>>,boost::tuples::tuple<int (__thiscall Foo::* const )(void) const,const boost ::lambda ::lambda_functor < boost ::lambda ::lambda_functor_base < boost ::lambda ::other_action < boost ::lambda ::contentsof_action > ,boost ::tuples ::tuple < boost ::lambda ::lambda_functor < boost ::lambda ::placeholder < 1 > > ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type > > > ,boost ::lambda ::detail ::bind_traits < boost ::tuples ::null_type > ::type ,boost ::lambda ::detail ::bind_traits < boost ::tuples ::null_type > ::type ,boost ::lambda ::detail ::bind_traits < boost ::tuples ::null_type > ::type ,boost ::lambda ::detail ::bind_traits < boost ::tuples ::null_type > ::type ,boost ::lambda ::detail ::bind_traits < boost ::tuples ::null_type > ::type ,boost ::lambda ::detail ::bind_traits < boost ::tuples ::null_type > ::type ,boost ::lambda ::detail ::bind_traits < boost ::tuples ::null_type > ::type ,boost ::lambda::detail::bind_traits<boost::tuples::null_type>::type>>>,const int ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples ::null_type ,boost ::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type>>> 1> ]

2 1

[iostreams] building iostreams with zlib support for iphone
by Kenny Riddile 09 Apr '09

09 Apr '09

I need to build the iostreams library with zlib support for both the iphone and iphone simulator. I already know how to just build the libs for iphone and the simulator, but I'm a windows developer and have little dev experience on mac, let-alone iphone, so I'm a bit bewildered. How do I go about getting zlib support compiled in?

3 6

different member function signatures based on class template arguments
by Hicham Mouline 09 Apr '09

09 Apr '09

Hello, I have a long chain of calls of functions where a template argument is passed from 1 function to the next. Different template arguments required slightly different arguments in the following signature: template< typename Interp> struct InterExtrap { static void Process( xbegin, xend, x, AdditionalArguments<Interp> ); // this calls static function inside Interp }; AdditionalArguments<Interp> is: . empty for a couple of Interp . size_t for a couple of others . double d0, double d1 for a couple of others. If all cases had exactly 1 argument which varied, I would have done above: typename AdditionalArguments<Interp>::type I could do struct S { double d1; double d2; }; I have in mind optimization issues as well as many of these intermediate functions are inlined. So I am concerned about process(xbegin, xend, x, const S& s) // then access s.d1 and s.d2 as I measured it is slower than process(xbegin, xend, x, double d1, double d2) Initial function (specifies Interp and therefore knows whether to pass empty, or size_t, or double double) calls a number of intermediate functions that are not interested in this detail, but still have the Interp template argument, and finally call static functions inside Interp which then know what they require as arguments. Is it possible to write the intermediate functions (member of template classes) in a generic way? Would SFINAE or the sizeof trick or any MPL Fusion facility allow this? Regards,

2 12

default argument and call trait const_reference
by Hicham Mouline 09 Apr '09

09 Apr '09

Hello, I have the following template template<typename C> class X { public: template<typename Interp, typename Extrap> void Get (int, typename boost::call_traits<Interp>::const_reference= Interp(), typename boost::call_traits<Extrap>::const_reference= Extrap() ) const; }; template<typename C> template<typename Interp, typename Extrap> inline void X<C>::Get(int, typename boost::call_traits<Interp>::const_reference i, typename boost::call_traits<Extrap>::const_reference e ) { // when I get here, i.mOrder is not 2 (0) e.mOrder is not 2 (23142343) } class P { public: static const size_t defaultInterpolationOrder = 2; // quadratic polynomial Polynomial1D(size_t order =defaultInterpolationOrder) : mOrder(order) {} Private: size_t mOrder; }; 1 example of call is x.template GetSpot<P,P>( 5 ); when I debug this P's ctor is never called and mOrder is never 2 Is my GetSpot method valid, the construction of the temporary should be bound to the const ref const P& and the temporary should have finished being constructed before we go inside the Get() method. Is there an issue with the definition of Get being out of classe? Am I calling call_traits<P>::const_reference in a wrong way? VS2005SP1 Regards,

2 2

[mpl] register types in a mpl sequence type
by Thomas Lemm 09 Apr '09

09 Apr '09

All, I am trying to accomplish a compile time type registry by trying to register a specific subset of my classes into an mpl sequence type. So during compilation that sequence type should hold a sequence of my classes for subsequent processing (e.g. by mpl::for_each). An example: --- code start -------------- class Super { tyedef mpl::list<> SubTypesList; // usage of SubTypesList: printSubtypes() { mpl::for_each< SubTypesList >( ... )}; }; class A : public RegisterWith< A, Super > {}; class B : public RegisterWith< B, Super > {}; --- code end -------------- now Super::SubTypesList should be equivalent to mpl::list< A, B >. I have the feeling that this approach is not achievable with templates alone due to the C++ template mechanism not being able to redefine a type. Still I would be happy being proven wrong. Any pointers to similiar problems and solutions, alternative approaches (maybe using the boost_pp?) are welcome, too. Kind regards Thomas Lemm

2 1

Re: [Boost-users] Linking with dynamic boost thread library
by John Wilkinson 09 Apr '09

09 Apr '09

> If the program compiles and runs the same only based on whether boost*.lib > is there, what function does the boost*.dll serve The boost*.lib files, as I think someone said earlier, are the import libraries for the boost*.dll run-time libraries. These are what you link to, in order to use boost*.dll at run time. The DLL files do not need to be in the link path, only in the executable path when your program is run. The boost*.lib files need to be in the link path when you build your program. John

2 2

[lambda] how to get rid of the reference argument in lambda functor?
by Pobinger Gerhard Stefan 09 Apr '09

09 Apr '09

Hi *, I was desparately trying to compile something like this (VS2008), always getting the error that it cannot convert from int* to int*&. :boost::shared_ptr<int> c; ::boost::lambda::var(c) =::boost::lambda::constructor <::boost::shared_ptr<int>>() (::boost::lambda::new_ptr<int>()() ) [This is "short form" for the conventional code ::boost::shared_ptr<int>c=::boost::shared_ptr<int>(new int());] (1) The reason is that all lambda functors take arguments by reference. In this case, make_const in front of shared_ptr did not solve the problem, it causes immediate evaluation of the new_ptr functor... Is there any way to rewrite this (1) short line of code in boost-lambda? /Gerhard Pobinger

2 1

Re: [Boost-users] Linking with dynamic boost thread library
by Steven Watanabe 09 Apr '09

09 Apr '09

AMDG Green, Jason M NSWCDL, W33 wrote: > I have a directory in my project call Boost. I added the directory to the > library files list. > In this directory I have the libboost*.lib files and the boost*.dll files. > I am able to get it working with no problem if I only have the libboost*.lib > files in there. If I rename them, and add the dll into the directory, it > will not build. That is where it will give me the error saying that it is > looking for libboost*.lib > Whoa. I'm confused. Is the linker complaining about libboost*.lib or boost*.lib? If you define BOOST_ALL_DYN_LINK or BOOST_<library name>_DYN_LINK the compiler will look for the import libraries for the dlls. > Green, Jason M NSWCDL, W33 wrote: > >> the compile warns me that it "cannot open file >> 'boost_regex-vc80-mt-gd-1_38.lib'" >> >> In Christ, Steven Watanabe

2 1

[interprocess] warning C4251: need dll-interface
by Brent Arias 09 Apr '09

09 Apr '09

I've defined a class to use within shared memory, and I've decorated it with a Windows _declspec(export) to expose it from a DLL. When I compiled with VC 2008, I got this warning: Warning C4251: class 'boost::interprocess::vector<T,A>' needs to have dll-interface to be used by clients of 'MyClass' I searched boost user archives for any discussion of this, and in the context of boost.signals I've seen someone comment to simply disable the warning with: #pragma warning (disable: 4251) Std::list<OtherClass*> talkers; #pragma warning (default: 4151) Does this also apply to boost.interprocess? Is it really safe to ignore this warning and continue to use the interprocess code from within a DLL? Brent Arias

4 3

Concept DefaultConstructible vs type traits has_trivial_constructor
by Hicham Mouline 09 Apr '09

09 Apr '09

Hi, What is the difference between the 2? For a type T, can it be DefaultConstructible and has_trivial_constructor<T> is false? Rds,

2 1

Re: [Boost-users] boost build interface
by Rudolf Leitgeb 09 Apr '09

09 Apr '09

FWIW this doesn't have to be a windows only GUI. We could use the QT widget set and make this portable to most platforms supported by boost. Note, that Qt is LGPL now, so you could even include this into commercial distributions if needed. Am 08.04.2009 um 16:10 schrieb Green, Jason M NSWCDL, W33: > Not that I am volunteering, but it isn't that hard to come up with a > simple > dialog based mfc project that would set up the commands to properly > run the > boost build.

2 2

[interprocess] placement new allocator for vector
by Brent Arias 09 Apr '09

09 Apr '09

I'd like to have a user type that contains a vector and yet is still binary serializable, *AND* that can be used entirely inside or outside of shared memory. My idea is to give the vector a placement new allocator, it goes like this: class MyBinarySerialType { struct SomeItem { char first[10]; char second[10]; }; SomeItem m_Items[16]; //The placement new allocator points with an offset_ptr<SomeItem> //to the location &m_Items[0] boost::interprocess::vector<SomeItem, /*placement new allocator*/> m_vItems; public: MyBinarySerialType(const /*placement new allocator*/ &alloc); } I'd like to know if interprocess allocators can already do this for me (via template params, etc) or if I need to write my own allocator. If this is done correctly, I think it means I can "new" MyBinarySerialType from the regular heap and it will work entirely outside of shared memory. Likewise if I use segment.construct<MyBinarySerialType>()(...), then the whole thing should be created inside of shared memory. Either way, the vector will allocate strictly to a piece of memory inside the size of the class. Brent Arias

2 1

[date_time] Time duration parsing
by Konstantin Litvinenko 09 Apr '09

09 Apr '09

Hi All! I have a string "14:34" and want to parse it into boost::posix_time::time_duration. How can I do that?

1 0

[serialization] Export question
by Tom Aylesworth 09 Apr '09

09 Apr '09

I just want to make sure that I understand the use of the Serialization library's EXPORT macros. On the "Serializable Concepts" page of the documentation, it states: -- The macro BOOST_CLASS_EXPORT_GUID associates a string literal with a class. ... This permits each class to be in a separate header file along with its string identifier. -- However, on the "Special Considerations" page, I find: -- Note that the implementation of this functionality requires that the BOOST_CLASS_EXPORT macro appear after and the inclusion of any archive class headers for which code is to be instantiated. ... Note that including BOOST_CLASS_EXPORT in the "a.hpp" header itself as one would do with other serialization traits will make it difficult or impossible to follow the rule above regarding inclusion of archive headers before BOOST_CLASS_EXPORT is invoked. This is different than other serialization traits which would normally be included in same file as the class declaration. -- The associated example shows the EXPORT macro following the #include of the header defining the class to be exported. I would certainly much rather have the EXPORT macros appear in the header with the class that defines them. I take it that means I have to guarantee that the file actually responsible for operating on an archive includes my headers with the class definitions and EXPORT macros *after* including the appropriate archive headers (e.g., "boost/archive/xml_oarchive.hpp"). Is that correct? Are there any other gotchas I should be aware of if I place the EXPORT macros in the headers with the classes to be exported? Thanks, Thomas Aylesworth Senior Software Engineer Reality Mobile

3 7

boost build interface
by Igor 09 Apr '09

09 Apr '09

I have a suggestion: Why not make a simple dialog window with several check buttons and few radio buttons where you will choose what kind of library you want to build(static/dynamic, release/debug), one edit line in which you enter the location where you want your libraries to be built, and one push button that will execute the build process? It would make the building process of the boost libraries 100 times easier.

4 3

[interprocess] named mutex clean up
by Chard 09 Apr '09

09 Apr '09

Does calling named_mutex::remove() have consistent cross-platform behaviour? The reason I ask is that I am trying to use a named mutex for an "I'm the only process" check. That is, the process takes a shared lock on the named mutex (at start up), then, at points within the program, it attempts to get an exclusive lock in order to perform the check/actions. When finished, the mutex is returned to a shared lock. The problem is, if a process dies in some unforeseen manner - and does not get to call named_mutex::remove() - the named_mutex is left orphaned in the system (in a shared lock) such that other processes can never get an exclusive lock. On the Windows platform, I've found I can call named_mutex::remove() at start up, which seems to clean up the named_mutex if it is orphaned, or just do nothing if another, active, process has a lock - exactly the behaviour I require. However, is this platform independent, and a suitable technique?

4 6