Re: Design question on wrapping a logging library
Victor Bazarov wrote:
LoggerWrapper() << SEVERITY_WARNING
<< "You have been warned!...\n"
<< LoggerWrapper::flush();
And if you don't care to see things in the log right away, then you
could simply implement the flushing functionality in the destructor,
and use temporary objects. They'll flush as soon as they are killed.
And if you use local objects, they'll flush going out of scope...
Got it! Should that be
LoggerObject(actual_single_logger_obj) << SEVERITY_WARNING << "crazy
dude" << LoggerWrapper::flush();
Everywhere -- where? If you create it once, as an automatic object,
then pass it around in the same thread, it should be fine. Or you
can recreate it in each function locally. Or you could use a temporary
object:
MyWrapperClass() << setSeverity(blah) << "blah...
Understood. Thanks for clarifying.
I would like to avoid that. Hence my
request to have just one global localwrapper
Huh? Global LOCALwrapper? What's that mean?
Probably nothing. I didn't come up with that name localwrapper. What
I wanted to say was I could get away with just one instance of the
localWrapper object. Your approach evidently makes better sense.
Writing to the global logger has to be portioned, right? And every
write has to be as short as possible not to hold any other logger in
another thread, right? So, if it takes some time to prepare the line
to be output, it needs to be done on thread's own time, and then the
buffer needs to be output to the global logger in a critical section
(although all those things are better discussed in a threading NG).
Gotcha! I have a cool way of handling this. My actual logger class
spins off a thread and posts all logging messages to itself. A message
pump services that thread's message queue and outputs all those
messages to a file... I am oversimplifying but I understand what you
are saying and have got it covered.
template<class T>
LoggerWrapper& operator <<(LoggerWrapper& lw, T const& t);
class LoggerWrapper
{
Logger &globalLogger;
std::string buffer;
Severity severity;
public:
LoggerWrapper(Logger& g)
: globalLogger(g), severity(SEVERITY_INFO) {}
LoggerWrapper& operator << (Severity s) { severity = s; return *this; }
template<class T> friend LoggerWrapper& operator <<(LoggerWrapper&,
T const&);
struct flush {};
void operator << (flush f) {
CRITICAL_SECTION {
globalLogger.writeLine(severity, buffer);
}
buffer.clear();
severity = SEVERITY_INFO;
}
};
template<class T>
LoggerWrapper& operator <<(LoggerWrapper& lw, T const& t)
{
std::ostringstream os;
os << t;
lw.buffer += os.str();
return lw;
}
Exactly what I needed to get me going. You are da man Victor. Thanks!