- Boost-users - lists.boost.org

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

Using BGL with mutexes
by Kelvin Chung 03 Jan '12

03 Jan '12

I wish to use multiple threads to build a graph, and to topologically sort it. It would appear that the easiest way is to construct a graph adapter like so: template <class T> class Graph { boost::adjacency_list<boost::vecS, boost::vecS, boost::directedS, T> internalGraph; boost::shared_mutex mutex; // read-write lock enabler // Add other suitable adapter methods here }; I'm wondering whether this is the better idea over using the PBGL, since it seems that the PBGL is more complicated. My specific scenario is that T is a functor type whose operation is expensive, and may depend on calling a similar functor (determining the dependent functors needed is cheap); thus, I'm trying to obtain all of the functors and then ordering them so that all dependent functors are always evaluated before the functor itself is evaluated. Thus, each thread would do something like this: Graph<T>& dependencyGraph = ...; // shared graph std::deque<T> tasks; // initially populated list while (!tasks.empty()) { T task = tasks.front(); tasks.pop_front(); std::list<T> dependents = task.getDependents(); for (std::list<T>::const_iterator it = dependents.begin(); it != dependents.end(); ++it) { dependencyGraph.addEdge(task, *it); // Creates a new vertex if either vertex does not exist tasks.push_back(*it); } } No vertices or edges are ever removed from the graph, unless the whole graph is being destroyed. Would bundling a mutex and a graph be a good idea for this purpose?

2 3

help with boost/numeric/operators.hpp
by Robert Ramey 03 Jan '12

03 Jan '12

I'm haveing some problems figuring out how to use boost/numeric/operators library. OK - I understand how to use template<class T> struct my_type : boost::numeric::operators<T> { T & operator+=(T & rhs); // automatically generate operator+, etc // ... }; so that one can use my_type<int> x, y, z; z = x + y; // etc.. There is a simple example like this in the documentation. So far so good. Now given: int & operator+=(int & lhs, my_type<int>); I want to use operators<T, U> to generate int operator+(int & lhs, my_type<int>); // etc. After studying the documenation, examples and code, the best I can come up with is: template<class T, class U> class helper : public boost::operators<T, U>{ }; T operator+(T & lhs, U & rhs){ helper<T, U>::operator+(lhs, rhs); // automatically generated + operator } // other non member operators forwarding to helper Am I doing this corrrectly? How did the authors of operators.hpp intend the two argument versions to be used? Robert Ramey

2 1

[C++ Now! 2012] Reminder: Call for Submissions, deadline is January 10th, 2012
by Hartmut Kaiser 03 Jan '12

03 Jan '12

INAUGURAL C++ NOW! CONFERENCE 2012 Aspen CO, USA, May 14-18, 2012, www.cppnow.org CALL FOR SUBMISSIONS We invite you to submit session proposals to the Inaugural C++ Now! Conference: C++Now! 2012 (Aspen CO, USA, May 14 - 18, 2012). Based on the successful traditions of 5 years of BoostCon, which was the main face-to-face event for all things C++ and Boost (www.boost.org) C++Now! 2012 will present leading speakers from the whole C++ community. The conference name is changing to C++ Now! to reflect the current value of the language, the focus on its new state (from the new Standard), and the need to continually look to the future so the language remains useful to the C++ community. The focus of this conference will be the new C++11 language Standard and as usual Boost: what's new in C++, its Standard library, and in the Boost libraries, how to write and maintain them, how to evangelize or to deploy Boost within your organization. The new C++ Standard, but also the infrastructure and process of Boost, its vision and mission - no matter what you are interested in, it all comes together in the C++Now! sessions. Meet the colleagues, and feel the inspiration to support your work with C++ and Boost for the next year. The C++ Now! Conference is dedicated to discussion and education about C++, an open and free language and standard. Our Conference will focus on discussion and education about open source software usage and developments in the C++ developer and user community. To reflect the breadth of the C++ and Boost communities, the conference includes sessions aimed at three constituencies: C++ and Boost end-users, hard-core Boost library and tool developers, and researchers pushing the boundaries of computation. The program fosters interaction and engagement within and across those groups, with an emphasis on hands-on, participatory sessions. As a multi-paradigm language, C++ is a melting pot where the most compelling ideas from other programming communities are blended in powerful ways. Historically, some of the most popular sessions at C++Now! have highlighted these concepts, from DSLs to functional programming to transactional memory and more. Bring your C#, Python, Ruby or Haskell influences to bear in an environment that will broaden their exposure. IMPORTANT DATES New proposal submissions due: January 10th, 2012. Proposals decisions sent (tentative program): February 17th, 2012. Fully scheduled program available: February 25th, 2012. Session materials due: April 15th, 2012. BEST PRESENTATION AWARDS We know how much effort it takes to prepare talks for our conference. For this reason we will award the best presentations in the following categories: Best Presentation, Best Short Presentation, Best Tutorial, and Best Workshop. The awards will be given based on the audience's voting. Each award will include the author's name listed on the cover of the C++Now! website for that year and a plaque containing all the C++Now! conference information. SESSION TOPICS Topics of interest include, but are not restricted to, the following: * C++11 and how it changes life for users and library writers * General tutorial sessions on C++11, the C++11 Standardslibrary, and one or more Boost libraries * In-depth sessions on using specific Boost libraries * Case studies on using Boost * Experts panels * Advanced sessions on implementation techniques used within Boost libraries * Development workshops to extend or enhance existing Boost libraries * Workshops on design process * Infrastructure workshops such as Build tools, Website, Testing * Concepts and Generic Programming * Hardware and infrastructure presentations focused on how libraries can make better use of the technology * Software development tools and their application to C++ and or Boost * Other topics likely to be of great interest to Boost users and developers Interactive and collaborative sessions are encouraged, as this is the style of learning and participation that has proven most successful at such events. Sessions can be tutorial based, with an emphasis on interaction and participant involvement, or workshop based, whether hands-on programming or paper-based, discussion-driven collaborative work. SESSION FORMATS Presentations Presentations focus on a practitioner's ideas and experience with anything relevant to C++11, Boost and users. Panels Panels feature three or four people presenting their ideas and experiences relating to C++11 and Boost's relevant, controversial, emerging, or unresolved issues. Panels may be conducted in several ways, such as comparative, analytic, or historic. Tutorials Tutorials are sessions at which instructors teach conference participants specific skills relevant to C++11 and Boost. Workshops Workshops provide an active arena for advancements In Boost-relevant topics. Workshops provide the opportunity for experienced practitioners to develop new ideas about a topic of common interest and experience. Author's Corner These were introduced at BoostCon 2008, and were a great Presentations success They are short (30 minute) sessions, focusing on tips on usage and design. In addition, we're looking to uncover the hidden design gems in Boost libraries. Tool Vendors We actively encourage tool vendors and ISP's to submit presentations proposals for a special Tool Vendors Session Track aimed at products related to Boost and C++ (compilers, libraries, tools, etc.). Other formats may also be of interest. Don't hold back a proposal just because it doesn't fit into a pigeonhole. SUBMITTING A PROPOSAL Standard Sessions are 60 minutes. You may submit a proposal for fractions or multiples of 90-minutes. Fractional proposals will be grouped into 60 minute sessions covering related topics. Longer sessions, such as tutorials and classes, will be assigned 90 minute, three hour (i.e. half day), or six hour (i.e. full day) time slots. Please include: * The working title. * Type of session: presentation, panel, tutorial, workshop, authors corner, vendor track, other. * A paragraph or two describing the topic covered, suitable for the conference web site. * Proposed length: 10-20 minute short talks, 45 minutes, 90 minutes, half day, full day. * Alternate lengths, if you are willing to make adjustments: 10- 20 minute short-talks, 45 minutes, 90 minutes, half-day, full day. * Audience: users, developers, both. * Level: basic, intermediate, advanced. * A biography, suitable for the conference web site. * Your contact information (will not be made public). SUBMISSION DETAILS All submissions should be made through the EasyChair conference management system: http://www.easychair.org/conferences/?conf=cppnow2012. If you have not already registered at EasyChair, you will need to do so in order to submit your proposal. All submissions will go through a peer review process. Authors are invited (but are not required) to submit PDF versions of full papers of up to 10 pages in ACM conference proceedings format (see http://www.acm.org/sigs/publications/proceedings-templates) The full papers are not required unless you want them published in the proceedings. All accepted proposals will be made available in the Association for Computing Machinery (ACM) Digital Library (approval pending). Best papers, after further reviews, will be considered to be book chapters or journal articles in a renowned journal. The session materials go on the C++Now! website and will be available to attendees. For general information on the C++Now! 2012 paper submission or the scope of technical papers solicited, please refer to the conference website at www.cppnow.org. For any other questions about the submission process or paper format, please contact the Program Committee at cppnow2012(a)easychair.com. If you have any technical problems with EasyChair, please contact EasyChair for help. Note: Presenters must agree to grant a non-exclusive perpetual license to publish submitted materials, either electronically or in print, in any media related to C++ Now!. Hartmut Kaiser, email: hartmut.kaiser(a)gmail.com (Program Committee Chair) Dave Abrahams, email: dave(a)boostpro.com (Conference Chair) On behalf of the conference organizers

1 0

property type trait
by Amir Yazdanbakhsh 02 Jan '12

02 Jan '12

Hi, I new to boost graph library. The thing that I have in my mind is to find the type of property that passed to a function and execute something based on that. I implemented two bundled properties each for vertex and edge. I want to implement a general function, say print a property, if the passed property is a vertex property the function should iterate over vertices and print out them and if it's edge property it should iterate over edges. Is it any way to do that? Thanks Best Regards, A. Yazdanbakhsh >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PhD. Student School of Electrical and Computer Engineering University of Wisconsin-Madison E-mail: yazdanbakhsh(a)wisc.edu <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

2 1

[multi_array]bug in strides calculation with some storage orderings
by Larry Evans 02 Jan '12

02 Jan '12

If I understand correctly, the multi_array storage order determines which strides are larger than others. In short: if( order[I]>order[I+1]) then stride[I]>stride[I+1] However, the output from the attached code shows that this is not always true. In the attached code, the mono_tonic_print function tests the conditions and prints out the results. The following partial output: :count=3 :permut_v={ 1, 2, 0} :permut_i={ 2, 0, 1} :ma.ordering(*)==permut_v=1 :multi_array_strides:strides()={ 12, 1, 3} :monotonically increasing={ 0, 0} :is_mono_tonic=0 :expected_strides:{ 4, 8, 1} :monotonically increasing={ 1, 1} :is_mono_tonic=1 :count=4 :permut_v={ 2, 0, 1} :permut_i={ 1, 2, 0} :ma.ordering(*)==permut_v=1 :multi_array_strides:strides()={ 4, 8, 1} :monotonically increasing={ 0, 0} :is_mono_tonic=0 :expected_strides:{ 12, 1, 3} :monotonically increasing={ 1, 1} :is_mono_tonic=1 shows that the multi_array code fails this monotonic constrait when the order is one of: :permut_v={ 1, 2, 0} :permut_v={ 2, 0, 1} The code also shows a possible solution. This possible solution uses the inverse permutation instead of the original permutation to calculate the strides, as shown in the expected_strides function. There's also a macro, NO_INVERT_PERMUT, which, if defined, has expected_strides reproduce the multi_array strides, which may help narrow down the source of the error in multi_array's stride calculation. The output is also attached. If macro INDENT_OUTPUT is defined, the code requires: http://svn.boost.org/svn/boost/sandbox/variadic_templates/boost/iostreams/f… http://svn.boost.org/svn/boost/sandbox/variadic_templates/boost/iostreams/u… http://svn.boost.org/svn/boost/sandbox/variadic_templates/boost/utility/tra… http://svn.boost.org/svn/boost/sandbox/variadic_templates/boost/utility/ind… If you don't want to download those, then the output will not be nicely indented as shown in the attached output. HTH. -regards, Larry

1 1

iterate over vertices with special propoerty
by Amir Yazdanbakhsh 01 Jan '12

01 Jan '12

Hi, I want to write an iterator which returns the vertices with a special property. For example have an functions which takes a graph and a string and returns an iterator over all the vertices that have this string as their name. Thanks Best Regards, A. Yazdanbakhsh >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PhD. Student School of Electrical and Computer Engineering University of Wisconsin-Madison E-mail: yazdanbakhsh(a)wisc.edu <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

2 1