---

pvlogger.h

Go to the documentation of this file.

#ifndef PVLOGGER_H_INCLUDED
#define PVLOGGER_H_INCLUDED

#ifndef OSCL_BASE_H_INCLUDED
#include "oscl_base.h"
#endif

#ifndef OSCL_VECTOR_H_INCLUDED
#include "oscl_vector.h"
#endif

#ifndef OSCL_DEFALLOC_H_INCLUDED
#include "oscl_defalloc.h"
#endif

#ifndef OSCL_SHARED_PTR_H
#include "oscl_shared_ptr.h"
#endif

#ifndef OSCL_BASE_ALLOC_H_INCLUDED
#include "oscl_base_alloc.h"
#endif


const int32 PVLOGGER_LEVEL_UNINTIALIZED = -1;



// The instrumentation layer allows groups
// of messages to be compiled in or out of
// the code based on a build-time parameter.

#define PVLOGMSG_INST_REL   0

#define PVLOGMSG_INST_PROF  1

#define PVLOGMSG_INST_HLDBG 2

#define PVLOGMSG_INST_MLDBG 3

#define PVLOGMSG_INST_LLDBG 4

/*
** Default logger instrumentation level.  To override this
** setting, define PVLOGGER_INST_LEVEL in the osclconfig.h file.
** Possible values and the resulting intrumentation:
**
**  PVLOGGER_INST_LEVEL 0 : No logging.  All logging statements compiled out.
**  PVLOGGER_INST_LEVEL 1 : Release level only.
**  PVLOGGER_INST_LEVEL 2 : Release level + profile level
**  PVLOGGER_INST_LEVEL 3 : Release level + profile level + high-level debug
**  PVLOGGER_INST_LEVEL 4 : Release level + profile level + high-level debug + mid-level debug
**  PVLOGGER_INST_LEVEL 5 & above : Release level + profile level + high-level debug
**                            + mid-level debug + low-level debug
*/
#ifndef PVLOGGER_INST_LEVEL
#if defined(NDEBUG)
/* Release mode-- No logging */
#define PVLOGGER_INST_LEVEL 0
#else
/* Debug mode-- Complete logging */
#define PVLOGGER_INST_LEVEL 5
#endif
#endif


#if (PVLOGGER_INST_LEVEL<1)

/*
** Disable and compile-out all logging
*/
#define PVLOGGER_LOGMSG(IL, LOGGER, LEVEL, MESSAGE) OSCL_UNUSED_ARG(LOGGER);
#define PVLOGGER_LOGMSG_V(IL, LOGGER, LEVEL, MESSAGE) OSCL_UNUSED_ARG(LOGGER);
#define PVLOGGER_LOGBIN(IL, LOGGER, LEVEL, MESSAGE) OSCL_UNUSED_ARG(LOGGER);
#define PVLOGGER_LOGBIN_V(IL, LOGGER, LEVEL, MESSAGE) OSCL_UNUSED_ARG(LOGGER);
#define PVLOGGER_LOG_USE_ONLY(x)

#else //PVLOGGER_INST_LEVEL

/*
** Internal use macros that make the logging calls to PVLogger.
*/
#define _PVLOGGER_LOGMSG(LOGGER, LEVEL, MESSAGE)\
{\
    if (LOGGER)\
    {\
        if (LOGGER->IsActive(LEVEL))\
        {\
            LOGGER->LogMsgString MESSAGE;\
        }\
    }\
}

#define _PVLOGGER_LOGMSG_V(LOGGER, LEVEL, MESSAGE)\
{\
    if (LOGGER)\
    {\
        if (LOGGER->IsActive(LEVEL))\
        {\
            LOGGER->LogMsgStringV MESSAGE;\
        }\
    }\
}

#define _PVLOGGER_LOGBIN(LOGGER, LEVEL, MESSAGE) \
{\
    if (LOGGER)\
    {\
        if (LOGGER->IsActive(LEVEL))\
        {\
                LOGGER->LogMsgBuffers MESSAGE;\
        }\
    }\
}

#define _PVLOGGER_LOGBIN_V(LOGGER, LEVEL, MESSAGE) \
{\
    if (LOGGER)\
    {\
        if (LOGGER->IsActive(LEVEL))\
        {\
                LOGGER->LogMsgBuffersV MESSAGE;\
        }\
    }\
}

/*
** In case some compilers cannot support the instrumentation-level macros,
** they can be disabled by defining PVLOGGER_INST_LEVEL_SUPPORT to 0
** in their osclconfig.h.  If instrumentation level is not supported, then
** all instrumentation levels will be compiled in.
**
** If PVLOGGER_INST_LEVEL_SUPPORT is not defined, the default is set here to allow
** compile-time instrumentation level support.
*/
#ifndef PVLOGGER_INST_LEVEL_SUPPORT
#define PVLOGGER_INST_LEVEL_SUPPORT 1
#endif

#if !(PVLOGGER_INST_LEVEL_SUPPORT)

/*
** A set of logging macros that ignore the instrumentation level.
** All instrumentation levels will be compiled in.
*/
#define PVLOGGER_LOGMSG(IL, LOGGER, LEVEL, MESSAGE) _PVLOGGER_LOGMSG(LOGGER, LEVEL, MESSAGE)
#define PVLOGGER_LOGMSG_V(IL, LOGGER, LEVEL, MESSAGE) _PVLOGGER_LOGMSG_V(LOGGER, LEVEL, MESSAGE)
#define PVLOGGER_LOGBIN(IL, LOGGER, LEVEL, MESSAGE) _PVLOGGER_LOGBIN(LOGGER, LEVEL, MESSAGE)
#define PVLOGGER_LOGBIN_V(IL, LOGGER, LEVEL, MESSAGE) _PVLOGGER_LOGBIN_V(LOGGER, LEVEL, MESSAGE)

#else //PVLOGGER_INST_LEVEL_SUPPORT

/*
** This set of macros compiles the logging statements in or out based on the instrumtation
** level.
*/

#if (PVLOGGER_INST_LEVEL > PVLOGMSG_INST_REL)
#define PVLOGGER_LOGMSG_PVLOGMSG_INST_REL(LOGGER, LEVEL, MESSAGE) _PVLOGGER_LOGMSG(LOGGER, LEVEL, MESSAGE)
#define PVLOGGER_LOGMSG_V_PVLOGMSG_INST_REL(LOGGER, LEVEL, MESSAGE) _PVLOGGER_LOGMSG_V(LOGGER, LEVEL, MESSAGE)
#define PVLOGGER_LOGBIN_PVLOGMSG_INST_REL(LOGGER, LEVEL, MESSAGE) _PVLOGGER_LOGBIN(LOGGER, LEVEL, MESSAGE)
#define PVLOGGER_LOGBIN_V_PVLOGMSG_INST_REL(LOGGER, LEVEL, MESSAGE) _PVLOGGER_LOGBIN_V(LOGGER, LEVEL, MESSAGE)
#else
#define PVLOGGER_LOGMSG_PVLOGMSG_INST_REL(LOGGER, LEVEL, MESSAGE) OSCL_UNUSED_ARG(LOGGER);
#define PVLOGGER_LOGMSG_V_PVLOGMSG_INST_REL(LOGGER, LEVEL, MESSAGE) OSCL_UNUSED_ARG(LOGGER);
#define PVLOGGER_LOGBIN_PVLOGMSG_INST_REL(LOGGER, LEVEL, MESSAGE) OSCL_UNUSED_ARG(LOGGER);
#define PVLOGGER_LOGBIN_V_PVLOGMSG_INST_REL(LOGGER, LEVEL, MESSAGE) OSCL_UNUSED_ARG(LOGGER);
#endif

#if (PVLOGGER_INST_LEVEL > PVLOGMSG_INST_PROF)
#define PVLOGGER_LOGMSG_PVLOGMSG_INST_PROF(LOGGER, LEVEL, MESSAGE) _PVLOGGER_LOGMSG(LOGGER, LEVEL, MESSAGE)
#define PVLOGGER_LOGMSG_V_PVLOGMSG_INST_PROF(LOGGER, LEVEL, MESSAGE) _PVLOGGER_LOGMSG_V(LOGGER, LEVEL, MESSAGE)
#define PVLOGGER_LOGBIN_PVLOGMSG_INST_PROF(LOGGER, LEVEL, MESSAGE) _PVLOGGER_LOGBIN(LOGGER, LEVEL, MESSAGE)
#define PVLOGGER_LOGBIN_V_PVLOGMSG_INST_PROF(LOGGER, LEVEL, MESSAGE) _PVLOGGER_LOGBIN_V(LOGGER, LEVEL, MESSAGE)
#else
#define PVLOGGER_LOGMSG_PVLOGMSG_INST_PROF(LOGGER, LEVEL, MESSAGE) OSCL_UNUSED_ARG(LOGGER);
#define PVLOGGER_LOGMSG_V_PVLOGMSG_INST_PROF(LOGGER, LEVEL, MESSAGE) OSCL_UNUSED_ARG(LOGGER);
#define PVLOGGER_LOGBIN_PVLOGMSG_INST_PROF(LOGGER, LEVEL, MESSAGE) OSCL_UNUSED_ARG(LOGGER);
#define PVLOGGER_LOGBIN_V_PVLOGMSG_INST_PROF(LOGGER, LEVEL, MESSAGE) OSCL_UNUSED_ARG(LOGGER);
#endif

#if (PVLOGGER_INST_LEVEL > PVLOGMSG_INST_HLDBG)
#define PVLOGGER_LOGMSG_PVLOGMSG_INST_HLDBG(LOGGER, LEVEL, MESSAGE) _PVLOGGER_LOGMSG(LOGGER, LEVEL, MESSAGE)
#define PVLOGGER_LOGMSG_V_PVLOGMSG_INST_HLDBG(LOGGER, LEVEL, MESSAGE) _PVLOGGER_LOGMSG_V(LOGGER, LEVEL, MESSAGE)
#define PVLOGGER_LOGBIN_PVLOGMSG_INST_HLDBG(LOGGER, LEVEL, MESSAGE) _PVLOGGER_LOGBIN(LOGGER, LEVEL, MESSAGE)
#define PVLOGGER_LOGBIN_V_PVLOGMSG_INST_HLDBG(LOGGER, LEVEL, MESSAGE) _PVLOGGER_LOGBIN_V(LOGGER, LEVEL, MESSAGE)
#else
#define PVLOGGER_LOGMSG_PVLOGMSG_INST_HLDBG(LOGGER, LEVEL, MESSAGE) OSCL_UNUSED_ARG(LOGGER);
#define PVLOGGER_LOGMSG_V_PVLOGMSG_INST_HLDBG(LOGGER, LEVEL, MESSAGE) OSCL_UNUSED_ARG(LOGGER);
#define PVLOGGER_LOGBIN_PVLOGMSG_INST_HLDBG(LOGGER, LEVEL, MESSAGE) OSCL_UNUSED_ARG(LOGGER);
#define PVLOGGER_LOGBIN_V_PVLOGMSG_INST_HLDBG(LOGGER, LEVEL, MESSAGE) OSCL_UNUSED_ARG(LOGGER);
#endif

#if (PVLOGGER_INST_LEVEL > PVLOGMSG_INST_MLDBG)
#define PVLOGGER_LOGMSG_PVLOGMSG_INST_MLDBG(LOGGER, LEVEL, MESSAGE) _PVLOGGER_LOGMSG(LOGGER, LEVEL, MESSAGE)
#define PVLOGGER_LOGMSG_V_PVLOGMSG_INST_MLDBG(LOGGER, LEVEL, MESSAGE) _PVLOGGER_LOGMSG_V(LOGGER, LEVEL, MESSAGE)
#define PVLOGGER_LOGBIN_PVLOGMSG_INST_MLDBG(LOGGER, LEVEL, MESSAGE) _PVLOGGER_LOGBIN(LOGGER, LEVEL, MESSAGE)
#define PVLOGGER_LOGBIN_V_PVLOGMSG_V_INST_MLDBG(LOGGER, LEVEL, MESSAGE) _PVLOGGER_LOGBIN_V(LOGGER, LEVEL, MESSAGE)
#else
#define PVLOGGER_LOGMSG_PVLOGMSG_INST_MLDBG(LOGGER, LEVEL, MESSAGE) OSCL_UNUSED_ARG(LOGGER);
#define PVLOGGER_LOGMSG_V_PVLOGMSG_INST_MLDBG(LOGGER, LEVEL, MESSAGE) OSCL_UNUSED_ARG(LOGGER);
#define PVLOGGER_LOGBIN_PVLOGMSG_INST_MLDBG(LOGGER, LEVEL, MESSAGE) OSCL_UNUSED_ARG(LOGGER);
#define PVLOGGER_LOGBIN_V_PVLOGMSG_V_INST_MLDBG(LOGGER, LEVEL, MESSAGE) OSCL_UNUSED_ARG(LOGGER);
#endif

#if (PVLOGGER_INST_LEVEL > PVLOGMSG_INST_LLDBG)
#define PVLOGGER_LOGMSG_PVLOGMSG_INST_LLDBG(LOGGER, LEVEL, MESSAGE) _PVLOGGER_LOGMSG(LOGGER, LEVEL, MESSAGE)
#define PVLOGGER_LOGMSG_V_PVLOGMSG_INST_LLDBG(LOGGER, LEVEL, MESSAGE) _PVLOGGER_LOGMSG_V(LOGGER, LEVEL, MESSAGE)
#define PVLOGGER_LOGBIN_PVLOGMSG_INST_LLDBG(LOGGER, LEVEL, MESSAGE) _PVLOGGER_LOGBIN(LOGGER, LEVEL, MESSAGE)
#define PVLOGGER_LOGBIN_V_PVLOGMSG_INST_LLDBG(LOGGER, LEVEL, MESSAGE) _PVLOGGER_LOGBIN_V(LOGGER, LEVEL, MESSAGE)
#else
#define PVLOGGER_LOGMSG_PVLOGMSG_INST_LLDBG(LOGGER, LEVEL, MESSAGE) OSCL_UNUSED_ARG(LOGGER);
#define PVLOGGER_LOGMSG_V_PVLOGMSG_INST_LLDBG(LOGGER, LEVEL, MESSAGE) OSCL_UNUSED_ARG(LOGGER);
#define PVLOGGER_LOGBIN_PVLOGMSG_INST_LLDBG(LOGGER, LEVEL, MESSAGE) OSCL_UNUSED_ARG(LOGGER);
#define PVLOGGER_LOGBIN_V_PVLOGMSG_INST_LLDBG(LOGGER, LEVEL, MESSAGE) OSCL_UNUSED_ARG(LOGGER);
#endif


#define PVLOGGER_LOGMSG(IL, LOGGER, LEVEL, MESSAGE) PVLOGGER_LOGMSG_ ## IL (LOGGER, LEVEL, MESSAGE)
#define PVLOGGER_LOGMSG_V(IL, LOGGER, LEVEL, MESSAGE) PVLOGGER_LOGMSG_V_ ## IL (LOGGER, LEVEL, MESSAGE)

#define PVLOGGER_LOGBIN(IL, LOGGER, LEVEL, MESSAGE) PVLOGGER_LOGBIN_ ## IL (LOGGER, LEVEL, MESSAGE)
#define PVLOGGER_LOGBIN_V(IL, LOGGER, LEVEL, MESSAGE) PVLOGGER_LOGBIN_V_ ## IL (LOGGER, LEVEL, MESSAGE)

#endif //PVLOGGER_INST_LEVEL_SUPPORT

#define PVLOGGER_LOG_USE_ONLY(x) x

#endif // PVLOGGER_INST_LEVEL

#ifndef PVLOGGER_ENABLE
#if (PVLOGGER_INST_LEVEL<1)
#define PVLOGGER_ENABLE 0
#else
#define PVLOGGER_ENABLE 1
#endif
#endif

class PVLoggerAppender;
class PVLoggerFilter;
class PVLogger
{
    public:

        typedef int32 log_level_type;
        typedef int32 message_id_type;
        typedef int32 filter_status_type;
        typedef _OsclBasicAllocator alloc_type;

        OSCL_IMPORT_REF static void Init();


        OSCL_IMPORT_REF static void Cleanup();

        OSCL_IMPORT_REF static PVLogger *GetLoggerObject(const char* inputTag);

        void SetLogLevel(log_level_type level)
        {
#if(PVLOGGER_ENABLE)
            _level = level;
#else
            OSCL_UNUSED_ARG(level);
#endif
        }

        OSCL_IMPORT_REF void SetLogLevelAndPropagate(log_level_type level);

        log_level_type GetLogLevel()
        {
#if(PVLOGGER_ENABLE)
            return(_level);
#else
            return 0;
#endif
        }

        void DisableAppenderInheritance()
        {
#if(PVLOGGER_ENABLE)
            _oAppenderInheritance = false;
#endif
        }

        void AddAppender(OsclSharedPtr<PVLoggerAppender> &appender)
        {
#if(PVLOGGER_ENABLE)
            _pOwnAppenderVec.push_back(appender);
#else
            OSCL_UNUSED_ARG(appender);
#endif
        }

        void RemoveAppender(OsclSharedPtr<PVLoggerAppender> &appender)
        {
#if(PVLOGGER_ENABLE)
            for (Oscl_Vector<OsclSharedPtr<PVLoggerAppender>, alloc_type>::iterator it = _pOwnAppenderVec.begin();
                    it != _pOwnAppenderVec.end();
                    it++)
            {
                if ((*it).GetRep() == appender.GetRep())
                {
                    _pOwnAppenderVec.erase(it);
                    break;
                }
            }
#else
            OSCL_UNUSED_ARG(appender);
#endif
        }

        void AddFilter(OsclSharedPtr<PVLoggerFilter> &filter)
        {
#if(PVLOGGER_ENABLE)
            _pMsgFilterVec.push_back(filter);
#else
            OSCL_UNUSED_ARG(filter);
#endif
        };

        uint32 GetNumAppenders()
        {
#if(PVLOGGER_ENABLE)
            return(_pOwnAppenderVec.size());
#else
            return 0;
#endif
        }

        OSCL_IMPORT_REF bool IsActive(log_level_type level);

        OSCL_IMPORT_REF void LogMsgStringV(message_id_type msgID, const char * fmt, va_list arguments);

        OSCL_IMPORT_REF void LogMsgBuffersV(message_id_type msgID, int32 numPairs, va_list arguments);

        OSCL_IMPORT_REF void LogMsgString(message_id_type msgID, const char * fmt, ...);

        OSCL_IMPORT_REF void LogMsgBuffers(message_id_type msgID, int32 numPairs, ...);

        OSCL_IMPORT_REF PVLogger(const char* inputTag, log_level_type level, bool oAppenderInheritance);

        virtual ~PVLogger()
        {
#if(PVLOGGER_ENABLE)
            _tagAllocator.deallocate(_tag);
#endif
        }

#if(PVLOGGER_ENABLE)
    protected:
        friend class PVLoggerRegistry;
        void SetParent(PVLogger *parentLogger)
        {
            _parentLogger = parentLogger;
        }
        PVLogger *GetParent()
        {
            return(_parentLogger);
        }

    private:
        filter_status_type FilterMsg(message_id_type msgID);
        void LogMsg(message_id_type msgID, const char *fmt, va_list arguments);
        void LogMsg(message_id_type msgID, int32 numPairs, va_list arguments);

        char* _tag;
        log_level_type _level;
        log_level_type _lastMsgLevel;
        bool _oAppenderInheritance;

        PVLogger *_parentLogger;
        Oscl_TAlloc<char, alloc_type> _tagAllocator;

        Oscl_Vector<OsclSharedPtr<PVLoggerFilter>, alloc_type> _pMsgFilterVec;
        Oscl_Vector<OsclSharedPtr<PVLoggerAppender>, alloc_type>  _pOwnAppenderVec;
#endif //PVLOGGER_ENABLE
};

// log message levels

const PVLogger::log_level_type PVLOGMSG_EMERG   = 0;
const PVLogger::log_level_type PVLOGMSG_ALERT   = 1;
const PVLogger::log_level_type PVLOGMSG_CRIT    = 2;
const PVLogger::log_level_type PVLOGMSG_ERR     = 3;
const PVLogger::log_level_type PVLOGMSG_WARNING = 4;
const PVLogger::log_level_type PVLOGMSG_NOTICE  = 5;
const PVLogger::log_level_type PVLOGMSG_INFO    = 6;
const PVLogger::log_level_type PVLOGMSG_STACK_TRACE = 7;
const PVLogger::log_level_type PVLOGMSG_DEBUG   = 8;

// do not use these levels
// for backward compatibility only
const PVLogger::log_level_type PVLOGMSG_FATAL_ERROR    = PVLOGMSG_EMERG;
const PVLogger::log_level_type PVLOGMSG_NONFATAL_ERROR = PVLOGMSG_ERR;
const PVLogger::log_level_type PVLOGMSG_STATISTIC      = PVLOGMSG_INFO;
const PVLogger::log_level_type PVLOGMSG_VERBOSE        = PVLOGMSG_DEBUG;

#endif // PVLOGGER_H_INCLUDED

---