binders to members of members

[Diego Martins]

consider the following piece of code:

void MyClass::VideoThreadLocker:perator()(Threadable * thread) {
static_cast<BasicVideoThread *>(thread)->mutex.lock();
};

void MyClass::VideoThreadUnlocker:perator()(Threadable * thread) {
static_cast<BasicVideoThread *>(thread)->mutex.unlock();
};

void MyClass:rocessData(PipeData & data)
{
std::for_each(threads.begin(),threads.end(),VideoThreadLocker());
cond.signalAll();
...
std::for_each(threads.begin(),threads.end(),VideoThreadUnlocker());
}

is there a way to avoid the creation of classes VideoThreadLocker and
VideoThreadUnlocker?

I can't figure out how to use mem_fun and binders in order to achieve
the static_cast and reach mutex.lock() or mutex.unlock()

is pointers to member-functions a good alternative? Using this, I will
create one additional class (e.g.: MutexThreadOper), intead of the two
current classes

cheers
Diego Martins

 

[Bob Hairgrove]

consider the following piece of code:

void MyClass::VideoThreadLocker:perator()(Threadable * thread) {
static_cast<BasicVideoThread *>(thread)->mutex.lock();
};

void MyClass::VideoThreadUnlocker:perator()(Threadable * thread) {
static_cast<BasicVideoThread *>(thread)->mutex.unlock();
};

void MyClass:rocessData(PipeData & data)
{
std::for_each(threads.begin(),threads.end(),VideoThreadLocker());
cond.signalAll();
...
std::for_each(threads.begin(),threads.end(),VideoThreadUnlocker());
}

is there a way to avoid the creation of classes VideoThreadLocker and
VideoThreadUnlocker?

I can't figure out how to use mem_fun and binders in order to achieve
the static_cast and reach mutex.lock() or mutex.unlock()

is pointers to member-functions a good alternative? Using this, I will
create one additional class (e.g.: MutexThreadOper), intead of the two
current classes

cheers
Diego Martins

It's very hard to say anything without seeing the declarations of
these classes. Can you post the relevant parts of the headers? Also,
how are you creating your threads? Are any of these objects in shared
libraries? Lots of variables here.

 

[Greg]

consider the following piece of code:

void MyClass::VideoThreadLocker:perator()(Threadable * thread) {
static_cast<BasicVideoThread *>(thread)->mutex.lock();
};

void MyClass::VideoThreadUnlocker:perator()(Threadable * thread) {
static_cast<BasicVideoThread *>(thread)->mutex.unlock();
};

void MyClass:rocessData(PipeData & data)
{
std::for_each(threads.begin(),threads.end(),VideoThreadLocker());
cond.signalAll();
...
std::for_each(threads.begin(),threads.end(),VideoThreadUnlocker());
}

is there a way to avoid the creation of classes VideoThreadLocker and
VideoThreadUnlocker?

I can't figure out how to use mem_fun and binders in order to achieve
the static_cast and reach mutex.lock() or mutex.unlock()

is pointers to member-functions a good alternative? Using this, I will
create one additional class (e.g.: MutexThreadOper), intead of the two
current classes

The std functions do not bind to data members. Boost's bind() (now part
of std::tr1) can bind to data members, but then there is still the
locking methods to call.

A simpler approach would be to add lock() and unlock() methods directly
to Threadable's interface and have them lock and unlock the data member
mutex themselves. In that way, std::mem_fun(&Threadable::lock) and
unlock could be used in these loops instead of the custom functor
currently in place.

Greg

 

[Diego Martins]

hmm can this Boost binder do something like this?

void MyClass:rocessData(PipeData & data)
{

std::for_each(threads.begin(),threads.end(),mem_data(&Threadable::mutex,&Mutex::lock));
cond.signalAll();
...

std::for_each(threads.begin(),threads.end(),mem_data(&Threadable::mutex,&Mutex::unlock));

}

&Threadable::mutex is a pointer to member-data (which is from Mutex
class)
&Mutex::lock and &Mutex::unlock are pointers to member functions of
Mutex class

Cheers
Diego Martins