June 2013 - Boost - lists.preview.boost.org

Re: [boost] [Boost-users] Herb Sutter on C++ Standardization and Visual Studio
by Nathan Ridge 30 Jun '13

30 Jun '13

> Herb Sutter on C++ Standardization at Microsoft. > > http://channel9.msdn.com/Events/Build/2013/2-306 > > SGL Pretty good news, IMO. In addition to the C++11 and C++14 plans, Herb announced that Microsoft would complete the holes in their C++98 standard support by finally fixing their preprocessor and implementing correct two-phase name lookup (39:18 in the video). Perhaps the last discussion about these things [1] helped to tip the scale. In any case, I'm glad to hear it. Regards, Nate [1] http://boost.2283326.n4.nabble.com/C-announcements-coming-tomorrow-td463790…

1 0

boost::thread dependency on boost::chrono (windows implementation)
by Christian Hägele 28 Jun '13

28 Jun '13

Hello, as boost::thread now depends on boost::chrono I have the following questions: In boost::chrono on windows the the steady_clock is implemented via QueryPerformanceCounter. This may lead to wrong results because on some systems QueryPerformanceCounter gives different results on different processors. In our software we encountered theses problems regularly on some customers machines and thus stopped using QueryPerformanceCounter without additional checking. The problem I'm talking about is described as a TODO in boost/chrono/system_clocks.hpp My questions is if functions like boost::thread::timed_join or boost::mutex::timed_wait may have similar problems on hardware where QueryPerformanceCounter gives wrong result. Is there a way (like a preprocessor macro) to have boost::thread use the old implementation independent from boost::chrono? Regards, Christian

8 10

[1.54.0] Release candidates available
by Marshall Clow 28 Jun '13

28 Jun '13

Release candidate files for 1.54.0 are available at http://boost.cowic.de/rc/ As always, the release managers would appreciate it if you download the candidate of your choice and give building it a try. Please report both success and failure, and anything else that is noteworthy. This helps ensure the candidates build OK before we push them out to SourceForge. The files (and associated md5s) are: efbfbff5a85a9330951f243d0a46e4b9 *boost_1_54_0_rc1.tar.gz 15cb8c0803064faef0c4ddf5bc5ca279 *boost_1_54_0_rc1.tar.bz2 78a35834c45220a6164310e280abe675 *boost_1_54_0_rc1.zip 89e734ffd2afe0982b2d9fc21d033dba *boost_1_54_0_rc1.7z Thanks! -- The release managers

6 9

Re: [boost] Could the custom allocator for flyweight hashed_factory be the boost::interprocess::allocator?
by JOAQUIN M. LOPEZ MUÑOZ 28 Jun '13

28 Jun '13

H Jin, ________________________________________ De: Boost [boost-bounces(a)lists.boost.org] en nombre de Jin Chen [chenjin92(a)gmail.com] Enviado el: lunes, 24 de junio de 2013 19:56 Para: Boost(a)lists.boost.org Asunto: [boost] Could the custom allocator for flyweight hashed_factory be the boost::interprocess::allocator? > I want to use boost::flyweight to do the dedupilcation of > boost::interprocess::basic_string object. I wrote a small test program for > that. In my program: > The flyweight works fine with the interprocess::basic_string which uses the > interprocess::allocator only with the default hashed_factory. The default > hashed_factory is ideal except that it uses std::allocator instead of > interprocess::allocator. I followed the > http://www.boost.org/doc/libs/1_53_0/libs/flyweight/doc/tutorial/configurat… > specifier > of a custom hash_factory which can change its allocator to the interprocess > one, but then got insanely long compiler error that is super hard to > decode... This is a very interesting exercise! There are several problems with your solution: * First of all, hashed_factory, as Jonathan points out, assumes the allocator is default constructible. As boost::interprocess::allocator needs a segment manager at construction time, you can overcome this by writing a custom interprocess allocator that takes that info statically, i.e., from a type that returns the segment manager: struct memory_dat_segment_manager { typedef ipc::managed_mapped_file::segment_manager type; static type* get() { static ipc::managed_mapped_file* segment= new ipc::managed_mapped_file(ipc::open_or_create,"memory.dat",409600); return segment->get_segment_manager(); } }; template<typename T,typename SegmentManager> struct segment_allocator: boost::interprocess::allocator<T,typename SegmentManager::type> { typedef boost::interprocess::allocator<T,typename SegmentManager::type> super; segment_allocator():super(SegmentManager::get()){} template<typename T2> segment_allocator(const segment_allocator<T2,SegmentManager>& x):super(x){} super& base(){return *this;} template<typename T2> struct rebind{ typedef segment_allocator<T2,SegmentManager> other; }; friend void swap(segment_allocator& x,segment_allocator& y) { swap(x.base(),y.base()); } }; Note that segment_allocator is default constructible: the segment is created on the first call to memory_dat_segment_manager. * Now, the holder class (www.boost.org/libs/flyweight/doc/tutorial/configuration.html#holders ) needs also to place its content in shared memory. As none of the holders provided by Boost.Flyweight does this, we must define our own: template<typename SegmentManager,typename C> struct segment_holder_class:boost::flyweights::holder_marker { static C& get() { static C* pc=SegmentManager::get()-> find_or_construct<C>(typeid(segment_holder_class).name())(); return *pc; } }; template<typename SegmentManager> struct segment_holder:boost::flyweights::holder_marker { template<typename C> struct apply { typedef segment_holder_class<SegmentManager,C> type; }; }; Again, the holder uses a SegmentManager class to get access to the segment manager * Finally, you need an interprocess locking policy (www.boost.org/libs/flyweight/doc/tutorial/configuration.html#locking ), and again this needs to be custom-defined (note that, in order for labeled_recursive_mutex to be default constructible, we get the info needed at construction time (the name of the mutex) from a Name class much in the same way we did with SegmentManager before for the allocator and holder): template<typename Name> struct labeled_recursive_mutex { typedef boost::interprocess::named_recursive_mutex mutex_type; operator mutex_type&() { static mutex_type mutex( boost::interprocess::open_or_create,Name::get()); return mutex; } }; template<typename Name> struct labeled_locking:boost::flyweights::locking_marker { typedef labeled_recursive_mutex<Name> mutex_type; typedef boost::interprocess::scoped_lock< typename labeled_recursive_mutex<Name>::mutex_type> lock_type; }; There's a technical issue here (if you don't get the following explanation you might as well skip it): As the mutex used by Boost.Flyweight is created by the holder class and we are using a shared-memory custom holder, it turns out labeled_recursive_mutex is thus created in shared memory. But boost::interprocess::named_recursive_mutex cannot be created in shared memory: we solve the problem with operator mutex_type&(), which actually creates the real mutex as a static variable in regular memory. And we're done. Find attached a small complete program showing how to put all the pieces together. Best, Joaquín M López Muñoz Telefónica Digital ________________________________ Este mensaje se dirige exclusivamente a su destinatario. Puede consultar nuestra política de envío y recepción de correo electrónico en el enlace situado más abajo. This message is intended exclusively for its addressee. We only send and receive email on the basis of the terms set out at: http://www.tid.es/ES/PAGINAS/disclaimer.aspx

2 1

[Spirit] Retrieve informations out of tokens
by ... ... 27 Jun '13

27 Jun '13

Hi, I want to create a c++ syntax analysor (for creating auto-completion tools), and to help me, I want to use the boost.spirit library. In order to learn the basics of spirit, I executed this exercise. It is now working but I want to display the tokens' characters instead of counting tokens. The problem is I don't know the properties of the argument passed to my functor (the variable "t" in the code below). What is the type of this variable and what are the public method/attributes we can use on ? This is the code of my functor : struct counter{ counter() : j(0) {j = new int();} counter(const counter &model) : j(model.j) {} ~counter() {delete int;} template <typename Token> bool operator()(Token const& t){//I want to know the type of this variable t ++i; ++(*j); std::ostringstream oss; oss << "global : " << i << " membre : " << *j;//typeid(t).name(); printf("%s\n", oss.str().c_str()); return true; } int* j;}; The variable t will be relay to my functor by the following tokenize function : counter* foncteur = new counter();lex::tokenize(first, last, word_count_functor, *foncteur); I still have other questions : I read a consistent part of the documentation but I have not been able to define the type of regex used by boost.spirit. Which type is it ? What is the more appropriate function to use to analyse c++ synthax : tokenize or tokenize _and_parse ? You seems to describe tokenize_and_parse as a more powerful tool, but is it possible to define all the syntax of c++ using a parser ? Could I find an example of c++ syntax analysor using boost.spirit ? Any help would be appreciate,Cordialy,Guillaume Bersac237bis rue de Pessac33000 Bordeaux06.65.30.89.43

6 11

Re: [boost] [thread] synchronized_value: value and move semantics
by Ben Pope 27 Jun '13

27 Jun '13

On 21/02/13 02:02, Vicente J. Botet Escriba wrote: > > Hi, > > boost::synchronized_value (not released yet [1][2][3]) is based on [4]. > See below part of this paper adapted to the Boost.Thread interface. > > Currently boost::synchronized_value is in addition Copyable and > Swappable. I was wondering if it is worth adding value and move > semantics to synchronized_value. Making it EqualityComparable, > LessThanComparable and Movable if the underlying type satisfy these > requirements will allow to store them on a Boost.Container/C++11 container. > > Do you see something completely wrong with this addition? > Has some of you had a need for this? Could you share the context? Sorry, I'm a bit late to the party and not really answering the question. I can see the usefulness of synchronized_value for C++03, but not in C++11. It's just too easy to forget to call the synchronise() member: boost::synchronized_value<std::queue<int>> synch_queue; if(!synch_queue->empty()) synch_queue->pop(); when was was meant was (excuse use of auto, I've become lazy): boost::synchronized_value<std::queue<int>> synch_queue; { auto lock = synch_queue.synchronize(); if(!synch_queue->empty()) synch_queue->pop(); } This is neither safe or efficient (2 lock/unlocks). I think this should just not exist in C++11 and instead be replaced by something like monitor<T> described by Herb Sutter [1]: monitor<std::queue<int>> synch_queue; queue([](std::queue& q) { if(!q.empty()) q.pop(); } Now we're safe and efficient (one lock/unlock per block). Since movability is a C++11 thing, can we have something harder to use incorrectly than synchronized_value for C++11? I guess my point is rather than C++11ifying synchronized_value, can we have monitor instead? Thoughts? Ben [1] http://channel9.msdn.com/Shows/Going+Deep/C-and-Beyond-2012-Herb-Sutter-Con… From 0:40:00

4 4

Interest in an 'either' library?
by David Sankel 26 Jun '13

26 Jun '13

**semantics**: template< typename left_type, typename right_type> struct either { // postcondition, is_left() either( left_type ); // postcondition, is_right() either( right_type ); bool is_left() const; bool is_right() const; // postcondition, is_left() either & operator=( left_type ); // postcondition, is_right() either & operator=( right_type ); // precondition, is_left() left_type left(); // precondition, is_right() right_type right(); private: }; **uses**: **Use 1**: Can be used as an alternative to exceptions or the (error codes+set reference idiom): either<error_code, file_id> load_file(...); vs. error_code load_file( file_id &, ... ); or // throws std::exception file_id load_file(...); **Use 2**: A lightweight alternative to boost::variant when only 2 components are required (either relates to variant in a similar way that pair relates to tuple ). variant<A,B> eitherAOrB; if( A * aPtr = boost::get<A>( &eitherAOrB ) ) std::cout << "A: " << *aPtr; else std::cout << "B: " << boost::get<B>( eitherAOrB ); vs. either<A,B> eitherAOrB; if( eitherAOrB.is_left() ) std::cout << "A: " << eitherAOrB.left(); else std::cout << "B: " << eitherAOrB.right(); --David Sankel

12 41

[1.54.0] Release notes
by Daniel James 26 Jun '13

26 Jun '13

Hello everyone, It's time to send me your release notes, or if you're feeling enthusiastic, you can add them yourself at: http://svn.boost.org/svn/boost/website/public_html/live/feed/history/ You see the notes so far at: http://www.boost.org/users/history/version_1_54_0.html And while I'm at it, I've also added the new libraries to: http://www.boost.org/doc/libs/1_54_0/ thank you, Daniel

11 16

[1.54.0][range] add release note
by Akira Takahashi 26 Jun '13

26 Jun '13

Hi, I think missing Boost.Range release note for 1.54.0. https://svn.boost.org/svn/boost/website/public_html/live/feed/history/boost… Please see changeset: https://svn.boost.org/trac/boost/changeset/84823 Changeset 84823 Timestamp:06/17/13 22:22:07 Author:nathanridge Message:[range] Merge Boost.Range bug fixes to release branch (fixes #6944; fixes #7407; fixes #7408; fixes #7731; fixes #7827; fixes #8338; fixes #8453). Thanks, Akira

2 1

[Boost][asio]How add a timeout to asio connection?
by Renato Forti 25 Jun '13

25 Jun '13

Hi All, I have one problem, I have this class to connect to my server app: class session { public: static void init( const std::string& host, const std::string& port, hades::archive::archive& iarch, hades::archive::archive& oarch) { boost::asio::io_service io_service; client client(io_service, host, port, iarch, oarch); io_service.run(); } }; The problem is : if my server is down, my client (session) will block on io_service.run(); the client nerves end. Then I try to add a time out: class client { public: /// Constructor starts the asynchronous connect operation. client(boost::asio::io_service& io_service, const std::string& host, const std::string& port, // service hades::archive::archive& iarch, hades::archive::archive& oarch) : connection_(io_service) , deadline_(io_service) , iarch_(&iarch) , oarch_(&oarch) { deadline_.async_wait(boost::bind(&client::check_deadline, this)); deadline_.expires_from_now(boost::posix_time::seconds(30)); // Resolve the host name into an IP address. boost::asio::ip::tcp::resolver resolver(io_service); boost::asio::ip::tcp::resolver::query query(host, port); boost::asio::ip::tcp::resolver::iterator endpoint_iterator = resolver.resolve(query); // Start an asynchronous connect operation. boost::asio::async_connect(connection_.socket(), endpoint_iterator, boost::bind(&client::handle_connect, this, boost::asio::placeholders::error)); } /// Handle completion of a connect operation. void handle_connect(const boost::system::error_code& e) { if (!e) { // Successfully established connection. Start operation to read the list // of stocks. The connection::async_read() function will automatically // decode the data that is read from the underlying socket. connection_.async_read(*oarch_, boost::bind(&client::handle_read, this, boost::asio::placeholders::error)); connection_.async_write(*iarch_, boost::bind(&client::handle_write, this, boost::asio::placeholders::error)) ; } else { // An error occurred. throw sync_client_exception(e.message()); } } // Handle completion of a write operation. void handle_write(const boost::system::error_code& e) { } // Handle completion of a read operation. void handle_read(const boost::system::error_code& e) { } void check_deadline() { // Check whether the deadline has passed. We compare the deadline against // the current time since a new asynchronous operation may have moved the // deadline before this actor had a chance to run. if (deadline_.expires_at() <= deadline_timer::traits_type::now()) { // The deadline has passed. The socket is closed so that any outstanding // asynchronous operations are cancelled. connection_.socket().close(); // There is no longer an active deadline. The expiry is set to positive // infinity so that the actor takes no action until a new deadline is set. deadline_.expires_at(boost::posix_time::pos_infin); throw sync_client_exception("Time out : deadline on client!"); } // Put the actor back to sleep. deadline_.async_wait(boost::bind(&client::check_deadline, this)); } private: // The connection to the server. dsafe::sync::connection connection_; // The data received from the server. hades::archive::archive *iarch_; hades::archive::archive *oarch_; deadline_timer deadline_; }; The problem is that now the timeout expires even if the connection to the server occurs. What is wrong? My timeout should be disabled when the connection is successful! How do I get it? Only when the connection fails it should be called! Thanks for clarification

3 2