Warning, file /libraries/qca/plugins/qca-logger/qca-logger.cpp was not indexed or was modified since last indexation (in which case cross-reference links may be missing, inaccurate or erroneous).

 /*
  * Copyright (C) 2007  Alon Bar-Lev <alon.barlev@gmail.com>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
  *
  */
 
 #include <QFile>
 #include <QTextStream>
 #include <QtCrypto>
 #include <QtPlugin>
 #include <qcaprovider.h>
 
 #include <cstdlib>
 
 using namespace QCA;
 
 namespace loggerQCAPlugin {
 
 class StreamLogger : public QCA::AbstractLogDevice
 {
     Q_OBJECT
 public:
     StreamLogger(QTextStream &stream)
         : QCA::AbstractLogDevice(QStringLiteral("Stream logger"))
         , _stream(stream)
     {
         QCA::logger()->registerLogDevice(this);
     }
 
     ~StreamLogger() override
     {
         QCA::logger()->unregisterLogDevice(name());
     }
 
     void logTextMessage(const QString &message, enum QCA::Logger::Severity severity) override
     {
         _stream << now() << " " << severityName(severity) << " " << message << Qt::endl;
     }
 
     void logBinaryMessage(const QByteArray &blob, enum QCA::Logger::Severity severity) override
     {
         Q_UNUSED(blob);
         _stream << now() << " " << severityName(severity) << " "
                 << "Binary blob not implemented yet" << Qt::endl;
     }
 
 private:
     inline const char *severityName(enum QCA::Logger::Severity severity)
     {
         if (severity <= QCA::Logger::Debug) {
             return s_severityNames[severity];
         } else {
             return s_severityNames[QCA::Logger::Debug + 1];
         }
     }
 
     inline QString now()
     {
         static const QString format = QStringLiteral("yyyy-MM-dd hh:mm:ss");
         return QDateTime::currentDateTime().toString(format);
     }
 
 private:
     static const char *s_severityNames[];
     QTextStream       &_stream;
 };
 
 const char *StreamLogger::s_severityNames[] = {"Q", "M", "A", "C", "E", "W", "N", "I", "D", "U"};
 
 }
 
 using namespace loggerQCAPlugin;
 
 class loggerProvider : public Provider
 {
 private:
     QFile         _logFile;
     QTextStream   _logStream;
     StreamLogger *_streamLogger;
     bool          _externalConfig;
 
 public:
     loggerProvider()
     {
         _externalConfig = false;
         _streamLogger   = nullptr;
 
         const QByteArray level = qgetenv("QCALOGGER_LEVEL");
         const QByteArray file  = qgetenv("QCALOGGER_FILE");
 
         if (!level.isEmpty()) {
             printf("XXXX %s %s\n", level.data(), file.data());
             _externalConfig = true;
             createLogger(atoi(level.constData()), file.isEmpty() ? QString() : QString::fromUtf8(file));
         }
     }
 
     ~loggerProvider() override
     {
         delete _streamLogger;
         _streamLogger = nullptr;
     }
 
 public:
     int qcaVersion() const override
     {
         return QCA_VERSION;
     }
 
     void init() override
     {
     }
 
     QString name() const override
     {
         return QStringLiteral("qca-logger");
     }
 
     QStringList features() const override
     {
         QStringList list;
         list += QStringLiteral("log");
         return list;
     }
 
     Context *createContext(const QString &type) override
     {
         Q_UNUSED(type);
         return nullptr;
     }
 
     QVariantMap defaultConfig() const override
     {
         QVariantMap mytemplate;
 
         mytemplate[QStringLiteral("formtype")] = QStringLiteral("http://affinix.com/qca/forms/qca-logger#1.0");
         mytemplate[QStringLiteral("enabled")]  = false;
         mytemplate[QStringLiteral("file")]     = QLatin1String("");
         mytemplate[QStringLiteral("level")]    = (int)Logger::Quiet;
 
         return mytemplate;
     }
 
     void configChanged(const QVariantMap &config) override
     {
         if (!_externalConfig) {
             delete _streamLogger;
             _streamLogger = nullptr;
 
             if (config[QStringLiteral("enabled")].toBool()) {
                 createLogger(config[QStringLiteral("level")].toInt(), config[QStringLiteral("file")].toString());
             }
         }
     }
 
 private:
     void createLogger(const int level, const QString &file)
     {
         bool success = false;
         if (file.isEmpty()) {
             success = _logFile.open(stderr, QIODevice::WriteOnly | QIODevice::Text | QIODevice::Unbuffered);
         } else {
             _logFile.setFileName(file);
             success = _logFile.open(QIODevice::Append | QIODevice::Text | QIODevice::Unbuffered);
         }
 
         if (success) {
             _logStream.setDevice(&_logFile);
             logger()->setLevel((Logger::Severity)level);
             _streamLogger = new StreamLogger(_logStream);
         }
     }
 };
 
 class loggerPlugin : public QObject, public QCAPlugin
 {
     Q_OBJECT
     Q_PLUGIN_METADATA(IID "com.affinix.qca.Plugin/1.0")
     Q_INTERFACES(QCAPlugin)
 
 public:
     Provider *createProvider() override
     {
         return new loggerProvider;
     }
 };
 
 #include "qca-logger.moc"