le_log.h

Go to the documentation of this file.

#ifndef LEGATO_LOG_INCLUDE_GUARD
#define LEGATO_LOG_INCLUDE_GUARD

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
typedef enum
{
    LE_LOG_DEBUG,   
    LE_LOG_INFO,    
    LE_LOG_WARN,    
    LE_LOG_ERR,     
    LE_LOG_CRIT,    
    LE_LOG_EMERG    
}
le_log_Level_t;


//--------------------------------------------------------------------------------------------------

typedef struct le_log_Session* le_log_SessionRef_t;

typedef struct le_log_Trace* le_log_TraceRef_t;

void _le_log_Send
(
    const le_log_Level_t level,
    const le_log_TraceRef_t traceRef,
    le_log_SessionRef_t logSession,
    const char* filenamePtr,
    const char* functionNamePtr,
    const unsigned int lineNumber,
    const char* formatPtr,
    ...
) __attribute__ ((format (printf, 7, 8)));

le_log_TraceRef_t _le_log_GetTraceRef
(
    le_log_SessionRef_t logSession,
    const char* keyword
);

void _le_log_SetFilterLevel
(
    le_log_SessionRef_t logSession,
    le_log_Level_t level
);


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#ifdef __cplusplus
extern
#endif
LE_SHARED le_log_SessionRef_t LE_LOG_SESSION;

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#ifdef __cplusplus
extern
#endif
LE_SHARED le_log_Level_t* LE_LOG_LEVEL_FILTER_PTR;


//--------------------------------------------------------------------------------------------------

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#define _LE_LOG_MSG(level, formatString, ...) \
    do { \
        if ((LE_LOG_LEVEL_FILTER_PTR == NULL) || (level >= *LE_LOG_LEVEL_FILTER_PTR)) \
            _le_log_Send(level, NULL, LE_LOG_SESSION, __FILE__, __func__, __LINE__, \
                    formatString, ##__VA_ARGS__); \
    } while(0)


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------

#define LE_DEBUG(formatString, ...)     _LE_LOG_MSG(LE_LOG_DEBUG, formatString, ##__VA_ARGS__)

#define LE_INFO(formatString, ...)      _LE_LOG_MSG(LE_LOG_INFO, formatString, ##__VA_ARGS__)

#define LE_WARN(formatString, ...)      _LE_LOG_MSG(LE_LOG_WARN, formatString, ##__VA_ARGS__)

#define LE_ERROR(formatString, ...)     _LE_LOG_MSG(LE_LOG_ERR, formatString, ##__VA_ARGS__)

#define LE_CRIT(formatString, ...)      _LE_LOG_MSG(LE_LOG_CRIT, formatString, ##__VA_ARGS__)

#define LE_EMERG(formatString, ...)     _LE_LOG_MSG(LE_LOG_EMERG, formatString, ##__VA_ARGS__)


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------

#define LE_DEBUG_IF(condition, formatString, ...)                                                   \
        if (condition) { _LE_LOG_MSG(LE_LOG_DEBUG, formatString, ##__VA_ARGS__); }

#define LE_INFO_IF(condition, formatString, ...)                                                    \
        if (condition) { _LE_LOG_MSG(LE_LOG_INFO, formatString, ##__VA_ARGS__); }

#define LE_WARN_IF(condition, formatString, ...)                                                    \
        if (condition) { _LE_LOG_MSG(LE_LOG_WARN, formatString, ##__VA_ARGS__); }

#define LE_ERROR_IF(condition, formatString, ...)                                                   \
        if (condition) { _LE_LOG_MSG(LE_LOG_ERR, formatString, ##__VA_ARGS__); }

#define LE_CRIT_IF(condition, formatString, ...)                                                    \
        if (condition) { _LE_LOG_MSG(LE_LOG_CRIT, formatString, ##__VA_ARGS__); }

#define LE_EMERG_IF(condition, formatString, ...)                                                   \
        if (condition) { _LE_LOG_MSG(LE_LOG_EMERG, formatString, ##__VA_ARGS__); }


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#define LE_FATAL(formatString, ...)                                                                 \
        { LE_EMERG(formatString, ##__VA_ARGS__); exit(EXIT_FAILURE); }


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#define LE_FATAL_IF(condition, formatString, ...)                                                   \
        if (condition) { LE_FATAL(formatString, ##__VA_ARGS__) }


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#define LE_ASSERT(condition)                                                                        \
        if (!(condition)) { LE_FATAL("Assert Failed: '%s'", #condition) }


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#define LE_RESULT_TXT(v) _le_log_GetResultCodeString(v)

const char* _le_log_GetResultCodeString
(
    le_result_t resultCode  
);


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#define LE_IS_TRACE_ENABLED(traceRef)  (le_log_IsTraceEnabled(traceRef))


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#define LE_TRACE(traceRef, string, ...)                                                             \
        if (le_log_IsTraceEnabled(traceRef))                                                        \
        {                                                                                           \
            _le_log_Send((le_log_Level_t)-1,                                                        \
                    traceRef,                                                                       \
                    LE_LOG_SESSION,                                                                 \
                    __FILE__,                                                                       \
                    __func__,                                                                       \
                    __LINE__,                                                                       \
                    string,                                                                         \
                    ##__VA_ARGS__);                                                                 \
        }


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
static inline le_log_TraceRef_t le_log_GetTraceRef
(
    const char* keywordPtr      
)
{
    return _le_log_GetTraceRef(LE_LOG_SESSION, keywordPtr);
}


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
static inline bool le_log_IsTraceEnabled
(
    const le_log_TraceRef_t traceRef    
)
{
    return *((bool*)traceRef);
}


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
static inline void le_log_SetFilterLevel
(
    le_log_Level_t level    
)
{
    _le_log_SetFilterLevel(LE_LOG_SESSION, level);
}


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
static inline le_log_Level_t le_log_GetFilterLevel
(
    void
)
{
    if (LE_LOG_LEVEL_FILTER_PTR != NULL)
    {
        return *LE_LOG_LEVEL_FILTER_PTR;
    }
    else
    {
        return LE_LOG_INFO; // Default.
    }
}


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
static inline void le_log_EnableTrace
(
    const le_log_TraceRef_t traceRef    
)
{
    *((bool*)traceRef) = true;
}


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
static inline void le_log_DisableTrace
(
    const le_log_TraceRef_t traceRef    
)
{
    *((bool*)traceRef) = false;
}



#endif // LEGATO_LOG_INCLUDE_GUARD