Kwave::Logger Class Reference

#include <Logger.h>

Collaboration diagram for Kwave::Logger:

Public Types
enum	LogLevel {   Debug = 0, Info, Warning, Error,   Fatal }

Public Member Functions
	Logger ()
virtual	~Logger ()

Static Public Member Functions
static bool Q_DECL_EXPORT	open (const QString &filename)
static void Q_DECL_EXPORT	log (const QObject *sender, LogLevel level, const QString &msg)

Static Private Attributes
static QFile *	m_logfile = Q_NULLPTR

Detailed Description

This is the main application class for Kwave. It contains functions for opening and saving files, opening new windows and holds global configuration data.

Definition at line 40 of file Logger.h.

Member Enumeration Documentation

LogLevel

enum Kwave::Logger::LogLevel

Enumerator
Debug	debug message
Info	info
Warning	warning, something might have went wrong
Error	error, something failed, but is recoverable
Fatal	fatal error, not recoverable, have to exit

Definition at line 44 of file Logger.h.

        {
            Debug = 0,  
            Info,       
            Warning,    
            Error,      
            Fatal       
        } LogLevel;

Constructor & Destructor Documentation

Logger()

Kwave::Logger::Logger

(

)

Constructor

Definition at line 44 of file Logger.cpp.

{
}

~Logger()

Kwave::Logger::~Logger ( )

virtual

Destructor.

Definition at line 49 of file Logger.cpp.

References _, Info, log(), and m_logfile.

{
    if (m_logfile) {
        log(Q_NULLPTR, Kwave::Logger::Info, _("--- CLOSED / APPLICATION SHUTDOWN ---"));
        m_logfile->flush();
        delete m_logfile;
    }
}

Here is the call graph for this function:

Member Function Documentation

log()

void Kwave::Logger::log ( const QObject *  sender, LogLevel  level, const QString &  msg  )

static

log a message to the log file

Parameters

sender	pointer to the sender of the message, must be derived from QObject
level	the log level / severity
msg	the message to log

Definition at line 103 of file Logger.cpp.

References _, ELEMENTS_OF, m_logfile, and UTF8.

Referenced by Kwave::FileContext::executeCommand(), Kwave::TopWidget::loadFile(), open(), Kwave::MainWidget::saveLabels(), Kwave::CurveWidget::savePreset(), Kwave::DebugPlugin::screenshot(), and ~Logger().

{
    static const char *str_level[] = {
        "DBG", "INF", "WAR", "ERR", "FAT"
    };
    if (!m_logfile) return;

    // NOTE: it would be fine to have a way to find out the instance
    //       which this message belongs to (TopLevelWidget + MainWidget)
    Q_UNUSED(sender);

    // translate the log level into a text (syslog format)
    const char *x_status = str_level[qBound(
        Q_UINT64_C(0),
        static_cast<quint64>(level),
        static_cast<quint64>(ELEMENTS_OF(str_level)))
    ];

    // get the time stamp
    QDateTime now = QDateTime::currentDateTime();
    QString date_time = now.toString(_("yyyy-MM-dd hh:mm:ss.zzz"));

    // get the PID of the application
    long int x_pid = qApp ? static_cast<long int>(qApp->applicationPid()) : -1;

    // format the log log message
    // x-status date time x-pid x-message
    QString line;
    line.sprintf("<%s> %s %ld %s\n",
        x_status,
        UTF8(date_time),
        x_pid,
        UTF8(msg)
    );

    m_logfile->write(line.toUtf8().constData());
    m_logfile->flush();
}

Here is the caller graph for this function:

open()

bool Kwave::Logger::open ( const QString &  filename )

static

open a log file for writing

Note

must only be called once, if there already is a log file, then the old log file will be closed and the new one will be opened.

Parameters

filename

name of the log file

Returns

true if succeed, false if failed

Definition at line 59 of file Logger.cpp.

References _, Kwave::Append, DBG, Info, log(), m_logfile, name, and Kwave::MessageBox::warningContinueCancel().

Referenced by Kwave::App::newInstance().

{
    if (m_logfile) {
        qWarning("reopening log file");
        log(Q_NULLPTR, Kwave::Logger::Info, _("--- CLOSED / REOPEN ---"));
        m_logfile->flush();
        delete m_logfile;
    }
    qDebug("logging to file: '%s'", DBG(filename));

    QString name(filename);
    m_logfile = new (std::nothrow) QFile(name);
    Q_ASSERT(m_logfile);

    if (m_logfile) m_logfile->open(
        QIODevice::WriteOnly | QIODevice::Append | QIODevice::Text);
    if (!m_logfile || (!m_logfile->isWritable())) {
        if (Kwave::MessageBox::warningContinueCancel(Q_NULLPTR,
            i18n("Failed opening the log file '%1' for writing",
            filename)) != KMessageBox::Continue)
        {
            return false;
        }
    }

    /*
     * provide the "header" of an extended log file
     * see http://www.w3.org/TR/WD-logfile.html
     */

    QTextStream out(m_logfile);
    const KAboutData about_data = KAboutData::applicationData();

    out << "#Version: 1.0" << endl;
    out << "#Fields: x-status date time x-pid x-message" << endl;
    out << "#Software: " << about_data.displayName() << " "
                         << about_data.version() << endl;
    QDateTime now = QDateTime::currentDateTime();
    out << "#Start-Date: " << now.toString(_("yyyy-MM-dd hh:mm:ss")) << endl;

    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

m_logfile

QFile * Kwave::Logger::m_logfile = Q_NULLPTR

staticprivate

log file that receives the log messages (Null is allowed)

Definition at line 86 of file Logger.h.

Referenced by log(), open(), and ~Logger().

---

The documentation for this class was generated from the following files:

• libkwave/Logger.h
• libkwave/Logger.cpp