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

Problems using boost::interprocess on Mac OS X
by Robert Bielik 05 Jan '12

05 Jan '12

Hi All, I'm trying to use boost::interprocess::named_mutex (1.47.0) on Mac OS X (10.6.7) with GCC 4.0, but I get loads of errors when compiling, the first ones shown here: /boost_1_47_0/boost/interprocess/sync/emulation/named_creation_functor.hpp:38:0 /boost_1_47_0/boost/interprocess/sync/emulation/named_creation_functor.hpp:38: error: expected type-specifier before 'Lm_arg' /boost_1_47_0/boost/interprocess/sync/emulation/named_creation_functor.hpp:38:0 /boost_1_47_0/boost/interprocess/sync/emulation/named_creation_functor.hpp:38: error: expected `)' before 'Lm_arg' /boost_1_47_0/boost/interprocess/sync/emulation/named_creation_functor.hpp:38:0 /boost_1_47_0/boost/interprocess/sync/emulation/named_creation_functor.hpp:38: error: expected `;' before 'Lm_arg' /boost_1_47_0/boost/exception/exception.hpp:320:0 /boost_1_47_0/boost/exception/exception.hpp:320: error: anachronistic old-style base class initializer /boost_1_47_0/boost/exception/exception.hpp:320:0 /boost_1_47_0/boost/exception/exception.hpp:320: error: unnamed initializer for 'boost::exception_detail::error_info_injector<T>', which uses multiple inheritance /boost_1_47_0/boost/exception/exception.hpp:321:0 /boost_1_47_0/boost/exception/exception.hpp:321: error: 'Lx' was not declared in this scope /boost_1_47_0/boost/exception/exception.hpp:418:0 /boost_1_47_0/boost/exception/exception.hpp:418: error: anachronistic old-style base class initializer /boost_1_47_0/boost/exception/exception.hpp:418:0 /boost_1_47_0/boost/exception/exception.hpp:418: error: unnamed initializer for 'boost::exception_detail::clone_impl<T>', which uses multiple inheritance /boost_1_47_0/boost/exception/exception.hpp:419:0 /boost_1_47_0/boost/exception/exception.hpp:419: error: 'Lx' was not declared in this scope ... Any ideas how to fix this ? TIA /Rob

2 2

[Phoenix][v3] Argument/State dependent return type of actors?
by Josef Weinbub 05 Jan '12

05 Jan '12

Hi Recently I made myself familiar with Phoenix v3, more specifically with actors. I did a few test implementations, and I wondered if there is a way to access the argument types (nested in the context's environment) and/or the type of the state(s) (nested in the proto expression) for the actor's result type declaration. Have a look at the following actor dummy implementation, especially at the line ''typedef int result_type;'': (for the sake of completeness, the complete actor implementation is provided) ------------------------------------------------------------ BOOST_PHOENIX_DEFINE_EXPRESSION( (boost)(phoenix)(myactor) , (boost::phoenix::meta_grammar) ) struct myactor_eval { // ------------------------ // the result type can not be made dependable from // one of the actors argument types .. it is // typedef int result_type; // ------------------------ template <typename StateExpr, typename Context> result_type operator()(StateExpr const& state_expr, Context & ctx) const { return -1; } }; namespace boost { namespace phoenix { template <> struct default_actions::when< rule::myactor> : boost::phoenix::call< ::myactor_eval> {}; template <typename T> typename expression::myactor<T>::type const inline myactor(T& t) { return expression::myactor<T>::make(t); } }} ------------------------------------------------------------ As I already stated, I wonder if there is a way to have access to the argument and state types for the result type, maybe as it was possible in Phoenix v2 via a nested template struct which got the same template parameters as the functor, like the simple example in the following: ------------------------------------------------------------ struct myactor_eval { template <typename StateExpr, typename Context> struct result { typedef typename result_of::env<Context>::type Environment; typedef typename remove_reference< Environment>::type::args_type Args; typedef typename result_of::value_at_c< Args, 0>::type Parameter; // make the result type argument dependent! typedef typename Parameter::value_type type; }; ... }; ------------------------------------------------------------ I do hope that I haven't overlooked something in the docs, sorry if I did. Thanks for your support! Cheers, Josef Weinbub

2 3

Re: [Boost-users] [Iostreams] Buffering nonblocking I/O
by Nat Linden 05 Jan '12

05 Jan '12

On Wed, Jan 4, 2012 at 5:21 PM, Chris Cleeland <chris.cleeland(a)gmail.com> wrote: > On Wed, Jan 4, 2012 at 1:44 PM, Nat Linden <nat(a)lindenlab.com> wrote: >> Let's postulate a new Boost.Iostreams Concept to describe an object >> capable of buffering data between producer and consumer. >> Until we can settle on a better name, as a placeholder, let's just >> call this a Queue. > You could call this thing a "conduit". Interesting! Although the term doesn't quite jump out at me, I can understand the metaphor, and to my knowledge it has the virtue of not already being hopelessly overloaded. If other people like it, I could go with that. >> ... I actually need an unbounded Queue for this. > > AND > >> It would also be possible to implement a Queue based on an actual OS pipe. > > Beware that OS pipes are bounded. Yup, I know that. Sorry I wasn't clearer: I intended to suggest three different plausible implementations of the Queue/Conduit concept, with variations on the one I'm actually planning to build. For an unbounded implementation I'm toying with a std::list< std::basic_string<Ch> >. I consider it interesting that you could fairly simply build an implementation around an OS pipe, but that doesn't address the use case that interests me most at the moment. I tossed it out there for purposes of illustration -- I guess a bit too tersely.

1 0

[geometry] GGL mailing list moved
by Mateusz Loskot 04 Jan '12

04 Jan '12

Hi, To Whom It May Concern... The Boost.Geometry library mailing list has moved from ggl at lists.osgeo.org server to geometry at lists.boost.org server. All existing subscribers and archives have been moved to the new server. The new list is available at: http://lists.boost.org/mailman/listinfo.cgi/geometry as well as listed on the main page: http://lists.boost.org/ It is also mirrored at Nabble: http://boost-geometry.203548.n3.nabble.com/ (Mirror at gmane.org may be added in future.) The old list at lists.osgeo.org will be wiped out soon. If anyone experiences any problems with the new geometry at lists.boost.org, please contact me directly. I'd like to thank OSGeo Foundation for hosting the first mailing list and the Boost mailman admins for help with the new one. Best regards, -- Mateusz Loskot, http://mateusz.loskot.net

1 0

[Iostreams] Buffering nonblocking I/O
by Nat Linden 04 Jan '12

04 Jan '12

I find myself wanting to extend Boost.Iostreams to support (at least a particular use case for) nonblocking I/O. I'd like to sketch a couple concepts, hoping you will improve and generalize the notion. In particular, it's easily possible that I don't yet understand Iostreams well enough: what I'm describing may well fit into existing Concepts better than I realize. Boost.Iostreams intends to provide more complete support for nonblocking I/O in future [0]. We can hope that a discussion around these ideas could help evolve the library in that direction. First I want to acknowledge Alexander Nasonov's work from 2003 [1]. I haven't used or even looked at his "iostream-like pipes" library [2] because I'm dubious about registering with Yahoo! before being allowed to download it. (John Torjo seems to have had some trouble too. [3]) If it were posted somewhere more freely accessible, I'd be interested to examine it because I think there's at least conceptual overlap. Let's postulate a new Boost.Iostreams Concept to describe an object capable of buffering data between producer and consumer. It's not quite a Filter because, as I understand it, control is passed to a Filter at only one end. An InputFilter receives control at the consumer end; it forwards the call to its upstream Source. Conversely, an OutputFilter receives control at the producer end, forwarding the call to its downstream Sink. I'm talking about an object that receives control at both the producer and consumer end, providing a buffer between them. My first thought was to call this concept a Pipe because it bears a strong conceptual resemblance to OS pipes. But others in the aforementioned mail thread ([4], [5]) point out that using the word "pipe" in connection with Iostreams (or C++ streams in general) is too easily misinterpreted: one tends to assume a stream interface to a real OS pipe. Other plausible names are "buffer" or "synchronization channel" [4] or "message queue." Talking about a "buffer stream" versus a "streambuf" could fairly quickly get confusing. I shy away from any form of "channel" simply because, in our own code base, the word "channel" is already overloaded to mean four or five vastly different things. Of course "message queue" already has another specific meaning too. [6] Until we can settle on a better name, as a placeholder, let's just call this a Queue. Naturally the producer end should model Sink, and the consumer end should model Source. Why elevate this to a concept? Why not just provide a class? Because different use cases suggest different implementations -- all of which could be plug-compatible. To the extent I understand it, Alexander's library [1] appears to be targeted at cross-thread message passing. It implicitly handles thread synchronization. He also mentions unlimited vs. limited capacity, that is, a bounded max size: when the buffer is full, a producer will block until a consumer has eaten some of the pending data. Unless I went off the rails somewhere, this would be a valid model of the Queue concept. My use case targets an interactive program built around an event loop. I'm not passing data between different threads, so thread synchronization would be unnecessary overhead. Instead, every iteration of the main loop I intend to poll a nonblocking source and a nonblocking sink. I want to use a couple such Queue objects to buffer the data. The application logic must be able to write data to a std::ostream. (If the producer end of a Queue models Sink, it should be straightforward to construct such an ostream based on this Queue.) Because the Sink underlying an ostream operation must model Blocking, I actually need an unbounded Queue for this. Then each iteration of the main loop will attempt to write all pending data on the nonblocking sink; data actually written can be consumed from the Queue. Unwritten data will be handled by subsequent iterations. The input side is similar. Each iteration of the main loop will attempt to fill a temporary buffer from the nonblocking source; the data it obtains will be put into the other Queue. (This can be a bounded Queue: given a way to determine how much buffer remains available, we can limit the size of the nonblocking read.) Presently there will be "enough" data for the application logic to read an istream attached to the consumer side of the Queue. This is so we can guarantee that the application-level istream read operation can be completely satisfied without blocking. Determination of "enough" is of course protocol-specific, as is the means for notifying the application logic. I would want such details to belong to a specific instance of the concept, perhaps a subclass of a provided base class, rather than part of the Queue concept itself. I've been speaking of a nonblocking "source" and "sink" (in lowercase) because, for me, these are actually APR I/O functions. But it occurs to me that we could provide adapters to existing Iostreams Source and Sink objects, using the Iostreams conventions for nonblocking I/O. One need only arrange to poll the adapters periodically. It would also be possible to implement a Queue based on an actual OS pipe. Does this avenue seem worth pursuing? I'm going to build something like this anyway, but (a) I hope you can help me improve the abstractions and (b) it may be worth trying to Boostify the code for possible contribution. [0] http://www.boost.org/doc/libs/1_48_0/libs/iostreams/doc/guide/asynchronous.… [1] http://lists.boost.org/Archives/boost/2003/08/51289.php [2] http://groups.yahoo.com/group/boost/files/pipes.zip [3] http://lists.boost.org/Archives/boost/2003/08/51310.php [4] http://lists.boost.org/Archives/boost/2003/08/51405.php [5] http://lists.boost.org/Archives/boost/2003/08/51448.php [6] http://www.amqp.org/

1 0

[Container] deque emplace() requirements
by Szymon Gatner 04 Jan '12

04 Jan '12

Hi, question: why container::deque<T>::emplace_back() requires T to be copyable? Shouldn't it just be using placement new operator with passed c-tor params? Unless growing of deque causes elements to be copied which is not what I want at all (hence deque and not vector). Cheers, Simon -- Szymon Gatner The Lordz Games Studio www.thelordzgamesstudio.com

3 5

boost vector including non standard objects
by Sabine B 04 Jan '12

04 Jan '12

Hello! I would like to create a vector in shared memory which includes objects of a class Listener*. Listener* was created by my own and is therefore no standard. When I try the following, using the boost interprocess library: typedef boost::interprocess::allocator<Listener*, managed_shared_memory::segment_manager> ShmemAllocator; typedef boost::interprocess::vector<Listener*, ShmemAllocator> MyVector; MyVector *ListenerVector; managed_shared_memory segment(create_only, "MySharedMemory", 65536); const ShmemAllocator alloc_inst(segment.get_segment_manager()); ListenerVector = segment.construct<MyVector>("ListenerVector")(alloc_inst); ListenerVector->push_back((Listener*)listener); The code works perfectly when I use a vector with integers, but it crashes when I use a vector with objects of my own class. I wanted to ask if it is possible to create a boost vector holding a non standard object and if so what I do wrong. Thank you very much for your help! Best regards, Sabine

2 1

[phoenix] ambiguity between std::begin/end and phoenix::begin/end due to ADL
by Nathan Ridge 04 Jan '12

04 Jan '12

Hello, I am running into a problem where an unqualified call to begin() on a range type whose template parameters include a Boost.Phoenix type (for examle filtered_range<Pred, R> where Pred is a phoenix function) is ambiguous because, in addition to the intended std::begin, phoenix::begin is being found by ADL. What can be done about this? There exists precedent for placing boost::xxx::begin/end functions in ADL barrier namespaces because C++11 encourages unqualified calls to begin/end (specifically, this was done for boost::range::begin/end). Should the same thing be done for Phoenix? Here is a minimal example that reproduces the problem: #include <iterator> #include <boost/range/adaptor/filtered.hpp> #include <boost/phoenix/phoenix.hpp> using std::begin; int main() { using boost::phoenix::arg_names::arg1; using boost::adaptors::filtered; int v[5]; const auto& f = v | filtered(arg1 < 0); begin(f); } And here are the errors, with GCC 4.7: test.cpp: In function 'int main()': test.cpp:15:12: error: call of overloaded 'begin( const boost::range_detail::filtered_range< boost::phoenix::actor< boost::proto::exprns_::basic_expr< boost::proto::tagns_::tag::less , boost::proto::argsns_::list2< boost::phoenix::actor< boost::proto::exprns_::basic_expr< boost::proto::tagns_::tag::terminal , boost::proto::argsns_::term< boost::phoenix::argument<1> >, 0l > >, boost::phoenix::actor< boost::proto::exprns_::basic_expr< boost::proto::tagns_::tag::terminal , boost::proto::argsns_::term<int>, 0l > > >, 2l > >, int [5] > & )' is ambiguous test.cpp:15:12: candidates are: In file included from string:53:0, from c++/4.7.0/bits/locale_classes.h:42, from ios_base.h:43, [STL Decryptor: Suppressed 3 more STL standard header messages] from test.cpp:1: c++/4.7.0/bits/range_access.h:58:5: decltype ( __cont.begin() ) begin( const boost::range_detail::filtered_range< boost::phoenix::actor< boost::proto::exprns_::basic_expr< boost::proto::tagns_::tag::less, boost::proto::argsns_ ::list2< boost::phoenix::actor< boost::proto::exprns_::basic_expr< boost::proto::tagns_::tag::terminal, boost ::proto::argsns_::term< boost::phoenix::argument<1> >, 0l> >, boost ::phoenix::actor< boost::proto::exprns_::basic_expr< boost::proto::tagns_::tag::terminal, boost ::proto::argsns_::term<int>, 0l> > >, 2l> >, int [5]>; decltype (__cont.begin()) = boost::filter_iterator< boost::phoenix::actor< boost::proto::exprns_::basic_expr< boost::proto::tagns_::tag::less, boost::proto::argsns_ ::list2< boost::phoenix::actor< boost::proto::exprns_::basic_expr< boost::proto::tagns_::tag::terminal, boost ::proto::argsns_::term< boost::phoenix::argument<1> >, 0l> >, boost ::phoenix::actor< boost::proto::exprns_::basic_expr< boost::proto::tagns_::tag::terminal, boost ::proto::argsns_::term<int>, 0l> > >, 2l> >, int *> &) c++/4.7.0/bits/range_access.h:48:5: decltype ( __cont.begin() ) begin( const boost::range_detail::filtered_range< boost::phoenix::actor< boost::proto::exprns_::basic_expr< boost::proto::tagns_::tag::less, boost::proto::argsns_ ::list2< boost::phoenix::actor< boost::proto::exprns_::basic_expr< boost::proto::tagns_::tag::terminal, boost ::proto::argsns_::term< boost::phoenix::argument<1> >, 0l> >, boost ::phoenix::actor< boost::proto::exprns_::basic_expr< boost::proto::tagns_::tag::terminal, boost ::proto::argsns_::term<int>, 0l> > >, 2l> >, int [5]>; decltype (__cont.begin()) = boost::filter_iterator< boost::phoenix::actor< boost::proto::exprns_::basic_expr< boost::proto::tagns_::tag::less, boost::proto::argsns_ ::list2< boost::phoenix::actor< boost::proto::exprns_::basic_expr< boost::proto::tagns_::tag::terminal, boost ::proto::argsns_::term< boost::phoenix::argument<1> >, 0l> >, boost ::phoenix::actor< boost::proto::exprns_::basic_expr< boost::proto::tagns_::tag::terminal, boost ::proto::argsns_::term<int>, 0l> > >, 2l> >, int *> &) In file included from boost/boost/phoenix/stl/container.hpp:11:0, from boost/boost/phoenix/stl.hpp:16, from boost/boost/phoenix/phoenix.hpp:18, from test.cpp:4: boost/boost/phoenix/stl/container/container.hpp:794:1: const boost ::phoenix::detail::expression::function_eval< boost::phoenix::stl::begin, boost::range_detail::filtered_range< boost::phoenix::actor< boost::proto::exprns_::basic_expr< boost::proto::tagns_::tag::less, boost::proto::argsns_ ::list2< boost::phoenix::actor< boost::proto::exprns_::basic_expr< boost::proto::tagns_::tag::terminal, boost ::proto::argsns_::term< boost::phoenix::argument<1> >, 0l> >, boost ::phoenix::actor< boost::proto::exprns_::basic_expr< boost::proto::tagns_::tag::terminal, boost ::proto::argsns_::term<int>, 0l> > >, 2l> >, int [5]>; boost::phoenix::detail::expression::function_eval< boost::phoenix::stl::begin, A0>::type = boost::phoenix::actor< boost::proto::exprns_::basic_expr< boost::phoenix::detail::tag::function_eval, boost::proto ::argsns_::list2< boost::proto::exprns_::basic_expr< boost::proto::tagns_::tag::terminal, boost::proto ::argsns_::term<boost::phoenix::stl::begin>, 0l>, boost ::proto::exprns_::basic_expr< boost::proto::tagns_::tag::terminal, boost::proto ::argsns_::term< boost::range_detail::filtered_range< boost::phoenix::actor< boost::proto::exprns_::basic_expr< boost::proto::tagns_::tag::less, boost ::proto::argsns_::list2< boost::phoenix::actor< boost::proto::exprns_ ::basic_expr< boost::proto::tagns_::tag ::terminal, boost::proto ::argsns_::term< boost::phoenix ::argument<1> >, 0l> >, boost::phoenix::actor< boost::proto::exprns_ ::basic_expr< boost::proto::tagns_::tag ::terminal, boost::proto ::argsns_::term<int>, 0l> > >, 2l> >, int [5]> >, 0l> >, 2l> > >::type boost::phoenix::begin( const boost::range_detail::filtered_range< boost::phoenix::actor< boost::proto::exprns_::basic_expr< boost::proto::tagns_::tag::less, boost::proto::argsns_ ::list2< boost::phoenix::actor< boost::proto::exprns_::basic_expr< boost::proto::tagns_::tag::terminal, boost ::proto::argsns_::term< boost::phoenix::argument<1> >, 0l> >, boost ::phoenix::actor< boost::proto::exprns_::basic_expr< boost::proto::tagns_::tag::terminal, boost ::proto::argsns_::term<int>, 0l> > >, 2l> >, int [5]>; boost::phoenix::detail::expression::function_eval< boost::phoenix::stl::begin, A0>::type = boost::phoenix::actor< boost::proto::exprns_::basic_expr< boost::phoenix::detail::tag::function_eval, boost::proto ::argsns_::list2< boost::proto::exprns_::basic_expr< boost::proto::tagns_::tag::terminal, boost::proto ::argsns_::term<boost::phoenix::stl::begin>, 0l>, boost ::proto::exprns_::basic_expr< boost::proto::tagns_::tag::terminal, boost::proto ::argsns_::term< boost::range_detail::filtered_range< boost::phoenix::actor< boost::proto::exprns_::basic_expr< boost::proto::tagns_::tag::less, boost ::proto::argsns_::list2< boost::phoenix::actor< boost::proto::exprns_ ::basic_expr< boost::proto::tagns_::tag ::terminal, boost::proto ::argsns_::term< boost::phoenix ::argument<1> >, 0l> >, boost::phoenix::actor< boost::proto::exprns_ ::basic_expr< boost::proto::tagns_::tag ::terminal, boost::proto ::argsns_::term<int>, 0l> > >, 2l> >, int [5]> >, 0l> >, 2l> > &) Thanks, Nate

3 2

[Build] getting Started - library naming.
by Robert Jones 04 Jan '12

04 Jan '12

Morning All, So, I've followed the Getting Started guide pretty faithfully I think; specifically on Fedora 13, Gcc 4.4.5 I've used... $ cd path/to/boost_1_48_0 $ ./bootstrap.sh --prefix=path/to/installation/prefix --show-libraries $ ./b2 install --prefix=path/to/installation/prefix That all seems to have worked Ok, and I have source and libraries in the appropriate prefix. Then I come to section 6, and in particular section 6.1, which talks about library naming. My libraries don't appear to be named according to this structure. Taking, for example, Boost.Regex I have libboost_regex.a libboost_regex.so libboost_regex.so.1.48.0 with no mention of toolsets or ABI tags. Does all the naming stuff only apply if you haven't used the host's default/native toolset? Thx, - Rob.

1 1

[stringalgo] Splitting based on sequence of elements
by Edward Diener 04 Jan '12

04 Jan '12

Is it possible to use the boost::algorithm::split function to split a sequence based on a subsequence match rather than on individual elements of the sequence ?

1 1