logging.h

/*
 * Copyright regify
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
#ifndef REGIFY_UTIL_LOGGING_H
#define REGIFY_UTIL_LOGGING_H
/* Only need to export C interface if used by C++ source code */
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
 
#define RU_LOG_NONE 0
 
#define RU_LOG_CRIT 1
 
#define RU_LOG_WARN 2
 
#define RU_LOG_INFO 3
 
#define RU_LOG_VERB 4
 
#define RU_LOG_DBUG 5
 
typedef void (*ruLogFunc) (perm_ptr userData, uint32_t logLevel, trans_chars msg);
 
typedef void (*ruCloseFunc) (perm_ptr userData);
 
typedef int (*ruWriteFunc) (trans_chars buf, FILE* wh);
 
typedef ptr ruPreCtx;
 
RUAPI ruPreCtx ruPreCtxNew(void);
 
RUAPI ruPreCtx ruPreCtxFree(ruPreCtx rpc, bool flush);
 
RUAPI void ruPreLogSink(perm_ptr rpc, uint32_t logLevel, trans_chars msg);
 
typedef ptr ruSinkCtx;
 
RUAPI ruSinkCtx ruSinkCtxNew(trans_chars filePath, ruCloseFunc closeCb,
                             perm_ptr closeCtx);
 
RUAPI int32_t ruSinkWriteCb(ruSinkCtx rsc, ruWriteFunc writeCb);
 
RUAPI int32_t ruSinkCtxPath(ruSinkCtx rsc, trans_chars filePath);
 
RUAPI ruSinkCtx ruSinkCtxFree(ruSinkCtx rsc);
 
RUAPI void ruFileLogSink(perm_ptr rsc, uint32_t logLevel, trans_chars msg);
 
RUAPI void ruStdErrLogSink(perm_ptr udata, uint32_t logLevel, trans_chars msg);
 
RUAPI ruCleaner ruGetCleaner(void);
 
RUAPI perm_ptr ruGetLogCtx(void);
 
RUAPI void ruSetLogger(ruLogFunc logger, uint32_t logLevel, perm_ptr userData,
                       bool cleaned, bool threaded);
 
RUAPI void ruLoggerUnblock(void);
 
RUAPI void ruStopLogger(void);
 
RUAPI void ruSetLogLevel(uint32_t logLevel);
 
RUAPI uint32_t ruGetLogLevel(void);
 
RUAPI bool ruDoesLog(uint32_t log_level);
 
 
RUAPI void ruLogDbg(trans_chars filePath, trans_chars func, int32_t line, trans_chars format, ...);
 
RUAPI void ruDoLog(uint32_t log_level, trans_chars filePath, trans_chars func,
                   int32_t line, trans_chars format, ...);
 
RUAPI void ruDoLogV(uint32_t log_level, trans_chars filePath, trans_chars func,
              int32_t line, trans_chars format, va_list args);
 
RUAPI alloc_chars ruMakeLogMsgV(uint32_t log_level, trans_chars filePath,
                                trans_chars func, int32_t line,
                                trans_chars format, va_list args);
 
RUAPI void ruRawLog(uint32_t log_level, trans_chars msg);
 
RUAPI void ruFlushLog(void);
 
RUAPI void ruLastLog(void);
 
RUAPI char* ruMakeLogMsg(uint32_t log_level, trans_chars file, trans_chars func,
                   int32_t line, trans_chars format, ...);
 
#define ruLog_(lvl, format, ...) ruMacStart { \
    if(ruDoesLog(lvl)) { \
        ruDoLog(lvl, __FILE__, __func__, __LINE__, format, __VA_ARGS__); \
    } \
} ruMacEnd
#define ruCritLog(msg) ruLog_(RU_LOG_CRIT, "%s", msg)
 
#define ruCritLogf(fmt, ...) ruLog_(RU_LOG_CRIT, fmt, __VA_ARGS__)
 
#define ruWarnLog(msg) ruLog_(RU_LOG_WARN, "%s", msg)
 
#define ruWarnLogf(fmt, ...) ruLog_(RU_LOG_WARN, fmt, __VA_ARGS__)
 
#define ruInfoLog(msg) ruLog_(RU_LOG_INFO, "%s", msg)
 
#define ruInfoLogf(fmt, ...) ruLog_(RU_LOG_INFO, fmt, __VA_ARGS__)
 
#define ruVerbLog(msg) ruLog_(RU_LOG_VERB, "%s", msg)
 
#define ruVerbLogf(fmt, ...) ruLog_(RU_LOG_VERB, fmt, __VA_ARGS__)
 
#define ruDbgLog(msg) ruLog_(RU_LOG_DBUG, "%s", msg)
 
#define ruDbgLogf(fmt, ...) ruLog_(RU_LOG_DBUG, fmt, __VA_ARGS__)
 
#define ruDump8(msg, start) \
    ruDbgLogf("%s @0x%x %02x %02x %02x %02x  %02x %02x %02x %02x", msg, (start), \
        (uint8_t)*(start), (uint8_t)*((start)+1), (uint8_t)*((start)+2), (uint8_t)*((start)+3), \
        (uint8_t)*((start)+4), (uint8_t)*((start)+5), (uint8_t)*((start)+6), (uint8_t)*((start)+7))
 
#define ruDump16(msg, start) \
    ruDbgLogf("%s @0x%x %02x %02x %02x %02x  %02x %02x %02x %02x  %02x %02x %02x %02x  %02x %02x %02x %02x", msg, (start), \
        (uint8_t)*(start), (uint8_t)*((start)+1), (uint8_t)*((start)+2), (uint8_t)*((start)+3), \
        (uint8_t)*((start)+4), (uint8_t)*((start)+5), (uint8_t)*((start)+6), (uint8_t)*((start)+7), \
        (uint8_t)*((start)+8), (uint8_t)*((start)+9), (uint8_t)*((start)+10), (uint8_t)*((start)+11), \
        (uint8_t)*((start)+12), (uint8_t)*((start)+13), (uint8_t)*((start)+14), (uint8_t)*((start)+15))
 
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif //REGIFY_UTIL_LOGGING_H