LoggerStream

#ifndef LOGGERSTREAM_H
#define LOGGERSTREAM_H

#include "dll_logger_global.h"

#include <QObject>
#include <QTextStream>
#include <QFile>
#include <QMutex>
#include <iostream>

// enum for log levels
enum LogLevels {
    LOG_INFO = 0,
    LOG_DEBUG1,
    LOG_DEBUG2,
    LOG_DEBUG3,
    LOG_WARNING,
    LOG_CRITICAL
};

// logger stream class
class LOGGERSHARED_EXPORT LoggerStream : public QObject
{
    Q_OBJECT

    QTextStream _fileStream;
    QFile _logFile;
    bool _isOpen;
    QString _fileName;

public:
    static LoggerStream *instance();
    LoggerStream& operator () (LogLevels level); // log levels input
    template <typename T>
    LoggerStream& operator << (const T& input); // template input
    LoggerStream& operator << (QVariant input);  // QVariant input
    LoggerStream& operator << (QString input); // QString input
    LoggerStream& operator << (int input);  // integer input
    LoggerStream& operator << (unsigned int input);  // unsigned integer input
    LoggerStream& operator << (float input);  // float input
    LoggerStream& operator << (double input);  // double input
    LoggerStream& operator << (char *input);  // string input
    LoggerStream& operator << (std::string input);  // integer input
    LoggerStream& operator << (std::ostream& (*pfn)(std::ostream&));  // input endl
    void setFileName(QString fileName);
    QString fileName();
    bool open();
    bool isOpen();
    void commit();

private:
    LoggerStream(QObject *parent = 0);
    ~LoggerStream();
    LoggerStream& operator = (const LoggerStream&);
    QString logLevelString(LogLevels level);
    void streamData(QString text);

    static LoggerStream *_instance;
};

#endif // LOGGERSTREAM_H


#include "loggerstream.h"

#include <QTime>
#include <QDebug>

// static instance of class
LoggerStream* LoggerStream::_instance = NULL;

/*
//  class constructor
*/
LoggerStream::LoggerStream(QObject *parent) :
    QObject(parent)
{
    _isOpen = false;
}

/*
//  return instance of singleton (static)
*/
LoggerStream * LoggerStream::instance()
{
    // create static mutex and check if the instance exists
    static QMutex _instanceMutex;
    if (_instance == NULL){
        _instanceMutex.lock();
        if (_instance == NULL)
            _instance = new LoggerStream;
        _instanceMutex.unlock();
    }
    // return the instance of the singleton
    return _instance;
}

/*
//  set the file name (public function)
*/
void LoggerStream::setFileName(QString fileName)
{
    _fileName = fileName;
}

/*
//  return file name (public function)
*/
QString LoggerStream::fileName()
{
    return _fileName;
}

/*
//  open the file (public function)
*/
bool LoggerStream::open()
{
    // check if it already open
    if (_isOpen)
        return true;

    // set attributes and open
    _logFile.setFileName(_fileName);
    if (!_logFile.open(QIODevice::WriteOnly | QIODevice::Truncate)){
        qDebug() << "failed to open file";
        return false;
    }

    // open success
    _fileStream.setDevice(&_logFile);
    _isOpen = true;
    return true;
}

/*
//  commit the log file (public function)
*/
void LoggerStream::commit()
{
    // close the stream file
    _fileStream.flush();
    _logFile.close();
    _isOpen = false;
}

/*
//  open status (public function)
*/
bool LoggerStream::isOpen()
{
    return _isOpen;
}

/*
//  log level input argument (public function)
*/
LoggerStream& LoggerStream::operator () (LogLevels level)
{
    // check if file is open
    if (!_isOpen)
        return *this;

    // create date / time stamp
    QTime time = QTime::currentTime();
    QDateTime dateTime = QDateTime::currentDateTime();

    // create log string including the log level output
    QString headerString = dateTime.date().toString() + " " + QVariant(time.hour()).toString() + " " + QVariant(time.minute()).toString()
            + " " + QVariant(time.second()).toString() + " " + QVariant(time.msec()).toString() + " " + logLevelString(level);

    // stream the data into the QTextStream
    QString fileText = QString("[") + headerString + QString("]: ");
    streamData(fileText);
    return *this;
}

/*
//  template input (public function)
*/
template <typename T>
LoggerStream& LoggerStream::operator << (const T& input)
{
    // check if file is open
    if (!_isOpen)
        return *this;

    // stream data
    streamData(QVariant(input).toString());
    return *stream;
}

/*
//  QVariant input (public function)
*/
LoggerStream& LoggerStream::operator << (QVariant input)
{
    // check if file is open
    if (!_isOpen)
        return *this;

    // stream data
    streamData(input.toString());
    return *this;
}

/*
//  QString input (public function)
*/
LoggerStream& LoggerStream::operator << (QString input)
{
    // check if file is open
    if (!_isOpen)
        return *this;

    // stream data
    streamData(input);
    return *this;
}

/*
//  integer input (public function)
*/
LoggerStream& LoggerStream::operator << (int input)
{
    // check if file is open
    if (!_isOpen)
        return *this;

    // stream data
    streamData(QVariant(input).toString());
    return *this;
}

/*
//  unsigned integer input (public function)
*/
LoggerStream& LoggerStream::operator << (unsigned int input)
{
    // check if file is open
    if (!_isOpen)
        return *this;

    // stream data
    streamData(QVariant(input).toString());
    return *this;
}

/*
//  float input (public function)
*/
LoggerStream& LoggerStream::operator << (float input)
{
    // check if file is open
    if (!_isOpen)
        return *this;

    // stream data
    streamData(QVariant(input).toString());
    return *this;
}

/*
//  double input (public function)
*/
LoggerStream& LoggerStream::operator << (double input)
{
    // check if file is open
    if (!_isOpen)
        return *this;

    // stream data
    streamData(QVariant(input).toString());
    return *this;
}

/*
//  string input (public function)
*/
LoggerStream& LoggerStream::operator << (char *input)
{
    // check if file is open
    if (!_isOpen)
        return *this;

    // stream data
    streamData(QVariant(input).toString());
    return *this;
}

/*
//  string input (public function)
*/
LoggerStream& LoggerStream::operator << (std::string input)
{
    // check if file is open
    if (!_isOpen)
        return *this;

    // stream data
    streamData(QString(input.c_str()));
    return *this;
}

/*
//  endl input (public function)
*/
LoggerStream& LoggerStream::operator << (std::ostream& (*pfn)(std::ostream&))
{
    // unused variable
    Q_UNUSED(pfn);

    // check if file is open
    if (!_isOpen)
        return *this;

    // stream data
    streamData("\n");
    return *this;
}

/*
//  write data to file (private function)
*/
void LoggerStream::streamData(QString text)
{
    // check if the file is open
    if (_isOpen){
        static QMutex fileMutex;
        fileMutex.lock();   // lock
        _fileStream << text;    // stream the text
        _fileStream.flush();    // flush data into file
        fileMutex.unlock(); // unlock
    }
}

/*
//  log level to string (private function)
*/
QString LoggerStream::logLevelString(LogLevels level)
{
    switch (level) {
    case LOG_WARNING: return "LOG_WARNING";
    case LOG_INFO: return "LOG_INFO";
    case LOG_CRITICAL: return "LOG_CRITICAL";
    case LOG_DEBUG1: return "LOG_DEBUG1";
    case LOG_DEBUG2: return "LOG_DEBUG2";
    case LOG_DEBUG3: return "LOG_DEBUG3";
    default: return "UNKNOWN";
    };
}

/*
//  class destructor
*/
LoggerStream::~LoggerStream()
{
    // commit the file
    commit();

    // delete the instance
    delete _instance;
}