Question

I have a logging class which has operator<< overloaded. So I can do things like this:

oLogger << "Log this" << " and this" << " and " << 10 << endl;
oLogger`<< "Something else" << endl;

The logger does this without any problems. But, I want the logger object to be shared among threads. Then, I don’t want it printing out something like this:

//LogFILE
Log this and this Something else
 and 10

So, I need to lock a whole chain of operator<<s. I am guessing this can be done with RAII, I haven’t given it much thought yet. In the meantime, is there any traditional way of getting this done? (Except ending input with a manipulator?)

Answer 1

Slight alternative to Nim’s answer:

Create

class LockedLog {
    static MutEx mutex; // global mutex for logging
    ScopedLock lock; // some scoped locker to hold the mutex
    Logger &oLogger; // reference to the log writer itself
public:
    LockedLog(Logger &oLogger) : oLogger(oLogger), lock(mutex) {}
    template <typename T>
    LockedLog &operator<<(const T &value) { oLogger << value; return *this; }
};

And either just do:

LockedLog(oLogger) << "Log this" << " and this " << " and " << 10 << endl;

Or change Logger::operator<< to normal method, call this method in LockedLog::operator<<, add cast-operator to Logger:

operator LockedLog() { return LockedLog(*this); }

and that should add locking to your current code.

Update: That locks across all the calls to operator<< and may even lock around evaluation of their arguments (depends on whether compiler will evaluate left or right argument first and it may choose). To reduce that, one could:

class LockedLog {
    static MutEx mutex; // global mutex for logging
    std::stringstream buffer; // temporary formatting buffer;
    Logger &oLogger; // reference to the log writer itself
public:
    LockedLog(Logger &oLogger) : oLogger(oLogger), lock(mutex) {}
    template <typename T> 
    LockedLog &operator<<(const T &value) { buffer << value; return *this; }
    ~LockedLog() { ScopedLock lock(mutex); oLogger << buffer.str() << std::flush; }
};

But the stringstream adds another overhead.