macro.hpp

Go to the documentation of this file.

#ifndef __LOGOG_MACRO_HPP__
#define __LOGOG_MACRO_HPP__

namespace logog
{
#ifdef LOGOG_USE_PREFIX
#define LOGOG_PREFIX LOGOG_
#endif // LOGOG_USE_PREFIX

#ifndef LOGOG_GROUP

#define LOGOG_GROUP NULL
#endif

#ifndef LOGOG_CATEGORY

#define LOGOG_CATEGORY NULL
#endif

#define TOKENPASTE2(x, y) x ## y

#define TOKENPASTE(x, y) TOKENPASTE2(x, y)

#define LOGOG_LEVEL_GROUP_CATEGORY_MESSAGE_NO_VA( level, group, cat, msg ) \
{ \
        Mutex *___pMCM = &GetMessageCreationMutex(); \
        ___pMCM->MutexLock(); \
        static logog::Message *TOKENPASTE(_logog_,__LINE__) = new logog::Message( level, \
                LOGOG_CONST_STRING( __FILE__ ), \
                __LINE__ , \
                LOGOG_CONST_STRING( group ), \
                LOGOG_CONST_STRING( cat ), \
                msg; \
        ___pMCM->MutexUnlock(); \
        TOKENPASTE(_logog_,__LINE__)->m_Transmitting.MutexLock(); \
        TOKENPASTE(_logog_,__LINE__)->Transmit(); \
        TOKENPASTE(_logog_,__LINE__)->m_Transmitting.MutexUnlock(); \
}

#define LOGOG_LEVEL_GROUP_CATEGORY_MESSAGE( level, group, cat, formatstring, ... ) \
LOGOG_MICROSOFT_PRAGMA_IN_MACRO(warning(push)) \
LOGOG_MICROSOFT_PRAGMA_IN_MACRO(warning(disable : 4127 )) \
do \
{ \
        ::logog::Mutex *___pMCM = &::logog::GetMessageCreationMutex(); \
        ___pMCM->MutexLock(); \
        static bool TOKENPASTE(_logog_static_bool_,__LINE__) = false; \
        static logog::Message * TOKENPASTE(_logog_,__LINE__); \
        if ( TOKENPASTE(_logog_static_bool_,__LINE__) == false ) \
        { \
                TOKENPASTE(_logog_,__LINE__) = \
                        new logog::Message( level, \
                                LOGOG_CONST_STRING( __FILE__ ), \
                                __LINE__ , \
                                LOGOG_CONST_STRING( group ), \
                                LOGOG_CONST_STRING( cat ), \
                                LOGOG_CONST_STRING( "" ), \
                                0.0f, \
                                & (TOKENPASTE(_logog_static_bool_,__LINE__)) ); \
        } \
        ___pMCM->MutexUnlock(); \
        /* A race condition could theoretically occur here if you are shutting down at the same instant as sending log messages. */ \
        TOKENPASTE(_logog_,__LINE__)->m_Transmitting.MutexLock(); \
        TOKENPASTE(_logog_,__LINE__)->Format( formatstring, ##__VA_ARGS__ ); \
        TOKENPASTE(_logog_,__LINE__)->Transmit(); \
        TOKENPASTE(_logog_,__LINE__)->m_Transmitting.MutexUnlock(); \
} while (false) \
LOGOG_MICROSOFT_PRAGMA_IN_MACRO(warning(pop))

#define LOGOG_LEVEL_MESSAGE( level, formatstring, ... ) \
        LOGOG_LEVEL_GROUP_CATEGORY_MESSAGE( level, LOGOG_GROUP, LOGOG_CATEGORY, formatstring, ##__VA_ARGS__ )

#define LOGOG_MESSAGE( formatstring, ... ) \
        LOGOG_LEVEL_MESSAGE( LOGOG_LEVEL, formatstring, ##__VA_ARGS__ )


#if LOGOG_LEVEL >= LOGOG_LEVEL_DEBUG

#define LOGOG_DEBUG( formatstring, ... ) \
        LOGOG_LEVEL_MESSAGE( LOGOG_LEVEL_DEBUG, formatstring, ##__VA_ARGS__ )
#else
#define LOGOG_DEBUG( formatstring, ... ) do {} while (false)
#endif

#if LOGOG_LEVEL >= LOGOG_LEVEL_INFO

#define LOGOG_INFO( formatstring, ... ) \
        LOGOG_LEVEL_MESSAGE( LOGOG_LEVEL_INFO, formatstring, ##__VA_ARGS__ )
#else
#define LOGOG_INFO( formatstring, ... ) do {} while (false)
#endif

#if LOGOG_LEVEL >= LOGOG_LEVEL_WARN3

#define LOGOG_WARN3( formatstring, ... ) \
        LOGOG_LEVEL_MESSAGE( LOGOG_LEVEL_WARN3, formatstring, ##__VA_ARGS__ )
#else
#define LOGOG_WARN3( formatstring, ... ) do {} while (false)
#endif

#if LOGOG_LEVEL >= LOGOG_LEVEL_WARN2

#define LOGOG_WARN2( formatstring, ... ) \
        LOGOG_LEVEL_MESSAGE( LOGOG_LEVEL_WARN2, formatstring, ##__VA_ARGS__ )
#else
#define LOGOG_WARN2( formatstring, ... ) do {} while (false)
#endif

#if LOGOG_LEVEL >= LOGOG_LEVEL_WARN1

#define LOGOG_WARN1( formatstring, ... ) \
        LOGOG_LEVEL_MESSAGE( LOGOG_LEVEL_WARN1, formatstring, ##__VA_ARGS__ )
#else
#define LOGOG_WARN1( formatstring, ... ) do {} while (false)
#endif

#if LOGOG_LEVEL >= LOGOG_LEVEL_WARN

#define LOGOG_WARN( formatstring, ... ) \
        LOGOG_LEVEL_MESSAGE( LOGOG_LEVEL_WARN, formatstring, ##__VA_ARGS__ )
#else
#define LOGOG_WARN( formatstring, ... ) do {} while (false)
#endif

#if LOGOG_LEVEL >= LOGOG_LEVEL_ERROR

#define LOGOG_ERROR( formatstring, ... ) \
        LOGOG_LEVEL_MESSAGE( LOGOG_LEVEL_ERROR, formatstring, ##__VA_ARGS__ )
#else
#define LOGOG_ERROR( formatstring, ... ) do {} while (false)
#endif

#if LOGOG_LEVEL >= LOGOG_LEVEL_CRITICAL

#define LOGOG_CRITICAL( formatstring, ... ) \
        LOGOG_LEVEL_MESSAGE( LOGOG_LEVEL_CRITICAL, formatstring, ##__VA_ARGS__ )
#else
#define LOGOG_CRITICAL( formatstring, ... ) do {} while (false)
#endif

#if LOGOG_LEVEL >= LOGOG_LEVEL_ALERT

#define LOGOG_ALERT( formatstring, ... ) \
        LOGOG_LEVEL_MESSAGE( LOGOG_LEVEL_ALERT, formatstring, ##__VA_ARGS__ )
#else
#define LOGOG_ALERT( formatstring, ... ) do {} while (false)
#endif

#if LOGOG_LEVEL >= LOGOG_LEVEL_EMERGENCY

#define LOGOG_EMERGENCY( formatstring, ... ) \
        LOGOG_LEVEL_MESSAGE( LOGOG_LEVEL_EMERGENCY, formatstring, ##__VA_ARGS__ )
#else
#define LOGOG_EMERGENCY( formatstring, ... ) do {} while (false)
#endif

#define LOGOG_SET_LEVEL( level ) \
        ::logog::SetDefaultLevel( level );

#ifndef LOGOG_USE_PREFIX
/* If you get compilation errors in this section, then define the flag LOGOG_USE_PREFIX during compilation, and these
 * shorthand logging macros won't exist -- you'll need to use the LOGOG_* equivalents above.
 */
/* We can't use DEBUG in Win32 unfortunately, so we use DBUG for shorthand here. */

#define DBUG(...) LOGOG_DEBUG( __VA_ARGS__ )

#define INFO(...) LOGOG_INFO( __VA_ARGS__ )

#define WARN3(...) LOGOG_WARN3( __VA_ARGS__ )

#define WARN2(...) LOGOG_WARN2( __VA_ARGS__ )

#define WARN1(...) LOGOG_WARN1( __VA_ARGS__ )

#define WARN(...) LOGOG_WARN( __VA_ARGS__ )

#define ERR(...) LOGOG_ERROR( __VA_ARGS__ )

#define ALERT(...) LOGOG_ALERT( __VA_ARGS__ )

#define CRITICAL(...) LOGOG_CRITICAL( __VA_ARGS__ )

#define EMERGENCY(...) LOGOG_EMERGENCY( __VA_ARGS__ )
#endif

#define LOGOG_INITIALIZE(...) logog::Initialize( __VA_ARGS__ )

#define LOGOG_SHUTDOWN() logog::Shutdown()

} // namespace logog

#endif // __LOGOG_MACRO_HPP_