rlog.h

Go to the documentation of this file.

/*****************************************************************************
 * Author:   Valient Gough <vgough@pobox.com>
 *
 *****************************************************************************
 * Copyright (c) 2002-2004, Valient Gough
 *
 * This library is free software; you can distribute it and/or modify it under
 * the terms of the GNU Lesser General Public License (LGPL), as published by
 * the Free Software Foundation; either version 2.1 of the License, or (at your
 * option) any later version.
 *
 * This library is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the LGPL in the file COPYING for more
 * details.
 *
 */
                                                                                                

#ifndef _rlog_incl_
#define _rlog_incl_

#define CONCAT2(A,B) A##B
#define CONCAT(A,B) CONCAT2(A,B)
#define STR(X) #X

#include <rlog/common.h>

// may be useful for checking from configuration files
#define CURRENT_RLOG_VERSION 20040503
extern "C" int RLogVersion();

namespace rlog
{

    class RLogChannel;
    class RLogPublisher;
    class RLogNode;

    enum LogLevel
    {
        Log_Undef    =0, 
        Log_Critical,    
        Log_Error,       
        Log_Warning,     
        Log_Notice,      
        Log_Info,        
        Log_Debug        
    };

    void RLOG_DECL RLogInit(int &argc, char **argv);


    // Get channel with a particular component name
    RLOG_DECL RLogChannel *GetComponentChannel(const char *component, 
                                     const char *path, 
                                     LogLevel level = Log_Undef);

    // the global channel receives messages for all components
    RLOG_DECL RLogChannel *GetGlobalChannel( const char *path,
                                   LogLevel level = Log_Undef);

#define DEF_CHANNEL(path,level) RLOG_CHANNEL_IMPL(RLOG_COMPONENT, path, level)
#define RLOG_CHANNEL(path) RLOG_CHANNEL_IMPL(RLOG_COMPONENT, path, rlog::Log_Undef)
#define RLOG_CHANNEL_IMPL(COMPONENT,path,level) \
    rlog::GetComponentChannel(STR(COMPONENT),path,level)

    /*
        Pre-defined channels, 
        "debug", "warning", and "error".

        You can of course defined sub-channels based on the predefined types,
        such as "debug/level1", or whatever.
    */
    extern RLOG_DECL RLogChannel *_RLDebugChannel;
    extern RLOG_DECL RLogChannel *_RLInfoChannel;
    extern RLOG_DECL RLogChannel *_RLWarningChannel;
    extern RLOG_DECL RLogChannel *_RLErrorChannel;

    struct PublishLoc
    {
        // If the compiler supports printf attribute specification on function
        // pointers, we'll use it here so that the compiler knows to check for
        // proper printf formatting.  If it doesn't support it, then we'll
        // force the check by inserting a bogus inline function..
        void (*publish)(PublishLoc *, RLogChannel *, const char *format, ... )
            PRINTF_FP(3,4);
        RLogNode *pub;
        const char *component;
        const char *fileName;
        const char *functionName;
        int lineNum;
        RLogChannel *channel;
    };

    void RLOG_DECL RLog_Register(PublishLoc *loc, RLogChannel *, 
                       const char *format, ... ) PRINTF(3,4);

    void RLOG_DECL rAssertFailed( const char *component, const char *file, 
                        const char *function, int line, 
                        const char *conditionStr );

    // if we don't have printf attributes on function pointers, but we do have
    // printf attributes, then make a bogus check function..
#if !HAVE_PRINTF_FP && HAVE_PRINTF_ATTR
    void __checkArgs(int, const char *, ... ) PRINTF(2,3);

    inline void __checkArgs(int, const char *, ...)
    { }
#endif
}

#if C99_VARIADAC_MACROS
#include <rlog/rlog-c99.h>
#elif PREC99_VARIADAC_MACROS
#include <rlog/rlog-prec99.h>
#else
#include <rlog/rlog-novariadic.h>
#endif


#define _rAssertFailed(COMPONENT, COND) \
    rlog::rAssertFailed(STR(COMPONENT),__FILE__,__FUNCTION__,__LINE__, COND)

#define rAssert( cond ) \
    do { \
        if( unlikely((cond) == false) ) \
        { rError( "Assert failed: " STR(cond) ); \
          _rAssertFailed(RLOG_COMPONENT, STR(cond)); \
        } \
    } while(0)

#define rAssertSilent( cond ) \
    do { \
        if( unlikely((cond) == false) ) \
        { _rAssertFailed(RLOG_COMPONENT, STR(cond)); } \
    } while(0)


/* @def RLOG_NO_COPY
    @brief Disables class copy constructor and operator =.

    This macro declares a private copy constructor and assignment operator
    which prevents automatic generation of these operation by the compiler.

    Attention, it switches access to private, so use it only at the end of the
    class declaration.
    */
#define RLOG_NO_COPY(CNAME) \
    private: \
        CNAME(const CNAME&); \
        CNAME & operator = (const CNAME &)


#endif // rlog.h

---