Portable Guard Classes
Guarding other classes follows the same pattern. Assuming that all guards follow the pattern GuardXXX, where XXX is the name of a DB Interface Module class, you can use a simple macro to provide a portable interface, whether or not the compiler uses templates. The macro would look something like this:
#if compiler does not support templates
#define GUARD(Class, OBJECT) Guard ## Class guard__((OBJECT))
#else
#define GUARD(Class, OBJECT) Guard<Class> guard__((OBJECT))
#endif
The first macro concatenates the word
Guard with the name of the class,
RWDBConnection, and creates an instance of that class called
guard__, initialized with the
OBJECT (conn). The second macro simply instantiates an instance of class Guard with the type
Class (
Class = RWDBConnection). Even if your compiler or application does not support templates, you can use these macros in a portable manner as follows:
void doSomething(const RWDBConnection& conn)
{
// we’re going to use the connection so we’d better
// control access
GUARD(RWDBConnection, conn); // RWDBConnection supports the
// necessary interface.
// Do something on the connection.
// The mutex is released when the Guard instance goes out of
// scope.
}
Even when using the portable guard class template, you must still create a specialized guard class for each DB Interface Module object type you want to guard. For example, to guard an
RWDBSchema, you have to create:
class GuardRWDBSchema {
.
.
.
}
This is necessary in addition to using GUARD(RWDBSchema, mySchema) in your code.
