for_each and invoking self's member pointer

[Kenneth Porter]

I'm trying to create a class that represents a bucket of locks, and I
want to lock a set of objects specified by a container of pointers. I
can't seem to find the right combination of function adapters to invoke
the bucket's member function on each pointer in the argument container.
What's the right thing to use here, at the "???"?

#include <vector>
#include <functional>
#include <algorithm>

using namespace std; // keeps example simple

class BucketOfLocks;

class Lockable
{
BucketOfLocks* owner;
public:
void acquire(BucketOfLocks& newOwner) { owner = &newOwner; }
};

class BucketOfLocks
{
public:
BucketOfLocks(const vector<Lockable*>& lockables);
private:
// this is what I want to invoke in the for_each
void acquire(Lockable& lockable);
};

BucketOfLocks::BucketOfLocks(const vector<Lockable*>& lockables)
{
for_each(lockables.begin(), lockables.end(),
???(&BucketOfLocks::acquire,*this));
}

 

[Alf P. Steinbach]

* Kenneth Porter:

I'm trying to create a class that represents a bucket of locks, and I
want to lock a set of objects specified by a container of pointers. I
can't seem to find the right combination of function adapters to invoke
the bucket's member function on each pointer in the argument container.
What's the right thing to use here, at the "???"?

#include <vector>
#include <functional>
#include <algorithm>

using namespace std; // keeps example simple

class BucketOfLocks;

class Lockable
{
BucketOfLocks* owner;
public:
void acquire(BucketOfLocks& newOwner) { owner = &newOwner; }
};

class BucketOfLocks
{
public:
BucketOfLocks(const vector<Lockable*>& lockables);
private:
// this is what I want to invoke in the for_each
void acquire(Lockable& lockable);
};

BucketOfLocks::BucketOfLocks(const vector<Lockable*>& lockables)
{
for_each(lockables.begin(), lockables.end(),
???(&BucketOfLocks::acquire,*this));
}

class BucketOfLocks
{
public:
BucketOfLocks(const vector<Lockable*>& lockables);
private:
// this is what I want to invoke in the for_each
void acquire(Lockable* lockable) {}
};

BucketOfLocks::BucketOfLocks(const vector<Lockable*>& lockables)
{
for_each(lockables.begin(), lockables.end(),
bind1st( mem_fun<void>( &BucketOfLocks::acquire ), this )
);
}

At least it compiles; I haven't tested it.

By the way, why are you using for_each, why not simply use a for loop?


Cheers, & hth.,

- Alf

 

[Kenneth Porter]

By the way, why are you using for_each, why not simply use a for loop?

Flexibility. I can change the container type without changing the code that
iterates over it.

Alas, I need to continue to use VC6 to support some customers and will need
to cripple my STL template usage a bit for awhile.

 

[Chris Thomasson]

I'm trying to create a class that represents a bucket of locks, and I
want to lock a set of objects specified by a container of pointers.

[...]

You are defining a locking order right? Or, are you using unordered
two-phased locking? The following might be of interest to you:

http://groups.google.com/group/comp.programming.threads/browse_frm/thread/e0c011baf08844c4

 

[Kenneth Porter]

You are defining a locking order right? Or, are you using unordered
two-phased locking? The following might be of interest to you:

http://groups.google.com/group/comp.programming.threads/browse_frm/thre
ad/e0c011baf08844c4

A "lock" in the conventional mutex sense may be a misnomer here. Attempting
to acquire a held lock in my system is considered an error, not something
to be waited for.

 

[Chris Thomasson]

A "lock" in the conventional mutex sense may be a misnomer here.
Attempting
to acquire a held lock in my system is considered an error, not something
to be waited for.

Okay. Sorry for all the questions, but, are your using traditional
two-phased locking based on try_lock/back-off logic?

 

[Kenneth Porter]

Okay. Sorry for all the questions, but, are your using traditional
two-phased locking based on try_lock/back-off logic?

No, I just throw a busy exception if the lock is already held, and the
application pops up an error. Scheduling of resources is supposed to be
handled elsewhere, and a lock failure at this level indicates a programming
error.

 

[Chris Thomasson]

No, I just throw a busy exception if the lock is already held, and the
application pops up an error. Scheduling of resources is supposed to be
handled elsewhere, and a lock failure at this level indicates a
programming
error.

Okay. I see.

 

[Kai-Uwe Bux]

Flexibility. I can change the container type without changing the code
that iterates over it.

[snip]

That can be achieved using just a typedef:

typedef std::vector< ticket > ticket_sequence;
...
for ( ticket_sequence::iterator iter = ... ) {
...
}

Now you can change from vector to deque by modifying a single line.


In fact, one can consider using std::vector< whatever > directly instead of
using a typedef to be the typesystem analogue of using a magic number like
12341 instead of a named constant

int const number_of_runs = 12341;


Best

Kai-Uwe Bux