test_sdk/core/gtl_logger.cpp

#include "gtl_logger.h"

#include <QDateTime>
#include <QRegularExpression>
#include <QFileInfo>

namespace gtl
{
    QFile logger::_log_file;
    QString logger::_path;
    QString logger::_file_name;
    QThread logger::_thread;
    uint32_t logger::_max_file_size;
    uint32_t logger::_max_index;

    logger::logger(QObject *parent)
        : QObject{parent}
    {
        _is_continue = false;
        open_file();
    }

    logger::~logger()
    {
        if(_log_file.isOpen())
            _log_file.close();
        _thread.wait();
    }

    logger* logger::getInstance()
    {
        static logger instance;
        return &instance;
    }

    void logger::init(const QString &path, const uint32_t max_file_size, const file_size_unit unit)
    {
        _path = path;
        _max_file_size = max_file_size << get_file_size_unit(unit);
        _file_name = find_last_file();

        connect(getInstance(), &logger::sgn_info, getInstance(), &logger::slt_info);
        connect(getInstance(), &logger::sgn_warning, getInstance(), &logger::slt_warning);
        connect(getInstance(), &logger::sgn_error, getInstance(), &logger::slt_error);
        connect(getInstance(), &logger::sgn_debug, getInstance(), &logger::slt_debug);

        getInstance()->moveToThread(&_thread);
        _thread.start();
    }

    void logger::open_file()
    {
        if(_log_file.isOpen())
            _log_file.close();

        _log_file.setFileName(_file_name );

        _log_file.open( QIODevice::WriteOnly | QIODevice::Append | QIODevice::Text );

        if( !_log_file.isOpen() )
            throw std::iostream::failure("Cannot open file: " + _file_name.toStdString());
    }

    QString logger::find_last_file()
    {
        QString file_name = _path + QDir::separator() + "log_0000";
        QRegularExpression reNameLogFile("^log_(\\d{4})$");

        QDir currentDir = QDir(_path);

        if(false == currentDir.exists())
            currentDir.mkdir(_path);

        QStringList filters;
        filters << "log_*";
        QStringList filesList = currentDir.entryList(filters, QDir::Files | QDir::NoSymLinks);

        if(!filesList.isEmpty())
        {
            _max_index = 0;
            uint32_t current_index = 0;
            bool flagFindCorrectName = false;

            while(!filesList.isEmpty())
            {
                QString fName = filesList.at(0);
                filesList.removeFirst();

                QRegularExpressionMatch match = reNameLogFile.match(fName);
                if(!match.hasMatch())
                    continue;

                flagFindCorrectName = true;
                fName.replace("log_", "");
                current_index = fName.toUInt();

                _max_index = ((_max_index < current_index) ? current_index : _max_index);
            }

            if(flagFindCorrectName)
            {
                file_name = _path + QDir::separator() + "log_" + QString::number(_max_index).rightJustified(4, '0');
                if(false == check_file_size(file_name))
                {
                    _max_index += 1;
                    file_name = _path + QDir::separator() + "log_" + QString::number(_max_index).rightJustified(4, '0');
                }
            }
        }

        return file_name;
    }

    bool logger::check_file_size(const QString& path)
    {
        QFileInfo info1(path);
        return  (info1.size() >= _max_file_size) ? false : true;
    }

    void logger::info(const QString &tag, const QString &str)
    {
        if(getInstance() != nullptr)
            emit getInstance()->sgn_info(tag, str);
    }

    void logger::warning(const QString &tag, const QString &str)
    {
        if(getInstance() != nullptr)
            emit getInstance()->sgn_warning(tag, str);
    }

    void logger::error(const QString &tag, const QString &str)
    {
        if(getInstance() != nullptr)
            emit getInstance()->sgn_error(tag, str);
    }

    void logger::debug(const QString &tag, const QString &str)
    {
        if(getInstance() != nullptr)
            emit getInstance()->sgn_debug(tag, str);
    }

    uint32_t logger::get_file_size_unit(const file_size_unit unit)
    {
        uint32_t temp;
        switch(unit) {
            case file_size_unit::b:     temp = 0; break;
            case file_size_unit::kb:    temp = 10; break;
            case file_size_unit::mb:    temp = 20; break;
            case file_size_unit::gb:    temp = 30; break;
        }
        return temp;
    }

    QString logger::get_level_string(const log_level level)
    {
        QString temp;
        switch(level) {
            case log_level::info:       temp = "INFO"; break;
            case log_level::warning:    temp = "WARNING"; break;
            case log_level::debug:      temp = "DEBUG"; break;
            case log_level::error:      temp = "ERROR"; break;
        }
        return temp;
    }

    QString logger::get_time_string()
    {
        //** for debug **
        //QThread::sleep(5);
        //** for debug **

        QDateTime m_dateTime = QDateTime::currentDateTime();
        return m_dateTime.toString("hh:mm:ss.zzz");
    }

    QString logger::get_date_string()
    {
        QDateTime m_dateTime = QDateTime::currentDateTime();
        return m_dateTime.toString("dd.MM.yyyy");
    }
}