barrier/lib/base/CLog.h

/*
 * synergy -- mouse and keyboard sharing utility
 * Copyright (C) 2002 Chris Schoeneman, Nick Bolton, Sorin Sbarnea
 * 
 * This package is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * found in the file COPYING that should have accompanied this file.
 * 
 * This package is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef CLOG_H
#define CLOG_H

#include "common.h"
#include "IArchMultithread.h"
#include "stdlist.h"
#include <stdarg.h>
#include "CArch.h"

#define CLOG (CLog::getInstance())

class ILogOutputter;
class CThread;

//! Logging facility
/*!
The logging class;  all console output should go through this class.
It supports multithread safe operation, several message priority levels,
filtering by priority, and output redirection.  The macros LOG() and
LOGC() provide convenient access.
*/
class CLog {
public:
	//! Log levels
	/*!
	The logging priority levels in order of highest to lowest priority.
	*/
	enum ELevel {
		kPRINT = -1,	//!< For print only (no file or time)
		kFATAL,			//!< For fatal errors
		kERROR,			//!< For serious errors
		kWARNING,		//!< For minor errors and warnings
		kNOTE,			//!< For messages about notable events
		kINFO,			//!< For informational messages
		kDEBUG,			//!< For important debugging messages
		kDEBUG1,		//!< For verbosity +1 debugging messages
		kDEBUG2,		//!< For verbosity +2 debugging messages
		kDEBUG3,		//!< For verbosity +3 debugging messages
		kDEBUG4,		//!< For verbosity +4 debugging messages
		kDEBUG5			//!< For verbosity +5 debugging messages
	};

	~CLog();

	//! @name manipulators
	//@{

	//! Add an outputter to the head of the list
	/*!
	Inserts an outputter to the head of the outputter list.  When the
	logger writes a message, it goes to the outputter at the head of
	the outputter list.  If that outputter's \c write() method returns
	true then it also goes to the next outputter, as so on until an
	outputter returns false or there are no more outputters.  Outputters
	still in the outputter list when the log is destroyed will be
	deleted.  If \c alwaysAtHead is true then the outputter is always
	called before all outputters with \c alwaysAtHead false and the
	return value of the outputter is ignored.

	By default, the logger has one outputter installed which writes to
	the console.
	*/
	void				insert(ILogOutputter* adopted,
							   bool alwaysAtHead = false);

	//! Remove an outputter from the list
	/*!
	Removes the first occurrence of the given outputter from the
	outputter list.  It does nothing if the outputter is not in the
	list.  The outputter is not deleted.
	*/
	void				remove(ILogOutputter* orphaned);

	//! Remove the outputter from the head of the list
	/*!
	Removes and deletes the outputter at the head of the outputter list.
	This does nothing if the outputter list is empty.  Only removes
	outputters that were inserted with the matching \c alwaysAtHead.
	*/
	void				pop_front(bool alwaysAtHead = false);

	//! Set the minimum priority filter.
	/*!
	Set the filter.  Messages below this priority are discarded.
	The default priority is 4 (INFO) (unless built without NDEBUG
	in which case it's 5 (DEBUG)).   setFilter(const char*) returns
	true if the priority \c name was recognized;  if \c name is NULL
	then it simply returns true.
	*/
	bool				setFilter(const char* name);
	void				setFilter(int);

	//@}
	//! @name accessors
	//@{

	//! Print a log message
	/*!
	Print a log message using the printf-like \c format and arguments
	preceded by the filename and line number.  If \c file is NULL then
	neither the file nor the line are printed.
	*/
	void				print(const char* file, int line,
							const char* format, ...);

	//! Get the minimum priority level.
	int					getFilter() const;

	//! Get the filter name of the current filter level.
	const char*			getFilterName() const;

	//! Get the filter name of a specified filter level.
	const char*			getFilterName(int level) const;

	//! Get the singleton instance of the log
	static CLog*		getInstance();

	//! Get the console filter level (messages above this are not sent to console).
	int					getConsoleMaxLevel() const { return kDEBUG1; }
	//@}

private:
	CLog();

	void				output(ELevel priority, char* msg);

private:
	typedef std::list<ILogOutputter*> COutputterList;

	static CLog*		s_log;

	CArchMutex			m_mutex;
	COutputterList		m_outputters;
	COutputterList		m_alwaysOutputters;
	int					m_maxNewlineLength;
	int					m_maxPriority;
};

/*!
\def LOG(arg)
Write to the log.  Because macros cannot accept variable arguments, this
should be invoked like so:
\code
LOG((CLOG_XXX "%d and %d are %s", x, y, x == y ? "equal" : "not equal"));
\endcode
In particular, notice the double open and close parentheses.  Also note
that there is no comma after the \c CLOG_XXX.  The \c XXX should be
replaced by one of enumerants in \c CLog::ELevel without the leading
\c k.  For example, \c CLOG_INFO.  The special \c CLOG_PRINT level will
not be filtered and is never prefixed by the filename and line number.

If \c NOLOGGING is defined during the build then this macro expands to
nothing.  If \c NDEBUG is defined during the build then it expands to a
call to CLog::print.  Otherwise it expands to a call to CLog::printt,
which includes the filename and line number.
*/

/*!
\def LOGC(expr, arg)
Write to the log if and only if expr is true.  Because macros cannot accept
variable arguments, this should be invoked like so:
\code
LOGC(x == y, (CLOG_XXX "%d and %d are equal", x, y));
\endcode
In particular, notice the parentheses around everything after the boolean
expression.    Also note that there is no comma after the \c CLOG_XXX.
The \c XXX should be replaced by one of enumerants in \c CLog::ELevel
without the leading \c k.  For example, \c CLOG_INFO.  The special
\c CLOG_PRINT level will not be filtered and is never prefixed by the
filename and line number.

If \c NOLOGGING is defined during the build then this macro expands to
nothing.  If \c NDEBUG is not defined during the build then it expands
to a call to CLog::print that prints the filename and line number,
otherwise it expands to a call that doesn't.
*/

#if defined(NOLOGGING)
#define LOG(_a1)
#define LOGC(_a1, _a2)
#define CLOG_TRACE
#elif defined(NDEBUG)
#define LOG(_a1)		CLOG->print _a1
#define LOGC(_a1, _a2)	if (_a1) CLOG->print _a2
#define CLOG_TRACE		NULL, 0,
#else
#define LOG(_a1)		CLOG->print _a1
#define LOGC(_a1, _a2)	if (_a1) CLOG->print _a2
#define CLOG_TRACE		__FILE__, __LINE__,
#endif

// the CLOG_* defines are line and file plus %z and an octal number (060=0, 
// 071=9), but the limitation is that once we run out of numbers at either 
// end, then we resort to using non-numerical chars. this still works (since 
// to deduce the number we subtract octal \060, so '/' is -1, and ':' is 10

#define CLOG_PRINT		CLOG_TRACE "%z\057" // char is '/'
#define CLOG_CRIT		CLOG_TRACE "%z\060" // char is '0'
#define CLOG_ERR		CLOG_TRACE "%z\061"
#define CLOG_WARN		CLOG_TRACE "%z\062"
#define CLOG_NOTE		CLOG_TRACE "%z\063"
#define CLOG_INFO		CLOG_TRACE "%z\064"
#define CLOG_DEBUG		CLOG_TRACE "%z\065"
#define CLOG_DEBUG1		CLOG_TRACE "%z\066"
#define CLOG_DEBUG2		CLOG_TRACE "%z\067"
#define CLOG_DEBUG3		CLOG_TRACE "%z\070"
#define CLOG_DEBUG4		CLOG_TRACE "%z\071" // char is '9'
#define CLOG_DEBUG5		CLOG_TRACE "%z\072" // char is ':'

#endif