version 3.0

common/log.h

@@ -0,0 +1,217 @@
+/*
+ * Copyright (c) 2008-2011 Juli Mallett. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#ifndef	COMMON_LOG_H
+#define	COMMON_LOG_H
+
+#include <stdlib.h> /* For abort(3).  */
+
+#include <sstream>
+#include <string>
+
+class LogNull {
+public:
+	LogNull(void)
+	{ }
+
+	~LogNull()
+	{ }
+
+	template<typename T>
+	const LogNull& operator<< (T) const
+	{
+		return (*this);
+	}
+
+	const LogNull& operator<< (std::ostream& (*)(std::ostream&)) const
+	{
+		return (*this);
+	}
+};
+
+class LogHandle {
+	std::string string_;
+public:
+	LogHandle(const char *s)
+	: string_(s)
+	{ }
+
+	LogHandle(const std::string& s)
+	: string_(s)
+	{ }
+
+	~LogHandle()
+	{ }
+
+	operator const std::string& (void) const
+	{
+		return (string_);
+	}
+
+	template<typename T>
+	LogHandle operator+ (T x) const
+	{
+		LogHandle appended = *this;
+		appended.string_ += x;
+		return (appended);
+	}
+};
+
+class Log {
+public:
+	enum Priority {
+		Emergency,
+		Alert,
+		Critical,
+		Error,
+		Warning,
+		Notice,
+		Info,
+		Trace,
+		Debug,
+	};
+
+	class Halt {
+	public:
+		Halt(void)
+		{ }
+
+		~Halt()
+		{ }
+	};
+
+private:
+	LogHandle handle_;
+	Priority priority_;
+	std::ostringstream str_;
+	bool pending_;
+	bool halted_;
+public:
+	Log(const LogHandle& handle, const Priority& priority, const std::string function)
+	: handle_(handle),
+	  priority_(priority),
+	  str_(),
+	  pending_(false),
+	  halted_(false)
+	{
+		/*
+		 * Print the function name for non-routine messages.
+		 */
+		switch (priority_) {
+		case Emergency:
+		case Alert:
+		case Critical:
+		case Error:
+#if !defined(NDEBUG)
+		case Debug:
+#endif
+			str_ << function << ": ";
+			break;
+		default:
+			break;
+		}
+	}
+
+	~Log()
+	{
+		flush();
+		if (halted_) {
+			abort(); /* XXX */
+		}
+	}
+
+	template<typename T>
+	std::ostream&
+	operator << (T x)
+	{
+		pending_ = true;
+		return (str_ << x);
+	}
+
+	std::ostream&
+	operator << (const Halt&)
+	{
+		pending_ = true;
+		halted_ = true;
+		return (str_ << "Halting: ");
+	}
+
+	void
+	flush(void)
+	{
+		if (!pending_)
+			return;
+		Log::log(priority_, handle_, str_.str());
+	}
+
+	static void log(const Priority&, const LogHandle&, const std::string&);
+	static bool mask(const std::string&, const Priority&);
+};
+
+	/* A panic condition.  */
+#define	EMERGENCY(log)	Log(log, Log::Emergency, __PRETTY_FUNCTION__)
+	/* A condition that should be corrected immediately.  */
+#define	ALERT(log)	Log(log, Log::Alert, __PRETTY_FUNCTION__)
+	/* Critical condition.  */
+#define	CRITICAL(log)	Log(log, Log::Critical, __PRETTY_FUNCTION__)
+	/* Errors.  */
+#define	ERROR(log)	Log(log, Log::Error, __PRETTY_FUNCTION__)
+	/* Warnings.  */
+#define	WARNING(log)	Log(log, Log::Warning, __PRETTY_FUNCTION__)
+	/* Conditions that are not error conditions, but may need handled.  */
+#define	NOTICE(log)	Log(log, Log::Notice, __PRETTY_FUNCTION__)
+	/* Informational.  */
+#define	INFO(log)	Log(log, Log::Info, __PRETTY_FUNCTION__)
+	/* Debugging information.  */
+#if !defined(NDEBUG)
+#define	DEBUG(log)	Log(log, Log::Debug, __PRETTY_FUNCTION__)
+#else
+#define	DEBUG(log)	LogNull()
+#endif
+
+	/* A condition which cannot be continued from.  */
+#define	HALT(log)	EMERGENCY(log) << Log::Halt()
+
+class Trace {
+	LogHandle log_;
+	std::string function_;
+public:
+	Trace(const LogHandle& log, const std::string& function)
+	: log_(log),
+	  function_(function)
+	{
+		Log(log_, Log::Trace, __PRETTY_FUNCTION__) << "Entered " << function_;
+	}
+
+	~Trace()
+	{
+		Log(log_, Log::Trace, __PRETTY_FUNCTION__) << "Exited " << function_;
+	}
+};
+
+	/* Selective debug tracing.  */
+#define	TRACE(log)	Trace trace_(log, __PRETTY_FUNCTION__)
+
+#endif /* !COMMON_LOG_H */