From: Howard Hinnant <hinnant@twcny.rr.com>
I've just thought of alternative syntax. I'm not sure yet whether I like it or not. But I'm putting it out there so that it gets more eyes than just my own (which are badly overworked at the moment)...
Below, allow for the pseudo code notation:
scoped_lock = move(scoped_lock);
To mean that given:
scoped_lock<Mutex> lock1(mut, defer_lock); scoped_lock<Mutex> lock2(mut);
you can do:
lock1 = move(lock1);
lock2 = move(lock1) // ???
We currently have (just discussing assignment forms below):
scoped_lock = move(scoped_lock); scoped_lock = move(upgradable_lock); // 1 scoped_lock = try_move(upgradable_lock); // 2
sharable_lock = sharable_lock; sharable_lock = upgradable_lock; sharable_lock = move(scoped_lock);
upgradable_lock = sharable_lock; upgradable_lock = move(upgradable_lock); upgradable_lock = move(scoped_lock);
Those forms not using try_move or move take a const& on the rhs, and never block.
Those forms using move on the rhs require the rhs to be an rvalue (or cast with move), and never block except for 1, which can block.
The form taking try_move is a try-lock form of 1 (and thus can not block).
Possible alternative syntax:
scoped_lock = move(scoped_lock); scoped_lock |= move(upgradable_lock); // 1
I like the pipe's suggestion of a wall and, hence, blocking. The x= operators are good, in general, as they still suggest assignment (<<= is better than << for that reason).
scoped_lock <<= move(upgradable_lock); // 2
This isn't as suggestive as the |=. How about these: scoped_lock ~= move(upgradable_lock); scoped_lock %= move(upgradable_lock); The ~ in ~= sort of suggests try, as in try-lock. Unfortunately, the tilde is small so it doesn't stand out really well. %= is almost never overloaded, so that makes it a good candidate for coopting for this purpose, and it sort of suggests the wishy-washy nature of try-lock. -- Rob Stewart stewart@sig.com Software Engineer http://www.sig.com Susquehanna International Group, LLP using std::disclaimer;