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

How to know wheter a Boost.thread has ended ?
by Huck finn 14 Oct '03

14 Oct '03

Hi, I need a way to find out if the threads that I created are done or not. I'm creating a somekind of thread_group that must clean the threads that have ended from the vector that keeps the threads within. void function () {} void main () { boost::thread thrd1(&function); //I'd need a function here to tell me that the thread has ended... if(thread1.IsDone()) { ... } } How can I do such a thing, any ideas? Thanks, Simon _________________________________________________________________ MSN Search, le moteur de recherche qui pense comme vous ! http://fr.ca.search.msn.com/

2 1

RE: [Boost-users] Regex++ multiline matching
by Ben Hutchings 14 Oct '03

14 Oct '03

I wrote: > John Maddock <john(a)johnmaddock.co.uk> wrote: > > > I see that Regex++ always treats ^ and $ as start and end of line > > > rather than start and end of buffer. Perl does this only if the > > > /m switch is used. Is there a simple way to switch between these > > > two interpretations when compiling a regex? > > > > No but you can use \A and \z for that purpose. > > I know that, but I want to be able to interpret user-supplied regexes > either way. Maybe I can pre-process them to substitute ^ and $, but > that seems awkward. Alternately I could have the traits object return different interpretations for them, but that would require either: - switching between two specialisations of reg_expression at run-time (resulting in code bloat) or - changing reg_expression's constructors to allow the client to pass a traits object into it rather than always using the default constructor (unusual usage of a traits class)

1 0

RE: [Boost-users] Regex++ multiline matching
by Ben Hutchings 14 Oct '03

14 Oct '03

John Maddock <john(a)johnmaddock.co.uk> wrote: > > I see that Regex++ always treats ^ and $ as start and end of line > > rather than start and end of buffer. Perl does this only if the /m > > switch is used. Is there a simple way to switch between these two > > interpretations when compiling a regex? > > No but you can use \A and \z for that purpose. I know that, but I want to be able to interpret user-supplied regexes either way. Maybe I can pre-process them to substitute ^ and $, but that seems awkward.

1 0

shared_from_this
by Dragan Milenkovic 14 Oct '03

14 Oct '03

Hello, people, I've been using enable_shared_from_this a LOT, mostly for implementing the Observer pattern (an object holds a list of weak pointers to it's observers). I wanted to know why are shared_from_this member functions public instead of being protected? Also, I've used the following expression a few times: shared_polymorphic_cast<This>(shared_from_this()) Any thoughts on putting it inside the enable_shared_from_this... shared_from_base<This>() or polymorphic_shared_from_this<This>() or such? Also, any comments on the designs I used? Better observers? Best regards, Dragan Milenkovic

2 1

Regex++ multiline matching
by Ben Hutchings 14 Oct '03

14 Oct '03

I see that Regex++ always treats ^ and $ as start and end of line rather than start and end of buffer. Perl does this only if the /m switch is used. Is there a simple way to switch between these two interpretations when compiling a regex?

2 1

boost::function compilation
by Terence Ou 14 Oct '03

14 Oct '03

Hi, I'm currently trying to use boost::function with VC++ 7.0 and I get the compilation error stating that function is not a member of boost. I've already included the header <boost/function.hpp> as well as the library path in the project settings but it just doesn't seem to be able to compile. The documentation specifies things about the preferred and portable syntax. Is there even some setting choose the desired syntax, becoz there are no hints or instructions that mention anything on it in the the documentation and I can't find anything in the source files as well. Thanks. Cheers, Terence

2 1

[BLL] bind(data_member_ptr,_1) functor won't accept temporaries as arguments
by Eelis van der Weegen 13 Oct '03

13 Oct '03

When Lambda's bind() is used to create a functor for dereferencing a stored data member pointer given an instance pointer, it seems it is not possible to pass the resulting functor a temporary instance pointer. For example: #include <boost/lambda/bind.hpp> #include <boost/lambda/lambda.hpp> struct S { int i; }; S * f (); void g (S * p) { using namespace boost::lambda; bind(&S::i, _1)(p); // ok bind(&S::i, _1)(p + 0); // not ok, "no match for call ..." bind(&S::i, _1)(f()); // not ok, "no match for call ..." } Does this restriction have a purpose? If not, is this something that needs to be (and can be) fixed? Regards, Eelis van der Weegen

2 1

enable_shared_from_this::_internal_weak_this initialization
by Cody Batt 13 Oct '03

13 Oct '03

Hello, It seems that classes which inherit from enable_shared_from_this are required to explicitly initialize _internal_weak_this. 1) Is that correct? If not, how is it initialized? 2) Is this detail mentioned anywhere in the documentation? (I couldn't find it.) Thanks, Cody

2 1

Stubbing for unit testing, what approach should I use
by Andrew Syrov 10 Oct '03

10 Oct '03

I am looking for set of techniques for isolation testing. As applications are designed with massive number of dependencies between classes and these dependencies end-up in external systems such as databases and OS, it's hard to extract function or part of class for efficient unit test. Basically I need an advice on what coding techniques should be used to allow flexible (generic?) stubbing: - function of a class may need to be tested in isolation from world (members could be global data for the purpose) - class may be tested with stubbed set functions; - data members could be stubbed, so no dependensies on classes which do not participate in test; Please advice. Andrew. _________________________________________________________________ Compare Cable, DSL or Satellite plans: As low as $29.95. https://broadband.msn.com

1 0

Enhancement to shared_pointer to support pointers to contained objects.
by Ricardo Capurro 09 Oct '03

09 Oct '03

Hello, We are really very happy and impressed with boost's smart_pointers, and we found the section "Smart Pointer Programming Techniques" (http://www.boost.org/libs/smart_ptr/sp_techniques.html) in boost smart_pointer documentation very useful, but we are having this problem: We have two classes X and Y, and each object of class X holds an object of class Y, and we need to implement a method in class X to get a shared_ptr<Y> so we can access Y instance inside X, and we need that X objects (that are too referenced by shared_ptr<X>) don't be deleted until all references to the Y object are destroyed. See the problem in this code: class Y {}; class X : public enable_shared_from_this<X> { Y y; public: shared_ptr<Y> ptr_y(); // Oops, how do we do here??? }; Our first approach was "Using a shared_ptr to hold a pointer to a statically allocated object" (http://www.boost.org/libs/smart_ptr/sp_techniques.html#static) but this doesn't work because X objects can be destroyed and we still have pointers to contained Y object, so we try a custom deletor like this: template <typename Z> class delegator_deletor { shared_ptr<Z> ptr; // Internal pointer to father X, wich contains Y public: delegator_deletor( shared_ptr<Z> const & ptrz ) : ptr( ptrz ) {} template <typename T> void operator()( T* ) { ptr.reset(); } // Null deletor, only resets pointer to father X object }; template <typename Z> delegator_deletor<Z> make_delegator_deletor( shared_ptr<Z> ptrz ) { return delegator_deletor<Z>( ptrz ); } class X : public enable_shared_from_this<X> { Y y; public: shared_ptr<Y> ptr_y() { return shared_ptr<Y>( &y, make_delegator_deletor( shared_from_this() ) ); } }; And now the problem was resolved but with one little drawback, we are not sharing the same counter between shared_ptr<X> and shared_ptr<Y>, so start looking boost's code to shange it in a way that it satisfies our needs, and we added this constructor to shared_ptr class: template<class Y,class Z> shared_ptr(Y* y, shared_ptr<Z> const & z): px(z.px ? y : 0), pn( y ? z.pn : detail::shared_count() ) // never throws { detail::sp_enable_shared_from_this(y, y, pn); } then we change X::ptr_y() this way: shared_ptr<Y> X::ptr_y() { return shared_ptr<Y>( &y, shared_from_this() ); } This new constructor instructs to create a shared_ptr<> that uses the same counter that the second's shared_ptr<> parameter, but point's to the first raw pointer paramenter. With this change everithing worked fine. Finally our question is: Is there an easyer way to solve our problem? If the answer is yes we want to know it and if the answer is no we want to know if you can enhace shared_ptr to solve this kind of problem. Thank you very much Ricardo #include <iostream> #include <string> #include <boost/smart_ptr.hpp> #include <boost/enable_shared_from_this.hpp> using namespace ::std; using namespace ::boost; #if !defined( SOLUTION1 ) && !defined( SOLUTION2 ) && !defined( SOLUTION3 ) && !defined( SOLUTION4 ) #define SOLUTION3 #endif #if defined( SOLUTION1 ) class null_deleter { public: template <typename T> void operator()( T* ) {} }; #elif defined( SOLUTION2 ) || defined( SOLUTION3 ) template <typename Z> class delegator_deletor { shared_ptr<Z> ptr; public: delegator_deletor( shared_ptr<Z> const & ptrz ) : ptr( ptrz ) { cerr << "delegator_deletor<" << typeid( Z ).name() << ">()" << endl; } template <typename T> void operator()( T* ) { ptr.reset(); cerr << "delegator_deletor<" << typeid( Z ).name() << ">()( " << typeid( T ).name() << "* )" << endl; } }; template <typename Z> delegator_deletor<Z> make_delegator_deletor( shared_ptr<Z> const & ptrz ) { return delegator_deletor<Z>( ptrz ); } #endif class Y : public enable_shared_from_this<Y> { Y( Y const & ); Y& operator=( Y const & ); public: Y() { cerr << "Y::Y()" << endl; } ~Y() { cerr << "Y::~Y()" << endl; } }; class X : public enable_shared_from_this<X> { Y y; int i; X( X const & ); X& operator=( X const & ); public: X() : y(), i( 7 ) { cerr << "X::X()" << endl; } ~X() { cerr << "X::~X()" << endl; } shared_ptr<Y> ptr_y() { #if defined( SOLUTION1 ) return shared_ptr<Y>( &y, null_deleter() ); #elif defined( SOLUTION2 ) return shared_ptr<Y>( &y, make_delegator_deletor( shared_from_this() ) ); #elif defined( SOLUTION3 ) shared_ptr<Y> py; try { py = y.shared_from_this(); } catch ( const bad_weak_ptr& ) { py.reset( &y, make_delegator_deletor( shared_from_this() ) ); } return py; #elif defined( SOLUTION4 ) return shared_ptr<Y>( &y, shared_from_this() ); #endif } shared_ptr<int> ptr_i() { #if defined( SOLUTION1 ) return shared_ptr<int>( &i, null_deleter() ); #elif defined( SOLUTION2 ) || defined( SOLUTION3 ) return shared_ptr<int>( &i, make_delegator_deletor( shared_from_this() ) ); #elif defined( SOLUTION4 ) return shared_ptr<int>( &i, shared_from_this() ); #endif } }; int main( const int, const char** ) { try { cerr << "(1)" << endl; shared_ptr<X> px( new X() ); cerr << "(2)" << endl; shared_ptr<Y> py = px->ptr_y(); cerr << "(3)" << endl; shared_ptr<int> pi = px->ptr_i(); cerr << "(4)" << endl; px.reset(); cerr << "(5)" << endl; py.reset(); cerr << "(6)" << endl; pi.reset(); cerr << "(7)" << endl; } catch ( const exception& e ) { cerr << "Exception caught: " << e.what() << endl; } catch ( ... ) { cerr << "Exception caught ..." << endl; } return 0; }

2 1