Question

I have to use a library that makes database calls which are not thread-safe. Also I occasionally have to load larger amounts of data in a background thread.
It is hard to say which library functions actually access the DB, so I think the safest approach for me is to protect every library call with a lock.

Let’s say I have a library object:

dbLib::SomeObject someObject;

Right now I can do something like this:

dbLib::ErrorCode errorCode = 0;
std::list<dbLib::Item> items;
{
    DbLock dbLock;
    errorCode = someObject.someFunction(&items);
} // dbLock goes out of scope

I would like to simplify that to something like this (or even simpler):

dbLib::ErrorCode errorCode =
    protectedCall(someObject, &dbLib::SomeObject::someFunction(&items));

The main advantage of this would be that I won’t have to duplicate the interface of dbLib::SomeObject in order to protect each call with a lock.

I’m pretty sure that this is a common pattern/idiom but I don’t know its name or what keywords to search for. (Looking at http://www.vincehuston.org/dp/gof_intents.html I think, it’s more an idiom than a pattern).

Where do I have to look for more information?

Answer 1

You could make protectedCall a template function that takes a functor without arguments (meaning you’d bind the arguments at the call-site), and then creates a scoped lock, calls the functor, and returns its value. For example something like:

template <typename Ret>
Ret protectedCall(boost::function<Ret ()> func)
{
    DbLock lock;
    return func();
}

You’d then call it like this:

dbLib::ErrorCode errorCode = protectedCall(boost::bind(&dbLib::SomeObject::someFunction, &items));

EDIT. In case you’re using C++0x, you can use std::function and std::bind instead of the boost equivalents.