Included Log4Qt in project

1 files changed, 902 insertions, 0 deletions

diff --git a/ext/Log4Qt/src/helpers/patternformatter.cpp b/ext/Log4Qt/src/helpers/patternformatter.cpp
new file mode 100644
index 0000000..cf23198
--- /dev/null
+++ b/ext/Log4Qt/src/helpers/patternformatter.cpp
@@ -0,0 +1,902 @@
+/******************************************************************************
+ *
+ * package:     Log4Qt
+ * file:        patternformatter.cpp
+ * created:     September 2007
+ * author:      Martin Heinrich
+ *
+ *
+ * changes      Feb 2009, Martin Heinrich
+ *              - Fixed VS 2008 unreferenced formal parameter warning by using
+ *                Q_UNUSED in LiteralPatternConverter::convert.
+ *
+ *
+ * Copyright 2007 - 2009 Martin Heinrich
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ ******************************************************************************/
+
+
+
+/******************************************************************************
+ * Dependencies
+ ******************************************************************************/
+
+#include "helpers/patternformatter.h"
+
+#include <QtCore/QString>
+#include <QtCore/QDebug>
+#include <limits.h>
+#include "helpers/datetime.h"
+#include "helpers/logerror.h"
+#include "layout.h"
+#include "logger.h"
+#include "loggingevent.h"
+
+
+
+namespace Log4Qt
+{
+
+
+	/**************************************************************************
+	 *Declarations
+	 **************************************************************************/
+
+
+	/*!
+	 * \brief The class FormattingInfo stores the formatting modifier for a
+	 * pattern converter.
+	 *
+	 * \sa PatternConverter
+	 */
+	class FormattingInfo
+	{
+	public:
+		FormattingInfo()
+		{ clear(); }
+		// FormattingInfo(const FormattingInfo &rOther); // Use compiler default
+		// virtual ~FormattingInfo(); // Use compiler default
+		// FormattingInfo &operator=(const FormattingInfo &rOther); // Use compiler default
+
+		void clear();
+		static QString intToString(int i);
+
+	public:
+		int mMinLength;
+		int mMaxLength;
+		bool mLeftAligned;
+	};
+
+
+	/*!
+	 * \brief The class PatternConverter is the abstract base class for all
+	 * pattern converters.
+	 *
+	 * PatternConverter handles the minimum and maximum modifier for a
+	 * conversion character. The actual conversion is by calling the
+	 * convert() member function of the derived class.
+	 *
+	 * \sa PatternLayout::format()
+	 */
+	class PatternConverter
+	{
+	public:
+		PatternConverter(const FormattingInfo &rFormattingInfo = FormattingInfo()) :
+			mFormattingInfo(rFormattingInfo)
+		{};
+		virtual ~PatternConverter()
+		{};
+	private:
+		PatternConverter(const PatternConverter &rOther); // Not implemented
+		PatternConverter &operator=(const PatternConverter &rOther); // Not implemented
+
+	public:
+		void format(QString &rFormat, const LoggingEvent &rLoggingEvent) const;
+
+	protected:
+		virtual QString convert(const LoggingEvent &rLoggingEvent) const = 0;
+	#ifndef QT_NO_DEBUG_STREAM
+		virtual QDebug debug(QDebug &rDebug) const = 0;
+		friend QDebug operator<<(QDebug, const PatternConverter &rPatternConverter);
+	#endif
+
+	protected:
+		FormattingInfo mFormattingInfo;
+	};
+
+
+	/*!
+	 * \brief The class BasicPatternConverter converts several members of a
+	 *        LoggingEvent to a string.
+	 *
+	 * BasicPatternConverter is used by PatternLayout to convert members that
+	 * do not reuquire additional formatting to a string as part of formatting
+	 * the LoggingEvent. It handles the following conversion characters:
+	 * 'm', 'p', 't', 'x'
+	 *
+	 * \sa PatternLayout::format()
+	 * \sa PatternConverter::format()
+	 */
+	class BasicPatternConverter : public PatternConverter
+	{
+	public:
+		enum Type {
+			MESSAGE_CONVERTER,
+			NDC_CONVERTER,
+			LEVEL_CONVERTER,
+			THREAD_CONVERTER
+		};
+
+	public:
+		BasicPatternConverter(const FormattingInfo &rFormattingInfo,
+														Type type) :
+					PatternConverter(rFormattingInfo),
+					mType(type)
+			{};
+		// virtual ~BasicPatternConverter(); // Use compiler default
+	private:
+		BasicPatternConverter(const BasicPatternConverter &rOther); // Not implemented
+		BasicPatternConverter &operator=(const BasicPatternConverter &rOther); // Not implemented
+
+	protected:
+		virtual QString convert(const LoggingEvent &rLoggingEvent) const;
+	#ifndef QT_NO_DEBUG_STREAM
+		virtual QDebug debug(QDebug &rDebug) const;
+	#endif
+
+	private:
+		Type mType;
+	};
+
+
+	/*!
+	 * \brief The class DatePatternConverter converts the time stamp of a
+	 *        LoggingEvent to a string.
+	 *
+	 * DatePatternConverter is used by PatternLayout to convert the time stamp
+	 * of a LoggingEvent to a string as part of formatting the LoggingEvent.
+	 * It handles the 'd' and 'r' conversion character.
+	 *
+	 * \sa PatternLayout::format()
+	 * \sa PatternConverter::format()
+	 */
+	class DatePatternConverter : public PatternConverter
+	{
+	public:
+		DatePatternConverter(const FormattingInfo &rFormattingInfo,
+										 const QString &rFormat) :
+					PatternConverter(rFormattingInfo),
+			mFormat(rFormat)
+		{};
+			// virtual ~DatePatternConverter(); // Use compiler default
+	private:
+		DatePatternConverter(const DatePatternConverter &rOther); // Not implemented
+		DatePatternConverter &operator=(const DatePatternConverter &rOther); // Not implemented
+
+	protected:
+		virtual QString convert(const LoggingEvent &rLoggingEvent) const;
+	#ifndef QT_NO_DEBUG_STREAM
+		virtual QDebug debug(QDebug &rDebug) const;
+	#endif
+
+	private:
+		QString mFormat;
+	};
+
+
+	/*!
+	 * \brief The class LiteralPatternConverter provides string literals.
+	 *
+	 * LiteralPatternConverter is used by PatternLayout to embed string
+	 * literals as part of formatting the LoggingEvent. It handles string
+	 * literals and the 'n' conversion character.
+	 *
+	 * \sa PatternLayout::format()
+	 * \sa PatternConverter::format()
+	 */
+	class LiteralPatternConverter : public PatternConverter
+	{
+	public:
+		LiteralPatternConverter(const QString &rLiteral) :
+					PatternConverter(),
+					mLiteral(rLiteral)
+			{};
+			// virtual ~LiteralPatternConverter(); // Use compiler default
+	private:
+		LiteralPatternConverter(const LiteralPatternConverter &rOther); // Not implemented
+		LiteralPatternConverter &operator=(const LiteralPatternConverter &rOther); // Not implemented
+
+	protected:
+		virtual QString convert(const LoggingEvent &rLoggingEvent) const;
+	#ifndef QT_NO_DEBUG_STREAM
+		virtual QDebug debug(QDebug &rDebug) const;
+	#endif
+
+	private:
+		QString mLiteral;
+	};
+
+
+	/*!
+	 * \brief The class LoggerPatternConverter converts the Logger name of a
+	 *        LoggingEvent to a string.
+	 *
+	 * LoggerPatternConverter is used by PatternLayout to convert the Logger
+	 * name of a LoggingEvent to a string as part of formatting the
+	 * LoggingEvent. It handles the 'c' conversion character.
+	 *
+	 * \sa PatternLayout::format()
+	 * \sa PatternConverter::format()
+	 */
+	class LoggerPatternConverter : public PatternConverter
+	{
+	public:
+		LoggerPatternConverter(const FormattingInfo &rFormattingInfo,
+														 int precision) :
+				 PatternConverter(rFormattingInfo),
+				 mPrecision(precision)
+			{};
+		// virtual ~LoggerPatternConverter(); // Use compiler default
+	private:
+		LoggerPatternConverter(const LoggerPatternConverter &rOther); // Not implemented
+		LoggerPatternConverter &operator=(const LoggerPatternConverter &rOther); // Not implemented
+
+	protected:
+		virtual QString convert(const LoggingEvent &rLoggingEvent) const;
+	#ifndef QT_NO_DEBUG_STREAM
+		virtual QDebug debug(QDebug &rDebug) const;
+	#endif
+
+	private:
+		int mPrecision;
+	};
+
+
+
+	/*!
+	 * \brief The class MDCPatternConverter converts the MDC data of a
+	 *        LoggingEvent to a string.
+	 *
+	 * MDCPatternConverter is used by PatternLayout to convert the MDC data of
+	 * a LoggingEvent to a string as part of formatting the LoggingEvent. It
+	 * handles the 'X' conversion character.
+	 *
+	 * \sa PatternLayout::format()
+	 * \sa PatternConverter::format()
+	 */
+	class MDCPatternConverter : public PatternConverter
+	{
+	public:
+		MDCPatternConverter(const FormattingInfo &rFormattingInfo,
+										const QString &rKey) :
+					PatternConverter(rFormattingInfo),
+					mKey(rKey)
+			{};
+		// virtual ~MDCPatternConverter(); // Use compiler default
+	private:
+		MDCPatternConverter(const MDCPatternConverter &rOther); // Not implemented
+		MDCPatternConverter &operator=(const MDCPatternConverter &rOther); // Not implemented
+
+	protected:
+		virtual QString convert(const LoggingEvent &rLoggingEvent) const;
+	#ifndef QT_NO_DEBUG_STREAM
+		virtual QDebug debug(QDebug &rDebug) const;
+	#endif
+
+	private:
+		QString mKey;
+	};
+
+
+	#ifndef QT_NO_DEBUG_STREAM
+	QDebug operator<<(QDebug, const FormattingInfo &rFormattingInfo);
+	#endif
+
+
+	#ifndef QT_NO_DEBUG_STREAM
+	QDebug operator<<(QDebug, const PatternConverter &rPatternConverter);
+	#endif
+
+
+
+	/**************************************************************************
+	 * C helper functions
+	 **************************************************************************/
+
+
+		LOG4QT_DECLARE_STATIC_LOGGER(logger, Log4Qt::PatternFormatter)
+
+
+
+	/**************************************************************************
+	 * Class implementation: PatternFormatter
+	 **************************************************************************/
+
+
+	PatternFormatter::PatternFormatter(const QString &rPattern) :
+		mIgnoreCharacters(QLatin1String("CFlLM")),
+		mConversionCharacters(QLatin1String("cdmprtxX")),
+		mOptionCharacters(QLatin1String("cd")),
+		mPattern(rPattern),
+		mPatternConverters()
+	{
+		parse();
+	}
+
+
+	PatternFormatter::~PatternFormatter()
+	{
+		PatternConverter *p_converter;
+		Q_FOREACH(p_converter, mPatternConverters)
+			delete p_converter;
+	}
+
+
+	QString PatternFormatter::format(const LoggingEvent &rLoggingEvent) const
+	{
+		QString result;
+		PatternConverter *p_converter;
+		Q_FOREACH(p_converter, mPatternConverters)
+			p_converter->format(result, rLoggingEvent);
+		return result;
+	}
+
+
+	bool PatternFormatter::addDigit(const QChar &rDigit,
+																	int &rValue)
+	{
+		if (!rDigit.isDigit())
+			return false;
+
+		int digit_value = rDigit.digitValue();
+		if (rValue > (INT_MAX - digit_value) / 10)
+			rValue = INT_MAX;
+		else
+			rValue = rValue * 10 + digit_value;
+		return true;
+	}
+
+
+	void PatternFormatter::createConverter(const QChar &rChar,
+																				 const FormattingInfo &rFormattingInfo,
+																				 const QString &rOption)
+	{
+		Q_ASSERT_X(mConversionCharacters.indexOf(rChar) >= 0, "PatternFormatter::createConverter", "Unknown conversion character" );
+
+			LogError e("Creating Converter for character '%1' min %2, max %3, left %4 and option '%5'");
+			e << QString(rChar)
+				<< FormattingInfo::intToString(rFormattingInfo.mMinLength)
+				<< FormattingInfo::intToString(rFormattingInfo.mMaxLength)
+				<< rFormattingInfo.mLeftAligned
+				<< rOption;
+		logger()->trace(e);
+
+		switch (rChar.toLatin1())
+		{
+			case 'c':
+				mPatternConverters << new LoggerPatternConverter(rFormattingInfo,
+																															 parseIntegerOption(rOption));
+				break;
+			case 'd':
+			{
+				QString option = rOption;
+				if (rOption.isEmpty()) {
+					option = QLatin1String("ISO8601");
+				} else if (rOption == "locale:long") {
+				  option = QLocale().dateTimeFormat(QLocale::LongFormat);
+				} else if (rOption == "locale:short") {
+				  option = QLocale().dateTimeFormat(QLocale::ShortFormat);
+				} else if (rOption == "locale:narrow") {
+				  option = QLocale().dateTimeFormat(QLocale::NarrowFormat);
+				} else if (rOption == "locale") {
+				  option = QLocale().dateTimeFormat(QLocale::ShortFormat);
+				}
+				mPatternConverters << new DatePatternConverter(rFormattingInfo,
+																														 option);
+				break;
+			}
+			case 'm':
+				mPatternConverters << new BasicPatternConverter(rFormattingInfo,
+																															BasicPatternConverter::MESSAGE_CONVERTER);
+				break;
+			case 'p':
+				mPatternConverters << new BasicPatternConverter(rFormattingInfo,
+																															BasicPatternConverter::LEVEL_CONVERTER);
+				break;
+			case 'r':
+				mPatternConverters << new DatePatternConverter(rFormattingInfo,
+																														 QLatin1String("RELATIVE"));
+				break;
+			case 't':
+				mPatternConverters << new BasicPatternConverter(rFormattingInfo,
+																															BasicPatternConverter::THREAD_CONVERTER);
+				break;
+			case 'x':
+				mPatternConverters << new BasicPatternConverter(rFormattingInfo,
+																															BasicPatternConverter::NDC_CONVERTER);
+				break;
+			case 'X':
+				mPatternConverters << new MDCPatternConverter(rFormattingInfo,
+																														rOption);
+				break;
+			default:
+				Q_ASSERT_X(false, "PatternFormatter::createConverter", "Unknown pattern character");
+		}
+	}
+
+
+	void PatternFormatter::createLiteralConverter(const QString &rLiteral)
+	{
+		logger()->trace("Creating literal LiteralConverter with Literal '%1'",
+								rLiteral);
+		mPatternConverters << new LiteralPatternConverter(rLiteral);
+	}
+
+
+	void PatternFormatter::parse()
+	{
+		enum State {
+			LITERAL_STATE,
+			ESCAPE_STATE,
+			MIN_STATE,
+			DOT_STATE,
+			MAX_STATE,
+			CHARACTER_STATE,
+			POSSIBLEOPTION_STATE,
+			OPTION_STATE
+		};
+
+		int i = 0;
+		QChar c;
+		char ch;
+		State state = LITERAL_STATE;
+		FormattingInfo formatting_info;
+		QString literal;
+		int converter_start = 0;
+		int option_start = 0;
+		while (i < mPattern.length())
+		{
+					// i points to the current character
+			// c contains the current character
+			// ch contains the Latin1 equivalent of the current character
+			// i is incremented at the end of the loop to consume the character
+			// continue is used to change state without consuming the character
+
+			c = mPattern.at(i);
+			ch = c.toLatin1();
+					switch (state)
+					{
+							case LITERAL_STATE:
+								if (ch == '%')
+								{
+									formatting_info.clear();
+									converter_start = i;
+									state = ESCAPE_STATE;
+								} else
+									literal += c;
+								break;
+							case ESCAPE_STATE:
+								if (ch == '%')
+								{
+									literal += c;
+									state = LITERAL_STATE;
+								}
+								else if (ch == 'n')
+								{
+									literal += Layout::endOfLine();
+									state = LITERAL_STATE;
+								}
+								else
+								{
+									if (!literal.isEmpty())
+									{
+										createLiteralConverter(literal);
+										literal.clear();
+									}
+									if (ch == '-')
+										formatting_info.mLeftAligned = true;
+									else if (c.isDigit())
+									{
+									formatting_info.mMinLength = c.digitValue();
+										state = MIN_STATE;
+									}
+									else if (ch == '.')
+										state = DOT_STATE;
+									else
+									{
+										state = CHARACTER_STATE;
+										continue;
+									}
+								}
+								break;
+							case MIN_STATE:
+								if (!addDigit(c, formatting_info.mMinLength))
+								{
+									if (ch == '.')
+										state = DOT_STATE;
+									else
+									{
+										state = CHARACTER_STATE;
+										continue;
+									}
+								}
+								break;
+							case DOT_STATE:
+								if (c.isDigit())
+								{
+								formatting_info.mMaxLength = c.digitValue();
+									state = MAX_STATE;
+								}
+								else
+								{
+											LogError e = LOG4QT_ERROR(QT_TR_NOOP("Found character '%1' where digit was expected."),
+																									LAYOUT_EXPECTED_DIGIT_ERROR,
+																									"Log4Qt::PatternFormatter");
+											e << QString(c);
+											logger()->error(e);
+								}
+								break;
+							case MAX_STATE:
+								if (!addDigit(c, formatting_info.mMaxLength))
+								{
+									state = CHARACTER_STATE;
+									continue;
+								}
+								break;
+							case CHARACTER_STATE:
+								if (mIgnoreCharacters.indexOf(c) >= 0)
+									state = LITERAL_STATE;
+								else if (mOptionCharacters.indexOf(c) >= 0)
+									state = POSSIBLEOPTION_STATE;
+								else if (mConversionCharacters.indexOf(c) >= 0)
+								{
+									createConverter(c, formatting_info);
+									state = LITERAL_STATE;
+								}
+								else
+								{
+									logger()->warn("Invalid conversion character '%1' at %2 in pattern '%3'",
+														 c, i, mPattern);
+									createLiteralConverter(mPattern.mid(converter_start, i - converter_start + 1));
+									state = LITERAL_STATE;
+								}
+								break;
+							case POSSIBLEOPTION_STATE:
+								if (ch == '{')
+								{
+										option_start = i;
+									state = OPTION_STATE;
+								}
+								else
+								{
+									createConverter(mPattern.at(i - 1),
+																			formatting_info);
+									state = LITERAL_STATE;
+									continue;
+								}
+								break;
+							case OPTION_STATE:
+								if (ch == '}')
+								{
+									createConverter(mPattern.at(option_start - 1),
+																			formatting_info,
+																			mPattern.mid(option_start + 1, i - option_start - 1));
+									state = LITERAL_STATE;
+								}
+									break;
+							default:
+								Q_ASSERT_X(false, "PatternFormatter::parse()", "Unknown parsing state constant");
+							state = LITERAL_STATE;
+					}
+			i++;
+		}
+
+		if (state != LITERAL_STATE)
+		{
+			logger()->warn("Unexptected end of pattern '%1'", mPattern);
+			if (state == ESCAPE_STATE)
+				literal += c;
+			else
+				literal += mPattern.mid(converter_start);
+		}
+
+		if (!literal.isEmpty())
+			createLiteralConverter(literal);
+	}
+
+
+	int PatternFormatter::parseIntegerOption(const QString &rOption)
+	{
+		if (rOption.isEmpty())
+			return 0;
+
+		bool ok;
+		int result = rOption.toInt(&ok);
+		if (!ok)
+		{
+					LogError e = LOG4QT_ERROR(QT_TR_NOOP("Option '%1' cannot be converted into an integer"),
+																			LAYOUT_OPTION_IS_NOT_INTEGER_ERROR,
+																			"Log4Qt::PatterFormatter");
+					e << rOption;
+					logger()->error(e);
+		}
+		if (result < 0)
+		{
+					LogError e = LOG4QT_ERROR(QT_TR_NOOP("Option %1 isn't a positive integer"),
+																			LAYOUT_INTEGER_IS_NOT_POSITIVE_ERROR,
+																			"Log4Qt::PatterFormatter");
+					e << result;
+					logger()->error(e);
+			result = 0;
+		}
+		return result;
+	}
+
+
+	/**************************************************************************
+	 * Class implementation: FormattingInfo
+	 **************************************************************************/
+
+
+	void FormattingInfo::clear()
+	{
+		mMinLength = 0;
+		mMaxLength = INT_MAX;
+		mLeftAligned = false;
+	}
+
+
+	QString FormattingInfo::intToString(int i)
+	{
+			if (i == INT_MAX)
+				return QLatin1String("INT_MAX");
+			else
+				return QString::number(i);
+	}
+
+
+
+	/**************************************************************************
+	 * Class implementation: PatternConverter
+	 **************************************************************************/
+
+
+	void PatternConverter::format(QString &rFormat, const LoggingEvent &rLoggingEvent) const
+	{
+		const QLatin1Char space(' ');
+		QString s = convert(rLoggingEvent);
+
+		if (s.length() > mFormattingInfo.mMaxLength)
+			rFormat += s.left(mFormattingInfo.mMaxLength);
+		else if (mFormattingInfo.mLeftAligned)
+			rFormat += s.leftJustified(mFormattingInfo.mMinLength, space, false);
+		else
+			rFormat += s.rightJustified(mFormattingInfo.mMinLength, space, false);
+	}
+
+
+
+	/**************************************************************************
+	 * Class implementation: BasicPatternConverter
+	 **************************************************************************/
+
+
+	QString BasicPatternConverter::convert(const LoggingEvent &rLoggingEvent) const
+	{
+		switch (mType)
+		{
+					case MESSAGE_CONVERTER:
+						return rLoggingEvent.message();
+						break;
+					case NDC_CONVERTER:
+						return rLoggingEvent.ndc();
+						break;
+					case LEVEL_CONVERTER:
+						return rLoggingEvent.level().toString();
+						break;
+					case THREAD_CONVERTER:
+						return rLoggingEvent.threadName();
+						break;
+					default:
+						Q_ASSERT_X(false, "BasicPatternConverter::convert()", "Unkown type constant");
+						return QString();
+		}
+	}
+
+
+	QDebug BasicPatternConverter::debug(QDebug &rDebug) const
+	{
+		QString type;
+		switch (mType)
+		{
+					case MESSAGE_CONVERTER:
+						type = QLatin1String("MESSAGE_CONVERTER");
+						break;
+					case NDC_CONVERTER:
+						type = QLatin1String("NDC_CONVERTER");
+						break;
+					case LEVEL_CONVERTER:
+						type = QLatin1String("LEVEL_CONVERTER");
+						break;
+					case THREAD_CONVERTER:
+						type = QLatin1String("THREAD_CONVERTER");
+						break;
+					default:
+						Q_ASSERT_X(false, "BasicPatternConverter::debug()", "Unkown type constant");
+		}
+			rDebug.nospace() << "BasicPatternConverter("
+					<< mFormattingInfo
+					<< "type:" << type
+					<< ")";
+			return rDebug.space();
+	}
+
+
+
+	/**************************************************************************
+	 * Class implementation: DatePatternConverter
+	 **************************************************************************/
+
+
+	QString DatePatternConverter::convert(const LoggingEvent &rLoggingEvent) const
+	{
+		return DateTime::fromMilliSeconds(rLoggingEvent.timeStamp()).toString(mFormat);
+	}
+
+
+	QDebug DatePatternConverter::debug(QDebug &rDebug) const
+	{
+			rDebug.nospace() << "DatePatternConverter("
+					<< mFormattingInfo
+					<< "format:" << mFormat
+					<< ")";
+			return rDebug.space();
+	}
+
+
+
+	/**************************************************************************
+	 * Class implementation: LiteralPatternConverter
+	 **************************************************************************/
+
+
+	QString LiteralPatternConverter::convert(const LoggingEvent &rLoggingEvent) const
+	{
+		Q_UNUSED(rLoggingEvent);
+		return mLiteral;
+	}
+
+
+	QDebug LiteralPatternConverter::debug(QDebug &rDebug) const
+	{
+			rDebug.nospace() << "LiteralPatternConverter("
+					<< mFormattingInfo
+					<< "literal:" << mLiteral
+					<< ")";
+			return rDebug.space();
+	}
+
+
+
+	/**************************************************************************
+	 * Class implementation: LoggerPatternConverter
+	 **************************************************************************/
+
+
+	QString LoggerPatternConverter::convert(const LoggingEvent &rLoggingEvent) const
+	{
+		if (!rLoggingEvent.logger())
+			return QString();
+		QString name = rLoggingEvent.logger()->name();
+			if (mPrecision <= 0 || (name.isEmpty()))
+				return name;
+
+				const QString separator(QLatin1String("::"));
+
+				int i = mPrecision;
+			int begin = name.length();
+			while ((i > 0) && (begin >= 0))
+			{
+				begin = name.lastIndexOf(separator, begin - name.length() - 1);
+				i--;
+			}
+			if (begin < 0)
+				begin = 0;
+			else
+				begin += 2;
+			return name.mid(begin);
+	}
+
+
+	QDebug LoggerPatternConverter::debug(QDebug &rDebug) const
+	{
+			rDebug.nospace() << "LoggerPatternConverter("
+					<< mFormattingInfo
+					<< "precision:" << mPrecision
+					<< ")";
+			return rDebug.space();
+	}
+
+
+
+	/******************************************************************************
+	 * Class implementation: MDCPatternConverter
+	 ******************************************************************************/
+
+
+	QString MDCPatternConverter::convert(const LoggingEvent &rLoggingEvent) const
+	{
+		return rLoggingEvent.mdc().value(mKey);
+	}
+
+
+	QDebug MDCPatternConverter::debug(QDebug &rDebug) const
+	{
+			rDebug.nospace() << "MDCPatternConverter("
+					<< mFormattingInfo
+					<< "key:" << mKey
+					<< ")";
+			return rDebug.space();
+	}
+
+
+
+	/**************************************************************************
+	 * Implementation: Operators, Helper
+	 **************************************************************************/
+
+
+	#ifndef QT_NO_DEBUG_STREAM
+	QDebug operator<<(QDebug debug, const PatternFormatter &rPatternFormatter)
+	{
+			debug.nospace() << "PatternFormatter("
+					<< "pattern:" << rPatternFormatter.mPattern << " "
+					<< "converters:(";
+			int i;
+			for (i = 0; i < rPatternFormatter.mPatternConverters.size(); i++)
+			{
+				if (i > 0)
+					debug.nospace() << ", ";
+				debug.nospace() << *rPatternFormatter.mPatternConverters.at(i);
+			}
+		debug.nospace() << ") )";
+			return debug.space();
+	}
+	#endif
+
+
+#ifndef QT_NO_DEBUG_STREAM
+	QDebug operator<<(QDebug debug, const FormattingInfo &rFormattingInfo)
+	{
+		debug.nospace() << "FormattingInfo("
+					<< "min:" << FormattingInfo::intToString(rFormattingInfo.mMinLength) << " "
+					<< "max:" << FormattingInfo::intToString(rFormattingInfo.mMaxLength) << " "
+					<< "left:" << rFormattingInfo.mLeftAligned
+					<< ")";
+		return debug.space();
+	}
+#endif // QT_NO_DEBUG_STREAM
+
+
+#ifndef QT_NO_DEBUG_STREAM
+	QDebug operator<<(QDebug debug, const PatternConverter &rPatternConverter)
+	{
+		return rPatternConverter.debug(debug);
+	}
+#endif // QT_NO_DEBUG_STREAM
+
+
+
+} // namespace Log4Qt