1. 加入日志；

2. 发送quit退出程序，干净终止线程

.gitignore

@@ -68,4 +68,5 @@ Thumbs.db
 
 # Binaries
 # --------
-bin/*.exe
+*.exe
+log/

FmclientUi.pro

@@ -13,6 +13,7 @@ TEMPLATE = app
 
 LIBS += -L$$PWD/lib/
 DESTDIR = $$PWD/bin
+include(./QsLog/QsLog.pri)
 
 win32 {
     LIBS += -lfmcrypt
@@ -25,6 +26,7 @@ SOURCES += main.cpp\
 HEADERS  += widget.h \
     fmcrypt.h \
     qfmclient.h \
-    app_single.h
+    app_single.h \
+    log.h
 
 FORMS    += widget.ui

QsLog/QsLog.cpp

+// Copyright (c) 2013, Razvan Petru
+// All rights reserved.
+
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+// * 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.
+// * The name of the contributors may not be used to endorse or promote products
+//   derived from this software without specific prior written permission.
+
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 THE COPYRIGHT HOLDER 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.
+
+#include "QsLog.h"
+#include "QsLogDest.h"
+#ifdef QS_LOG_SEPARATE_THREAD
+#include <QThreadPool>
+#include <QRunnable>
+#endif
+#include <QMutex>
+#include <QVector>
+#include <QDateTime>
+#include <QLatin1String>
+#include <QtGlobal>
+#include <cassert>
+#include <cstdlib>
+#include <stdexcept>
+
+namespace QsLogging
+{
+typedef QVector<DestinationPtr> DestinationList;
+
+static const char TraceString[] = "TRACE";
+static const char DebugString[] = "DEBUG";
+static const char InfoString[]  = "INFO ";
+static const char WarnString[]  = "WARN ";
+static const char ErrorString[] = "ERROR";
+static const char FatalString[] = "FATAL";
+
+// not using Qt::ISODate because we need the milliseconds too
+static const QString fmtDateTime("yyyy-MM-dd hh:mm:ss.zzz");
+
+static const char* LevelToText(Level theLevel)
+{
+    switch (theLevel) {
+        case TraceLevel:
+            return TraceString;
+        case DebugLevel:
+            return DebugString;
+        case InfoLevel:
+            return InfoString;
+        case WarnLevel:
+            return WarnString;
+        case ErrorLevel:
+            return ErrorString;
+        case FatalLevel:
+            return FatalString;
+        case OffLevel:
+            return "";
+        default: {
+            assert(!"bad log level");
+            return InfoString;
+        }
+    }
+}
+
+#ifdef QS_LOG_SEPARATE_THREAD
+class LogWriterRunnable : public QRunnable
+{
+public:
+    LogWriterRunnable(QString message, Level level);
+    virtual void run();
+
+private:
+    QString mMessage;
+    Level mLevel;
+};
+#endif
+
+class LoggerImpl
+{
+public:
+    LoggerImpl();
+
+#ifdef QS_LOG_SEPARATE_THREAD
+    QThreadPool threadPool;
+#endif
+    QMutex logMutex;
+    Level level;
+    DestinationList destList;
+};
+
+#ifdef QS_LOG_SEPARATE_THREAD
+LogWriterRunnable::LogWriterRunnable(QString message, Level level)
+    : QRunnable()
+    , mMessage(message)
+    , mLevel(level)
+{
+}
+
+void LogWriterRunnable::run()
+{
+    Logger::instance().write(mMessage, mLevel);
+}
+#endif
+
+
+LoggerImpl::LoggerImpl()
+    : level(InfoLevel)
+{
+    // assume at least file + console
+    destList.reserve(2);
+#ifdef QS_LOG_SEPARATE_THREAD
+    threadPool.setMaxThreadCount(1);
+    threadPool.setExpiryTimeout(-1);
+#endif
+}
+
+
+Logger::Logger()
+    : d(new LoggerImpl)
+{
+}
+
+Logger& Logger::instance()
+{
+    static Logger instance;
+    return instance;
+}
+
+// tries to extract the level from a string log message. If available, conversionSucceeded will
+// contain the conversion result.
+Level Logger::levelFromLogMessage(const QString& logMessage, bool* conversionSucceeded)
+{
+    if (conversionSucceeded)
+        *conversionSucceeded = true;
+
+    if (logMessage.startsWith(QLatin1String(TraceString)))
+        return TraceLevel;
+    if (logMessage.startsWith(QLatin1String(DebugString)))
+        return DebugLevel;
+    if (logMessage.startsWith(QLatin1String(InfoString)))
+        return InfoLevel;
+    if (logMessage.startsWith(QLatin1String(WarnString)))
+        return WarnLevel;
+    if (logMessage.startsWith(QLatin1String(ErrorString)))
+        return ErrorLevel;
+    if (logMessage.startsWith(QLatin1String(FatalString)))
+        return FatalLevel;
+
+    if (conversionSucceeded)
+        *conversionSucceeded = false;
+    return OffLevel;
+}
+
+Logger::~Logger()
+{
+#ifdef QS_LOG_SEPARATE_THREAD
+    d->threadPool.waitForDone();
+#endif
+    delete d;
+    d = 0;
+}
+
+void Logger::addDestination(DestinationPtr destination)
+{
+    assert(destination.data());
+    QMutexLocker lock(&d->logMutex);
+    d->destList.push_back(destination);
+}
+
+void Logger::removeDestination(const DestinationPtr& destination)
+{
+    QMutexLocker lock(&d->logMutex);
+    const int destinationIndex = d->destList.indexOf(destination);
+    if (destinationIndex != -1) {
+        d->destList.remove(destinationIndex);
+    }
+}
+
+bool Logger::hasDestinationOfType(const char* type) const
+{
+    QMutexLocker lock(&d->logMutex);
+    for (DestinationList::iterator it = d->destList.begin(),
+        endIt = d->destList.end();it != endIt;++it) {
+        if ((*it)->type() == QLatin1String(type)) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+void Logger::setLoggingLevel(Level newLevel)
+{
+    d->level = newLevel;
+}
+
+Level Logger::loggingLevel() const
+{
+    return d->level;
+}
+
+//! creates the complete log message and passes it to the logger
+void Logger::Helper::writeToLog()
+{
+    const char* const levelName = LevelToText(level);
+    const QString completeMessage(QString("%1 %2 %3")
+                                  .arg(levelName)
+                                  .arg(QDateTime::currentDateTime().toString(fmtDateTime))
+                                  .arg(buffer)
+                                  );
+
+    Logger::instance().enqueueWrite(completeMessage, level);
+}
+
+Logger::Helper::~Helper()
+{
+    try {
+        writeToLog();
+    }
+    catch(std::exception&) {
+        // you shouldn't throw exceptions from a sink
+        assert(!"exception in logger helper destructor");
+        throw;
+    }
+}
+
+//! directs the message to the task queue or writes it directly
+void Logger::enqueueWrite(const QString& message, Level level)
+{
+#ifdef QS_LOG_SEPARATE_THREAD
+    LogWriterRunnable *r = new LogWriterRunnable(message, level);
+    d->threadPool.start(r);
+#else
+    write(message, level);
+#endif
+}
+
+//! Sends the message to all the destinations. The level for this message is passed in case
+//! it's useful for processing in the destination.
+void Logger::write(const QString& message, Level level)
+{
+    QMutexLocker lock(&d->logMutex);
+    for (DestinationList::iterator it = d->destList.begin(),
+        endIt = d->destList.end();it != endIt;++it) {
+        (*it)->write(message, level);
+    }
+}
+
+} // end namespace

QsLog/QsLog.h

+// Copyright (c) 2013, Razvan Petru
+// All rights reserved.
+
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+// * 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.
+// * The name of the contributors may not be used to endorse or promote products
+//   derived from this software without specific prior written permission.
+
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 THE COPYRIGHT HOLDER 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 QSLOG_H
+#define QSLOG_H
+
+#include "QsLogLevel.h"
+#include "QsLogDest.h"
+#include <QDebug>
+#include <QString>
+
+#define QS_LOG_VERSION "2.1"
+
+namespace QsLogging
+{
+class Destination;
+class LoggerImpl; // d pointer
+
+class QSLOG_SHARED_OBJECT Logger
+{
+public:
+    static Logger& instance();
+    static Level levelFromLogMessage(const QString& logMessage, bool* conversionSucceeded = 0);
+
+    ~Logger();
+
+    //! Adds a log message destination. Don't add null destinations.
+    void addDestination(DestinationPtr destination);
+    //! Removes a previously added destination. Does nothing if destination was not previously added.
+    void removeDestination(const DestinationPtr& destination);
+    //! Checks if a destination of a specific type has been added. Pass T::Type as parameter.
+    bool hasDestinationOfType(const char* type) const;
+    //! Logging at a level < 'newLevel' will be ignored
+    void setLoggingLevel(Level newLevel);
+    //! The default level is INFO
+    Level loggingLevel() const;
+
+    //! The helper forwards the streaming to QDebug and builds the final
+    //! log message.
+    class QSLOG_SHARED_OBJECT Helper
+    {
+    public:
+        explicit Helper(Level logLevel) :
+            level(logLevel),
+            qtDebug(&buffer) {}
+        ~Helper();
+        QDebug& stream(){ return qtDebug; }
+
+    private:
+        void writeToLog();
+
+        Level level;
+        QString buffer;
+        QDebug qtDebug;
+    };
+
+private:
+    Logger();
+    Logger(const Logger&);            // not available
+    Logger& operator=(const Logger&); // not available
+
+    void enqueueWrite(const QString& message, Level level);
+    void write(const QString& message, Level level);
+
+    LoggerImpl* d;
+
+    friend class LogWriterRunnable;
+};
+
+} // end namespace
+
+//! Logging macros: define QS_LOG_LINE_NUMBERS to get the file and line number
+//! in the log output.
+#ifndef QS_LOG_LINE_NUMBERS
+#define QLOG_TRACE() \
+    if (QsLogging::Logger::instance().loggingLevel() > QsLogging::TraceLevel) {} \
+    else QsLogging::Logger::Helper(QsLogging::TraceLevel).stream()
+#define QLOG_DEBUG() \
+    if (QsLogging::Logger::instance().loggingLevel() > QsLogging::DebugLevel) {} \
+    else QsLogging::Logger::Helper(QsLogging::DebugLevel).stream()
+#define QLOG_INFO()  \
+    if (QsLogging::Logger::instance().loggingLevel() > QsLogging::InfoLevel) {} \
+    else QsLogging::Logger::Helper(QsLogging::InfoLevel).stream()
+#define QLOG_WARN()  \
+    if (QsLogging::Logger::instance().loggingLevel() > QsLogging::WarnLevel) {} \
+    else QsLogging::Logger::Helper(QsLogging::WarnLevel).stream()
+#define QLOG_ERROR() \
+    if (QsLogging::Logger::instance().loggingLevel() > QsLogging::ErrorLevel) {} \
+    else QsLogging::Logger::Helper(QsLogging::ErrorLevel).stream()
+#define QLOG_FATAL() \
+    if (QsLogging::Logger::instance().loggingLevel() > QsLogging::FatalLevel) {} \
+    else QsLogging::Logger::Helper(QsLogging::FatalLevel).stream()
+#else
+#define QLOG_TRACE() \
+    if (QsLogging::Logger::instance().loggingLevel() > QsLogging::TraceLevel) {} \
+    else  QsLogging::Logger::Helper(QsLogging::TraceLevel).stream() << __FILE__ << '@' << __LINE__
+#define QLOG_DEBUG() \
+    if (QsLogging::Logger::instance().loggingLevel() > QsLogging::DebugLevel) {} \
+    else QsLogging::Logger::Helper(QsLogging::DebugLevel).stream() << __FILE__ << '@' << __LINE__
+#define QLOG_INFO()  \
+    if (QsLogging::Logger::instance().loggingLevel() > QsLogging::InfoLevel) {} \
+    else QsLogging::Logger::Helper(QsLogging::InfoLevel).stream() << __FILE__ << '@' << __LINE__
+#define QLOG_WARN()  \
+    if (QsLogging::Logger::instance().loggingLevel() > QsLogging::WarnLevel) {} \
+    else QsLogging::Logger::Helper(QsLogging::WarnLevel).stream() << __FILE__ << '@' << __LINE__
+#define QLOG_ERROR() \
+    if (QsLogging::Logger::instance().loggingLevel() > QsLogging::ErrorLevel) {} \
+    else QsLogging::Logger::Helper(QsLogging::ErrorLevel).stream() << __FILE__ << '@' << __LINE__
+#define QLOG_FATAL() \
+    if (QsLogging::Logger::instance().loggingLevel() > QsLogging::FatalLevel) {} \
+    else QsLogging::Logger::Helper(QsLogging::FatalLevel).stream() << __FILE__ << '@' << __LINE__
+#endif
+
+#ifdef QS_LOG_DISABLE
+#include "QsLogDisableForThisFile.h"
+#endif
+
+#endif // QSLOG_H

QsLog/QsLog.pri

+INCLUDEPATH += $$PWD
+#DEFINES += QS_LOG_LINE_NUMBERS       # automatically writes the file and line for each log message
+#DEFINES += QS_LOG_DISABLE            # logging code is replaced with a no-op
+#DEFINES += QS_LOG_SEPARATE_THREAD    # messages are queued and written from a separate thread
+#DEFINES += QS_LOG_WIN_PRINTF_CONSOLE # Use fprintf instead of OutputDebugString on Windows
+SOURCES += $$PWD/QsLogDest.cpp \
+    $$PWD/QsLog.cpp \
+    $$PWD/QsLogDestConsole.cpp \
+    $$PWD/QsLogDestFile.cpp \
+    $$PWD/QsLogDestFunctor.cpp
+
+HEADERS += $$PWD/QsLogDest.h \
+    $$PWD/QsLog.h \
+    $$PWD/QsLogDestConsole.h \
+    $$PWD/QsLogLevel.h \
+    $$PWD/QsLogDestFile.h \
+    $$PWD/QsLogDisableForThisFile.h \
+    $$PWD/QsLogDestFunctor.h
+
+OTHER_FILES += \
+    $$PWD/QsLogChanges.txt \
+    $$PWD/README.md

QsLog/QsLogDest.cpp

+// Copyright (c) 2013, Razvan Petru
+// All rights reserved.
+
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+// * 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.
+// * The name of the contributors may not be used to endorse or promote products
+//   derived from this software without specific prior written permission.
+
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 THE COPYRIGHT HOLDER 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.
+
+#include "QsLogDest.h"
+#include "QsLogDestConsole.h"
+#include "QsLogDestFile.h"
+#include "QsLogDestFunctor.h"
+#include <QString>
+
+namespace QsLogging
+{
+
+Destination::~Destination()
+{
+}
+
+//! destination factory
+DestinationPtr DestinationFactory::MakeFileDestination(const QString& filePath,
+    LogRotationOption rotation, const MaxSizeBytes &sizeInBytesToRotateAfter,
+    const MaxOldLogCount &oldLogsToKeep)
+{
+    if (EnableLogRotation == rotation) {
+        QScopedPointer<SizeRotationStrategy> logRotation(new SizeRotationStrategy);
+        logRotation->setMaximumSizeInBytes(sizeInBytesToRotateAfter.size);
+        logRotation->setBackupCount(oldLogsToKeep.count);
+
+        return DestinationPtr(new FileDestination(filePath, RotationStrategyPtr(logRotation.take())));
+    }
+
+    return DestinationPtr(new FileDestination(filePath, RotationStrategyPtr(new NullRotationStrategy)));
+}
+
+DestinationPtr DestinationFactory::MakeDebugOutputDestination()
+{
+    return DestinationPtr(new DebugOutputDestination);
+}
+
+DestinationPtr DestinationFactory::MakeFunctorDestination(QsLogging::Destination::LogFunction f)
+{
+    return DestinationPtr(new FunctorDestination(f));
+}
+
+DestinationPtr DestinationFactory::MakeFunctorDestination(QObject *receiver, const char *member)
+{
+    return DestinationPtr(new FunctorDestination(receiver, member));
+}
+
+} // end namespace

QsLog/QsLogDest.h

+// Copyright (c) 2013, Razvan Petru
+// All rights reserved.
+
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+// * 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.
+// * The name of the contributors may not be used to endorse or promote products
+//   derived from this software without specific prior written permission.
+
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 THE COPYRIGHT HOLDER 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 QSLOGDEST_H
+#define QSLOGDEST_H
+
+#include "QsLogLevel.h"
+#include <QSharedPointer>
+#include <QtGlobal>
+class QString;
+class QObject;
+
+#ifdef QSLOG_IS_SHARED_LIBRARY
+#define QSLOG_SHARED_OBJECT Q_DECL_EXPORT
+#elif QSLOG_IS_SHARED_LIBRARY_IMPORT
+#define QSLOG_SHARED_OBJECT Q_DECL_IMPORT
+#else
+#define QSLOG_SHARED_OBJECT
+#endif
+
+namespace QsLogging
+{
+
+class QSLOG_SHARED_OBJECT Destination
+{
+public:
+    typedef void (*LogFunction)(const QString &message, Level level);
+
+public:
+    virtual ~Destination();
+    virtual void write(const QString& message, Level level) = 0;
+    //!
+    //! \brief isValid
+    //! \return whether the destination was created correctly
+    //!
+    virtual bool isValid() = 0;
+    //!
+    //! \brief type
+    //! \return the type as a string e.g: console, file.
+    //!         The returned value may change in different versions of QsLog, but two destinations
+    //!         of the same type will return the same value.
+    //!
+    virtual QString type() const = 0;
+};
+typedef QSharedPointer<Destination> DestinationPtr;
+
+
+// a series of "named" paramaters, to make the file destination creation more readable
+enum LogRotationOption
+{
+    DisableLogRotation = 0,
+    EnableLogRotation  = 1
+};
+
+struct QSLOG_SHARED_OBJECT MaxSizeBytes
+{
+    MaxSizeBytes() : size(0) {}
+    explicit MaxSizeBytes(qint64 size_) : size(size_) {}
+    qint64 size;
+};
+
+struct QSLOG_SHARED_OBJECT MaxOldLogCount
+{
+    MaxOldLogCount() : count(0) {}
+    explicit MaxOldLogCount(int count_) : count(count_) {}
+    int count;
+};
+
+
+//! Creates logging destinations/sinks. The caller shares ownership of the destinations with the logger.
+//! After being added to a logger, the caller can discard the pointers.
+class QSLOG_SHARED_OBJECT DestinationFactory
+{
+public:
+    static DestinationPtr MakeFileDestination(const QString& filePath,
+        LogRotationOption rotation = DisableLogRotation,
+        const MaxSizeBytes &sizeInBytesToRotateAfter = MaxSizeBytes(),
+        const MaxOldLogCount &oldLogsToKeep = MaxOldLogCount());
+    static DestinationPtr MakeDebugOutputDestination();
+    // takes a pointer to a function
+    static DestinationPtr MakeFunctorDestination(Destination::LogFunction f);
+    // takes a QObject + signal/slot
+    static DestinationPtr MakeFunctorDestination(QObject *receiver, const char *member);
+};
+
+} // end namespace
+
+#endif // QSLOGDEST_H

QsLog/QsLogDestConsole.cpp

+// Copyright (c) 2013, Razvan Petru
+// All rights reserved.
+
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+// * 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.
+// * The name of the contributors may not be used to endorse or promote products
+//   derived from this software without specific prior written permission.
+
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 THE COPYRIGHT HOLDER 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.
+
+#include "QsLogDestConsole.h"
+#include <QString>
+#include <QtGlobal>
+
+#if defined(Q_OS_UNIX) || defined(Q_OS_WIN) && defined(QS_LOG_WIN_PRINTF_CONSOLE)
+#include <cstdio>
+void QsDebugOutput::output( const QString& message )
+{
+   fprintf(stderr, "%s\n", qPrintable(message));
+   fflush(stderr);
+}
+#elif defined(Q_OS_WIN)
+#define WIN32_LEAN_AND_MEAN
+#include <Windows.h>
+void QsDebugOutput::output( const QString& message )
+{
+   OutputDebugStringW(reinterpret_cast<const WCHAR*>(message.utf16()));
+   OutputDebugStringW(L"\n");
+}
+#endif
+
+const char* const QsLogging::DebugOutputDestination::Type = "console";
+
+void QsLogging::DebugOutputDestination::write(const QString& message, Level)
+{
+    QsDebugOutput::output(message);
+}
+
+bool QsLogging::DebugOutputDestination::isValid()
+{
+    return true;
+}
+
+QString QsLogging::DebugOutputDestination::type() const
+{
+    return QString::fromLatin1(Type);
+}

QsLog/QsLogDestConsole.h

+// Copyright (c) 2013, Razvan Petru
+// All rights reserved.
+
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+// * 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.
+// * The name of the contributors may not be used to endorse or promote products
+//   derived from this software without specific prior written permission.
+
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 THE COPYRIGHT HOLDER 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 QSLOGDESTCONSOLE_H
+#define QSLOGDESTCONSOLE_H
+
+#include "QsLogDest.h"
+class QString;
+
+class QsDebugOutput
+{
+public:
+   static void output(const QString& a_message);
+};
+
+namespace QsLogging
+{
+
+// debugger sink
+class DebugOutputDestination : public Destination
+{
+public:
+    static const char* const Type;
+
+    virtual void write(const QString& message, Level level);
+    virtual bool isValid();
+    virtual QString type() const;
+};
+
+}
+
+#endif // QSLOGDESTCONSOLE_H

QsLog/QsLogDestFile.cpp

+// Copyright (c) 2013, Razvan Petru
+// All rights reserved.
+
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+// * 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.
+// * The name of the contributors may not be used to endorse or promote products
+//   derived from this software without specific prior written permission.
+
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 THE COPYRIGHT HOLDER 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.
+
+#include "QsLogDestFile.h"
+#include <QTextCodec>
+#include <QDateTime>
+#include <QString>
+#include <QtGlobal>
+#include <iostream>
+
+const int QsLogging::SizeRotationStrategy::MaxBackupCount = 10;
+
+QsLogging::RotationStrategy::~RotationStrategy()
+{
+}
+
+QsLogging::SizeRotationStrategy::SizeRotationStrategy()
+    : mCurrentSizeInBytes(0)
+    , mMaxSizeInBytes(0)
+    , mBackupsCount(0)
+{
+}
+
+void QsLogging::SizeRotationStrategy::setInitialInfo(const QFile &file)
+{
+    mFileName = file.fileName();
+    mCurrentSizeInBytes = file.size();
+}
+
+void QsLogging::SizeRotationStrategy::setInitialInfo(const QString &filePath, int fileSize)
+{
+    mFileName = filePath;
+    mCurrentSizeInBytes = fileSize;
+}
+
+void QsLogging::SizeRotationStrategy::includeMessageInCalculation(const QString &message)
+{
+    mCurrentSizeInBytes += message.toUtf8().size();
+}
+
+bool QsLogging::SizeRotationStrategy::shouldRotate()
+{
+    return mCurrentSizeInBytes > mMaxSizeInBytes;
+}
+
+// Algorithm assumes backups will be named filename.X, where 1 <= X <= mBackupsCount.
+// All X's will be shifted up.
+void QsLogging::SizeRotationStrategy::rotate()
+{
+    if (!mBackupsCount) {
+        if (!removeFileAtPath(mFileName)) {
+            std::cerr << "QsLog: backup delete failed " << qPrintable(mFileName);
+        }
+        return;
+    }
+
+     // 1. find the last existing backup than can be shifted up
+     const QString logNamePattern = mFileName + QString::fromUtf8(".%1");
+     int lastExistingBackupIndex = 0;
+     for (int i = 1;i <= mBackupsCount;++i) {
+         const QString backupFileName = logNamePattern.arg(i);
+         if (fileExistsAtPath(backupFileName)) {
+             lastExistingBackupIndex = qMin(i, mBackupsCount - 1);
+         }
+         else {
+             break;
+         }
+     }
+
+     // 2. shift up
+     for (int i = lastExistingBackupIndex;i >= 1;--i) {
+         const QString oldName = logNamePattern.arg(i);
+         const QString newName = logNamePattern.arg(i + 1);
+         removeFileAtPath(newName);
+         const bool renamed = renameFileFromTo(oldName, newName);
+         if (!renamed) {
+             std::cerr << "QsLog: could not rename backup " << qPrintable(oldName)
+                       << " to " << qPrintable(newName);
+         }
+     }
+
+     // 3. rename current log file
+     const QString newName = logNamePattern.arg(1);
+     if (fileExistsAtPath(newName)) {
+         removeFileAtPath(newName);
+     }
+     if (!renameFileFromTo(mFileName, newName)) {
+         std::cerr << "QsLog: could not rename log " << qPrintable(mFileName)
+                   << " to " << qPrintable(newName);
+     }
+}
+
+QIODevice::OpenMode QsLogging::SizeRotationStrategy::recommendedOpenModeFlag()
+{
+    return QIODevice::Append;
+}
+
+void QsLogging::SizeRotationStrategy::setMaximumSizeInBytes(qint64 size)
+{
+    Q_ASSERT(size >= 0);
+    mMaxSizeInBytes = size;
+}
+
+void QsLogging::SizeRotationStrategy::setBackupCount(int backups)
+{
+    Q_ASSERT(backups >= 0);
+    mBackupsCount = qMin(backups, SizeRotationStrategy::MaxBackupCount);
+}
+
+bool QsLogging::SizeRotationStrategy::removeFileAtPath(const QString &path)
+{
+    return QFile::remove(path);
+}
+
+bool QsLogging::SizeRotationStrategy::fileExistsAtPath(const QString &path)
+{
+    return QFile::exists(path);
+}
+
+bool QsLogging::SizeRotationStrategy::renameFileFromTo(const QString &from, const QString &to)
+{
+    return QFile::rename(from, to);
+}
+
+const char* const QsLogging::FileDestination::Type = "file";
+
+QsLogging::FileDestination::FileDestination(const QString& filePath, RotationStrategyPtr rotationStrategy)
+    : mRotationStrategy(rotationStrategy)
+{
+    mFile.setFileName(filePath);
+    if (!mFile.open(QFile::WriteOnly | QFile::Text | mRotationStrategy->recommendedOpenModeFlag())) {
+        std::cerr << "QsLog: could not open log file " << qPrintable(filePath);
+    }
+    mOutputStream.setDevice(&mFile);
+    mOutputStream.setCodec(QTextCodec::codecForName("UTF-8"));
+
+    mRotationStrategy->setInitialInfo(mFile);
+}
+
+void QsLogging::FileDestination::write(const QString& message, Level)
+{
+    mRotationStrategy->includeMessageInCalculation(message);
+    if (mRotationStrategy->shouldRotate()) {
+        mOutputStream.setDevice(NULL);
+        mFile.close();
+        mRotationStrategy->rotate();
+        if (!mFile.open(QFile::WriteOnly | QFile::Text | mRotationStrategy->recommendedOpenModeFlag())) {
+            std::cerr << "QsLog: could not reopen log file " << qPrintable(mFile.fileName());
+        }
+        mRotationStrategy->setInitialInfo(mFile);
+        mOutputStream.setDevice(&mFile);
+        mOutputStream.setCodec(QTextCodec::codecForName("UTF-8"));
+    }
+
+    mOutputStream << message << endl;
+    mOutputStream.flush();
+}
+
+bool QsLogging::FileDestination::isValid()
+{
+    return mFile.isOpen();
+}
+
+QString QsLogging::FileDestination::type() const
+{
+    return QString::fromLatin1(Type);
+}
+

QsLog/QsLogDestFile.h

+// Copyright (c) 2013, Razvan Petru
+// All rights reserved.
+
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+// * 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.
+// * The name of the contributors may not be used to endorse or promote products
+//   derived from this software without specific prior written permission.
+
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 THE COPYRIGHT HOLDER 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 QSLOGDESTFILE_H
+#define QSLOGDESTFILE_H
+
+#include "QsLogDest.h"
+#include <QFile>
+#include <QTextStream>
+#include <QtGlobal>
+#include <QSharedPointer>
+
+namespace QsLogging
+{
+class RotationStrategy
+{
+public:
+    virtual ~RotationStrategy();
+
+    virtual void setInitialInfo(const QFile &file) = 0;
+    virtual void includeMessageInCalculation(const QString &message) = 0;
+    virtual bool shouldRotate() = 0;
+    virtual void rotate() = 0;
+    virtual QIODevice::OpenMode recommendedOpenModeFlag() = 0;
+};
+
+// Never rotates file, overwrites existing file.
+class NullRotationStrategy : public RotationStrategy
+{
+public:
+    virtual void setInitialInfo(const QFile &) {}
+    virtual void includeMessageInCalculation(const QString &) {}
+    virtual bool shouldRotate() { return false; }
+    virtual void rotate() {}
+    virtual QIODevice::OpenMode recommendedOpenModeFlag() { return QIODevice::Truncate; }
+};
+
+// Rotates after a size is reached, keeps a number of <= 10 backups, appends to existing file.
+class SizeRotationStrategy : public RotationStrategy
+{
+public:
+    SizeRotationStrategy();
+    static const int MaxBackupCount;
+
+    virtual void setInitialInfo(const QFile &file);
+    void setInitialInfo(const QString& filePath, int fileSize);
+    virtual void includeMessageInCalculation(const QString &message);
+    virtual bool shouldRotate();
+    virtual void rotate();
+    virtual QIODevice::OpenMode recommendedOpenModeFlag();
+
+    void setMaximumSizeInBytes(qint64 size);
+    void setBackupCount(int backups);
+
+protected:
+    // can be overridden for testing
+    virtual bool removeFileAtPath(const QString& path);
+    virtual bool fileExistsAtPath(const QString& path);
+    virtual bool renameFileFromTo(const QString& from, const QString& to);
+
+private:
+    QString mFileName;
+    qint64 mCurrentSizeInBytes;
+    qint64 mMaxSizeInBytes;
+    int mBackupsCount;
+};
+
+typedef QSharedPointer<RotationStrategy> RotationStrategyPtr;
+
+// file message sink
+class FileDestination : public Destination
+{
+public:
+    static const char* const Type;
+
+    FileDestination(const QString& filePath, RotationStrategyPtr rotationStrategy);
+    virtual void write(const QString& message, Level level);
+    virtual bool isValid();
+    virtual QString type() const;
+
+private:
+    QFile mFile;
+    QTextStream mOutputStream;
+    QSharedPointer<RotationStrategy> mRotationStrategy;
+};
+
+}
+
+#endif // QSLOGDESTFILE_H

QsLog/QsLogDestFunctor.cpp

+// Copyright (c) 2014, Razvan Petru
+// Copyright (c) 2014, Omar Carey
+// All rights reserved.
+
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+// * 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.
+// * The name of the contributors may not be used to endorse or promote products
+//   derived from this software without specific prior written permission.
+
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 THE COPYRIGHT HOLDER 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.
+
+#include "QsLogDestFunctor.h"
+#include <cstddef>
+#include <QtGlobal>
+#include <QString>
+
+const char* const QsLogging::FunctorDestination::Type = "functor";
+
+QsLogging::FunctorDestination::FunctorDestination(LogFunction f)
+    : QObject(NULL)
+    , mLogFunction(f)
+{
+}
+
+QsLogging::FunctorDestination::FunctorDestination(QObject *receiver, const char *member)
+    : QObject(NULL)
+    , mLogFunction(NULL)
+{
+    connect(this, SIGNAL(logMessageReady(QString,int)), receiver, member, Qt::QueuedConnection);
+}
+
+
+void QsLogging::FunctorDestination::write(const QString &message, QsLogging::Level level)
+{
+    if (mLogFunction)
+        mLogFunction(message, level);
+
+    if (level > QsLogging::TraceLevel)
+        emit logMessageReady(message, static_cast<int>(level));
+}
+
+bool QsLogging::FunctorDestination::isValid()
+{
+    return true;
+}
+
+QString QsLogging::FunctorDestination::type() const
+{
+    return QString::fromLatin1(Type);
+}

QsLog/QsLogDestFunctor.h

+// Copyright (c) 2014, Razvan Petru
+// Copyright (c) 2014, Omar Carey
+// All rights reserved.
+
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+// * 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.
+// * The name of the contributors may not be used to endorse or promote products
+//   derived from this software without specific prior written permission.
+
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 THE COPYRIGHT HOLDER 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 QSLOGDESTFUNCTOR_H
+#define QSLOGDESTFUNCTOR_H
+
+#include "QsLogDest.h"
+#include <QObject>
+
+namespace QsLogging
+{
+// Offers various types of function-like sinks.
+// This is an advanced destination type. Depending on your configuration, LogFunction might be
+// called from a different thread or even a different binary. You should not access QsLog from
+// inside LogFunction and should not perform any time-consuming operations.
+// logMessageReady is connected through a queued connection and trace messages are not included
+class FunctorDestination : public QObject, public Destination
+{
+    Q_OBJECT
+public:
+    static const char* const Type;
+
+    explicit FunctorDestination(LogFunction f);
+    FunctorDestination(QObject *receiver, const char *member);
+
+    virtual void write(const QString &message, Level level);
+    virtual bool isValid();
+    virtual QString type() const;
+
+protected:
+    // int used to avoid registering a new enum type
+    Q_SIGNAL void logMessageReady(const QString &message, int level);
+
+private:
+    LogFunction mLogFunction;
+};
+}
+
+#endif // QSLOGDESTFUNCTOR_H

QsLog/QsLogDisableForThisFile.h

+#ifndef QSLOGDISABLEFORTHISFILE_H
+#define QSLOGDISABLEFORTHISFILE_H
+
+#include <QtDebug>
+// When included AFTER QsLog.h, this file will disable logging in that C++ file. When included
+// before, it will lead to compiler warnings or errors about macro redefinitions.
+
+#undef QLOG_TRACE
+#undef QLOG_DEBUG
+#undef QLOG_INFO()
+#undef QLOG_WARN
+#undef QLOG_ERROR
+#undef QLOG_FATAL
+
+#define QLOG_TRACE() if (1) {} else QLOG_INFO()
+#define QLOG_DEBUG() if (1) {} else QLOG_INFO()
+#define QLOG_INFO()()  if (1) {} else QLOG_INFO()
+#define QLOG_WARN()  if (1) {} else QLOG_INFO()
+#define QLOG_ERROR() if (1) {} else QLOG_INFO()
+#define QLOG_FATAL() if (1) {} else QLOG_INFO()
+
+#endif // QSLOGDISABLEFORTHISFILE_H

QsLog/QsLogLevel.h

+// Copyright (c) 2013, Razvan Petru
+// All rights reserved.
+
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+// * 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.
+// * The name of the contributors may not be used to endorse or promote products
+//   derived from this software without specific prior written permission.
+
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 THE COPYRIGHT HOLDER 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 QSLOGLEVEL_H
+#define QSLOGLEVEL_H
+
+namespace QsLogging
+{
+
+enum Level
+{
+    TraceLevel = 0,
+    DebugLevel,
+    InfoLevel,
+    WarnLevel,
+    ErrorLevel,
+    FatalLevel,
+    OffLevel
+};
+
+}
+
+#endif // QSLOGLEVEL_H

log.h

+#ifndef LOG
+#define LOG
+#include "QsLog/QsLog.h"
+#include <QDir>
+
+static void InitLogger()
+{
+    QString logPath = qApp->applicationDirPath()+"/log";
+    QString logName = qApp->applicationName().append(".log");
+    QsLogging::Level logLevel = QsLogging::TraceLevel;
+    if(logLevel < QsLogging::TraceLevel || logLevel > QsLogging::OffLevel) {
+        logLevel = QsLogging::TraceLevel;
+    }
+    int logSize = 1;
+    int logCount = 20;
+
+    QDir logDir(logPath);
+    if(!logDir.exists()) {
+        logDir.mkpath(logDir.absolutePath());
+    }
+    QString logFilePath = logDir.absolutePath()+'/'+logName;
+    QsLogging::Logger& logger = QsLogging::Logger::instance();
+    logger.setLoggingLevel(logLevel);
+
+    /* 配置输出定向器 */
+    /* 输出到指定文件 */
+    QsLogging::DestinationPtr fileDestination(QsLogging::DestinationFactory::MakeFileDestination(
+                                                  logFilePath,
+                                                  QsLogging::EnableLogRotation, QsLogging::MaxSizeBytes(1024*1024*logSize),
+                                                  QsLogging::MaxOldLogCount(logCount)));
+    logger.addDestination(fileDestination);
+    /* 输出到控制台 */
+    QsLogging::DestinationPtr consleDest(QsLogging::DestinationFactory::MakeDebugOutputDestination());
+    logger.addDestination(consleDest);
+}
+
+#endif // LOG
+

main.cpp

@@ -2,6 +2,7 @@
 #include <QApplication>
 #include "qfmclient.h"
 #include "app_single.h"
+#include "log.h"
 
 int main(int argc, char *argv[])
 {
@@ -11,10 +12,13 @@ int main(int argc, char *argv[])
         OutputDebugString(L"FmclientUi running.");
         return 0;
     }
+    InitLogger();
+    QLOG_INFO()<<"start FmclientUi...";
     Widget w;
     QFmClient client;
     QObject::connect(&client,&QFmClient::HideUi, &w, &Widget::hide,Qt::QueuedConnection);
     QObject::connect(&client,&QFmClient::ShowUi, &w, &Widget::showTop,Qt::QueuedConnection);
+    QObject::connect(&client,&QFmClient::finished, &a, &a.quit);
     client.start();
     return a.exec();
 }

qfmclient.cpp

@@ -9,6 +9,7 @@
 #include <Qdebug>
 #include <QApplication>
 #include <QWidget>
+#include "QsLog/QsLog.h"
 
 #ifdef WIN32
 #include <direct.h>
@@ -272,13 +273,13 @@ int QFmClient::WaitAndReadDataFromPos(int type, int flag)
 #endif
         precvBuf = _tempbuf;
 
-        _tempbuf[recbytes] = '\0';
+        _tempbuf[recbytes] = '\0';            
 
         if(1 == flag)
             precvBuf = DecodeRecvData(_tempbuf, recbytes, &recbytes);
 
-        qDebug() << "received data from socket " << _acceptedSock << " : " << precvBuf;
-
+        qDebug() << "received data from pos " << _acceptedSock << " : \n" << precvBuf;
+        QLOG_INFO()<< "received data from pos " << _acceptedSock << " : \n" << precvBuf;
         while(0 < recbytes)
         {
             finLen = CheckIsCompleteJsonData(&checkCount, precvBuf + prosLen);
@@ -559,7 +560,8 @@ int QFmClient::RecvAndCheckDataFromSock(int sock, int flag, int type)  //type =
             precvBuf = DecodeRecvData(_tempbuf, recbytes, &recbytes);
         }
 
-        qDebug() << "received data from socket " << sock << " : " << precvBuf;
+        qDebug() << "received data from Proxy " << sock << " :\n " << precvBuf;
+        QLOG_INFO() << "received data from Proxy " << sock << " :\n " << precvBuf;
 
         while(0 < recbytes)
         {
@@ -610,9 +612,10 @@ int QFmClient::SendData2ZhProxyAndWaitRspData()
     if (rlt != length)
     {
 #ifdef WIN32
-        qDebug() << "recv() return : " << rlt << ";error : " << WSAGetLastError() << ";\r\n";
+        qDebug() << "send data to ZhProxy return : " << rlt << ";error : " << WSAGetLastError() << ";\r\n";
+        QLOG_ERROR()<< "send data to ZhProxy return : " << rlt << ";error : " << WSAGetLastError() << ";\r\n";
 #endif
-        qDebug() << "send data to socket failed!\r\n";
+        qDebug() << "send data to ZhProxy failed!\r\n";
         return -1;
     }
 
@@ -621,6 +624,7 @@ int QFmClient::SendData2ZhProxyAndWaitRspData()
     if (0 != RecvAndCheckDataFromSock(_zhProxySock, _codeFlag,0))
     {
          qDebug() << "receive data or check data failed\r\n";
+         QLOG_ERROR() << "receive data or check data failed\r\n";
          return -1;
     }
 
@@ -661,11 +665,12 @@ int QFmClient::ProcessZhProxyRspDataAndSend2Pos()
     if (rlt != length)
     {
 #ifdef WIN32
-        qDebug() << "recv() return : " << rlt << ";error : " << WSAGetLastError() << ";\r\n";
+        qDebug() << "send to pos return : " << rlt << ";error : " << WSAGetLastError() << ";\r\n";
+        QLOG_ERROR()<< "send to pos return : " << rlt << ";error : " << WSAGetLastError() << ";\r\n";
 #endif
         return -1;
     }
-
+    QLOG_INFO() <<"send to pos:\n"<<_recvbuf;
     return  0;
 }
 
@@ -717,8 +722,13 @@ void QFmClient::run()
 
             if (0 != WaitAndReadDataFromPos(1, 0))
             {
+                if(strcmp(_tempbuf,"quit") == 0)
+                {
+                    closesocket(_acceptedSock);
+                    quit();
+                    break;
+                }
                 CloseSocket(&_acceptedSock);
-
                 continue;
             }
             emit ShowUi();
@@ -737,6 +747,7 @@ void QFmClient::run()
             if (0 != Try2ConnectZhProxy())
             {
                 qDebug() << "connect to proxy failed";
+                QLOG_ERROR() << "connect to proxy failed";
                 CloseSocket(&_acceptedSock);
                 emit HideUi();
                 continue;
@@ -752,6 +763,7 @@ void QFmClient::run()
             memset(_sendbuf, 0, MAX_BUF_LEN);
             QString temp = QString(QJsonDocument(object).toJson());
             strcpy(_sendbuf, temp.toStdString().c_str());
+            QLOG_INFO()<<"send to ZhProxy:\n"<<_sendbuf;
 
             rlt = SendData2ZhProxyAndWaitRspData();
 
@@ -781,13 +793,14 @@ void QFmClient::run()
 
     }while(!isInterruptionRequested());
 
-    qDebug() << "Exit ZH Client!\r\n";
-    OutputDebugString(L"Exit ZH Client!\r\n");
+    qDebug() << "Exit FmclientUi!\r\n";
+    OutputDebugString(L"Exit FmclientUi!\r\n");
 
 #ifdef WIN32
     WSACleanup();
 #endif
 
+    QLOG_INFO()<< "Exit FmclientUi!\r\n\n";
 }
 
 void QFmClient::quit()
@@ -846,6 +859,7 @@ bool QFmClient::StartListenport()
     }
 
     qDebug()<<"listen "<<_clientPort;
+    QLOG_INFO()<<"listen at "<<_clientPort;
     return true;
 }