Should this be called a mutex? - c++

Question

I have objects that can be opened in different modes, among which read and write.
If you opened it read you can still call
object->upgradeOpen();
It is common practice in our code to call
object->downgradeOpen();
When you are done writing.
I usually find it easier to use the concept of a mutex that I learned in c++ essentials where you let this upgradeOpen and downgradeOpen be done in the constructor and destructor of this mutex object.
class ObjectMutex{
public:
ObjectMutex(const Object& o)
: m_o(o)
{
m_o.upgradeOpen();
}
~ObjectMutex(){
m_o.downgradeOpen();
}
private:
Object m_o;
};
Only problem is, it doesn't really lock the object to make it thread safe, so I don't think it really is a mutex.
Is there another accepted name to call this construction?

Answer 1

The principle which is implemented in this class is called RAII (http://en.cppreference.com/w/cpp/language/raii).
In general such objects can be called "RAII object".
For the name in code you can use ScopedSomething. In this particular case, for example, ScopedObjectUpgrader or another meaningful name of action which is done for the scope.

Answer 2

Sounds to me more like an upgradable mutex
Take a look at RAII wrappers for upgradable mutexes How to unlock boost::upgrade_to_unique_lock (made from boost::shared_mutex)? to get a better idea of how to write one yourself.
For example you probably want to write two separate RAII wrappers
class OpenLock {
public:
OpenLock(Object& o_in) : o{o_in} {
this->o.open();
}
~OpenLock() {
this->o.close();
}
private:
Object& o;
};
class UpgradeOpenLock {
public:
UpgradeOpenLock(Object& o_in) : o{o_in} {
this->o->upgradeOpen();
}
~UpgradeOpenLock() {
this->o->downgradeOpen();
}
private:
Object& o;
};
and then use it like this
{
OpenLock open_lck(o);
// freely read
{
UpgradeOpenLock upgrade_lck(o);
// freely read or write
}
// freely read again
}