src/debug.h

   1 // Author:    Max Howell <max.howell@methylblue.com>, (C) 2003-5
   2 // Copyright: See COPYING file that comes with this distribution
   3 //
   4
   5 #ifndef AMAROK_DEBUG_H
   6 #define AMAROK_DEBUG_H
   7
   8 #include <kdebug.h>
   9 #include <QApplication>
  10 #include <QMutex>
  11 #include <QObject>
  12
  13 #include <iostream>
  14 #include <sys/time.h>
  15
  16 #include "amarok_export.h"
  17
  18 #ifdef _WIN32
  19 #define __PRETTY_FUNCTION__ __FUNCTION__
  20 #endif
  21
  22 /**
  23  * @namespace Debug
  24  * @short kdebug with indentation functionality and convenience macros
  25  * @author Max Howell <max.howell@methylblue.com>
  26  *
  27  * Usage:
  28  *
  29  *     #define DEBUG_PREFIX "Blah"
  30  *     #include "debug.h"
  31  *
  32  *     void function()
  33  *     {
  34  *        Debug::Block myBlock( __PRETTY_FUNCTION__ );
  35  *
  36  *        debug() << "output1" << endl;
  37  *        debug() << "output2" << endl;
  38  *     }
  39  *
  40  * Will output:
  41  *
  42  * app: BEGIN: void function()
  43  * app:   [Blah] output1
  44  * app:   [Blah] output2
  45  * app: END: void function(): Took 0.1s
  46  *
  47  * @see Block
  48  * @see CrashHelper
  49  * @see ListStream
  50  */
  51
  52 namespace Debug
  53 {
  54     extern AMAROK_EXPORT QMutex mutex; // defined in app.cpp
  55
  56     // we can't use a statically instantiated QCString for the indent, because
  57     // static namespaces are unique to each dlopened library. So we piggy back
  58     // the QCString on the KApplication instance
  59
  60     #define qOApp reinterpret_cast<QObject*>(qApp)
  61     class Indent : QObject
  62     {
  63         friend QString &modifieableIndent();
  64         Indent() : QObject( qOApp ) { setObjectName( "DEBUG_indent" ); }
  65         QString m_string;
  66     };
  67
  68     inline QString &modifieableIndent()
  69     {
  70         QObject* o = qOApp ? qOApp->findChild<QObject*>( "DEBUG_indent" ) : 0;
  71         QString &ret = (o ? static_cast<Indent*>( o ) : new Indent)->m_string;
  72         return ret;
  73     }
  74
  75     inline QString indent()
  76     {
  77         return modifieableIndent();
  78     }
  79     #undef qApp
  80
  81
  82     #ifdef NDEBUG
  83         static inline kndbgstream debug()   { return kndbgstream(); }
  84         static inline kndbgstream warning() { return kndbgstream(); }
  85         static inline kndbgstream error()   { return kndbgstream(); }
  86         static inline kndbgstream fatal()   { return kndbgstream(); }
  87
  88         typedef kndbgstream DebugStream;
  89     #else
  90         #ifndef DEBUG_PREFIX
  91         #define AMK_PREFIX ""
  92         #else
  93         #define AMK_PREFIX "[" DEBUG_PREFIX "] "
  94         #endif
  95
  96         //from kdebug.h
  97         enum DebugLevels {
  98             KDEBUG_INFO  = 0,
  99             KDEBUG_WARN  = 1,
 100             KDEBUG_ERROR = 2,
 101             KDEBUG_FATAL = 3
 102         };
 103
 104         static inline kdbgstream debug()   { mutex.lock(); QString ind = indent(); mutex.unlock(); return kdbgstream( QtDebugMsg ) << ind + AMK_PREFIX; }
 105         static inline kdbgstream warning() { mutex.lock(); QString ind = indent(); mutex.unlock(); return kdbgstream( QtDebugMsg ) << ind + AMK_PREFIX << "[WARNING!] "; }
 106         static inline kdbgstream error()   { mutex.lock(); QString ind = indent(); mutex.unlock(); return kdbgstream( QtDebugMsg ) << ind + AMK_PREFIX << "[ERROR!] "; }
 107         static inline kdbgstream fatal()   { mutex.lock(); QString ind = indent(); mutex.unlock(); return kdbgstream( QtDebugMsg ) << ind + AMK_PREFIX; }
 108
 109         typedef kdbgstream DebugStream;
 110
 111         #undef AMK_PREFIX
 112     #endif
 113
 114     typedef kndbgstream NoDebugStream;
 115 }
 116
 117 using Debug::debug;
 118 using Debug::warning;
 119 using Debug::error;
 120 using Debug::fatal;
 121 using Debug::DebugStream;
 122
 123 /// Standard function announcer
 124 #define DEBUG_FUNC_INFO { Debug::mutex.lock(); kDebug() << Debug::indent() << k_funcinfo << endl; Debug::mutex.unlock(); }
 125
 126 /// Announce a line
 127 #define DEBUG_LINE_INFO { Debug::mutex.lock(); kDebug() << Debug::indent() << k_funcinfo << "Line: " << __LINE__ << endl; Debug::mutex.unlock(); }
 128
 129 /// Convenience macro for making a standard Debug::Block
 130 #define DEBUG_BLOCK Debug::Block uniquelyNamedStackAllocatedStandardBlock( __PRETTY_FUNCTION__ );
 131
 132 /// Use this to remind yourself to finish the implementation of a function
 133 #define AMAROK_NOTIMPLEMENTED warning() << "NOT-IMPLEMENTED: " << __PRETTY_FUNCTION__ << endl;
 134
 135 /// Use this to alert other developers to stop using a function
 136 #define AMAROK_DEPRECATED warning() << "DEPRECATED: " << __PRETTY_FUNCTION__ << endl;
 137
 138
 139 namespace Debug
 140 {
 141     /**
 142      * @class Debug::Block
 143      * @short Use this to label sections of your code
 144      *
 145      * Usage:
 146      *
 147      *     void function()
 148      *     {
 149      *         Debug::Block myBlock( "section" );
 150      *
 151      *         debug() << "output1" << endl;
 152      *         debug() << "output2" << endl;
 153      *     }
 154      *
 155      * Will output:
 156      *
 157      *     app: BEGIN: section
 158      *     app:  [prefix] output1
 159      *     app:  [prefix] output2
 160      *     app: END: section - Took 0.1s
 161      *
 162      */
 163
 164     class Block
 165     {
 166         timeval     m_start;
 167         const char *m_label;
 168
 169     public:
 170         Block( const char *label )
 171                 : m_label( label )
 172         {
 173             mutex.lock();
 174             gettimeofday( &m_start, 0 );
 175
 176             kDebug() << "BEGIN: " << label << "\n";
 177             Debug::modifieableIndent() += "  ";
 178             mutex.unlock();
 179         }
 180
 181         ~Block()
 182         {
 183             mutex.lock();
 184             timeval end;
 185             gettimeofday( &end, 0 );
 186
 187             end.tv_sec -= m_start.tv_sec;
 188             if( end.tv_usec < m_start.tv_usec) {
 189                 // Manually carry a one from the seconds field.
 190                 end.tv_usec += 1000000;
 191                 end.tv_sec--;
 192             }
 193             end.tv_usec -= m_start.tv_usec;
 194
 195             double duration = double(end.tv_sec) + (double(end.tv_usec) / 1000000.0);
 196
 197             Debug::modifieableIndent().truncate( Debug::indent().length() - 2 );
 198             kDebug() << "END__: " << m_label
 199                       << " - Took " << QString::number( duration, 'g', 2 ) << "s\n";
 200             mutex.unlock();
 201         }
 202     };
 203
 204
 205     /**
 206      * @name Debug::stamp()
 207      * @short To facilitate crash/freeze bugs, by making it easy to mark code that has been processed
 208      *
 209      * Usage:
 210      *
 211      *     {
 212      *         Debug::stamp();
 213      *         function1();
 214      *         Debug::stamp();
 215      *         function2();
 216      *         Debug::stamp();
 217      *     }
 218      *
 219      * Will output (assuming the crash occurs in function2()
 220      *
 221      *     app: Stamp: 1
 222      *     app: Stamp: 2
 223      *
 224      */
 225
 226     inline void stamp()
 227     {
 228         static int n = 0;
 229         debug() << "| Stamp: " << ++n << endl;
 230     }
 231 }
 232
 233
 234 #include <QVariant>
 235
 236 namespace Debug
 237 {
 238     /**
 239      * @class Debug::List
 240      * @short You can pass anything to this and it will output it as a list
 241      *
 242      *     debug() << (Debug::List() << anInt << aString << aQStringList << aDouble) << endl;
 243      */
 244
 245     typedef QList<QVariant> List;
 246 }
 247
 248 #endif