Re: DebugLog. Bad design or...??
Bo M?ller wrote:
I want to make a logging class which is used like a ostream. But in
addition I need the log only put generate output for messages which
are >= the threshold of the instance e.g.
// ERROR > WARN > DEBUG
DebugLog log(WARN);
log.Report(DEBUG)<< "No output "<<std::endl;
log(ERROR) << "Output" << std::endl;
To achive this i declared Debuglog as:
class DebugLog: public std::ostream
{
public:
// Various Constructors omitted
std::ostream const &GetStream();
DebugLog &Report(const int &level);
bool const isActive();
private:
int m_threshold;
int m_level;
};
Hmmm, this interface doesn't fit above use.
Deriving from std::ostream gave me all the inserters. But in order to
switch the output on or off i defined the functions and template
below:
bool DebugLog::isActive() { return m_level >= m_threshold;}
const?
std::ostream &DebugLog::GetStream()
{
return dynamic_cast<std::ostream&> (*this);
}
Why dynamic_cast?
DebugLog &DebugLog::Report(const int &level)
{
m_level = level;
return (*this);
}
Here is one thing I don't like: adding an entry modifies a persistent state
inside the object.
template< class T > DebugLog& operator<<( DebugLog& o , T const& obj)
{
if( o.isActive() )
o.GetStream() << obj ;
return o ;
}
You will have problems with this when you encounter a T that is an
overloaded function like std::endl. Just adding an overload for
ostream& (*pfn)(ostream&);
should do the job.
The idear with the template was to forward all the insertions to an
std::ostream is the DebugLog was active, and discard all if the
DebugLog was inactive.
I did not get the idear by myself but from:
"http://groups.google.dk/group/comp.lang.c++.moderated/browse_thread/thread/
e61ad0c1feb3f0e7/7e6c3a1903784451?lnk=st&q=&rnum=3&hl=da#7e6c3a1903784451"
If the link doesn't work, the threads title was "Efficient error-log
filtering using streams" and the answer was given by James Kanze on
11 feb. 1999:
2. More recently, using templates to define a logging stream which does
the test before converting, e.g.:
template< class T >
logstream&
operator<<( logstream& o , T const& obj )
{
if ( o.isActive() )
o.getStream() << obj ;
return o ;
}
It all works nicely until i pass :
log2.Report(x) << "Level " << x << std::endl << "#";
Then the output contains "\n#". Thus my template is NOT used, but
instead a template in std::ostream which returns an std::ostream.
I believe this is due to std::endl not fitting your template inserter and
thus calling the existing version.
Is it possible to write a insertion operator for manipulators which
simply casts the manipulator away is the Debuglog is inaktive?
See above, you need an overload because std::endl is overloaded.
Or is the design bad from the begining? I have seen suggestions to set
the failbit of the ostream, but i think this is an ugly solution.
You can easier work around this issue, even without replacing all those
operators. Firstly, don't derive from ostream but include two ostreams in
your logger.
struct logger
{
ostream out;
ostream sink;
};
Then, you connect one of those to a real target (by supplying a rdbuf() that
forwards it):
streambuf* rdbuf( streambuf* b) { return out.rdbuf(b); }
In order to write something, you could conveniently overload operator()
(which is a matter of taste though, you could also use a memberfunction):
ostream& operator()(unsigned level) {
if(level>=threshold)
return out;
else
return sink;
}
and then leave everything else to the << operators (my above advise about
overloads is then still true but not important any more!), you don't need
any other operators specially for your class:
logger log;
log(LOG_WARNING) << "foo!\n";
BTW: this has the added advantage that you can supply this at any place
where a std::ostream& is called for:
someobject o;
o.dump_state_to_stream( log(LOG_INFO));
even without changing said object.
Uli
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]