wbLogger.cpp

#include	<wb.h>


wbLogger_t _logger = NULL;

static inline wbBool wbLogEntry_hasNext(wbLogEntry_t elem) {
    return wbLogEntry_getNext(elem) != NULL;
}

static inline wbLogEntry_t wbLogEntry_new() {
    wbLogEntry_t elem;

    elem = wbNew(struct st_wbLogEntry_t);

    wbLogEntry_setMessage(elem, NULL);
    wbLogEntry_setTime(elem, _hrtime());
#ifndef NDEBUG
    wbLogEntry_setLevel(elem, wbLogLevel_TRACE);
#else
    wbLogEntry_setLevel(elem, wbLogLevel_OFF);
#endif
    wbLogEntry_setNext(elem, NULL);

    wbLogEntry_setLine(elem, -1);
    wbLogEntry_setFile(elem, NULL);
    wbLogEntry_setFunction(elem, NULL);

    return elem;
}

static inline wbLogEntry_t wbLogEntry_initialize(wbLogLevel_t level, string msg, const char * file,
        const char * fun, int line) {
    wbLogEntry_t elem;

    elem = wbLogEntry_new();

    wbLogEntry_setLevel(elem, level);

    wbLogEntry_setMessage(elem, wbString_duplicate(msg));

    wbLogEntry_setLine(elem, line);
    wbLogEntry_setFile(elem, file);
    wbLogEntry_setFunction(elem, fun);

    return elem;
}

static inline void wbLogEntry_delete(wbLogEntry_t elem) {
    if (elem != NULL) {
        if (wbLogEntry_getMessage(elem) != NULL) {
            wbFree(wbLogEntry_getMessage(elem));
        }
        wbDelete(elem);
    }
    return ;
}

static inline const char * getLevelName(wbLogLevel_t level) {
    switch (level) {
    case wbLogLevel_unknown:
        return "Unknown";
    case wbLogLevel_OFF:
        return "Off";
    case wbLogLevel_FATAL:
        return "Fatal";
    case wbLogLevel_ERROR:
        return "Error";
    case wbLogLevel_WARN:
        return "Warn";
    case wbLogLevel_INFO:
        return "Info";
    case wbLogLevel_DEBUG:
        return "Debug";
    case wbLogLevel_TRACE:
        return "Trace";
    }
    return NULL;
}

static inline string wbLogEntry_toJSON(wbLogEntry_t elem) {
    if (elem != NULL) {
        stringstream ss;

        ss << "{\n";
        ss << wbString_quote("level") << ":" << wbString_quote(getLevelName(wbLogEntry_getLevel(elem))) << ",\n";
        ss << wbString_quote("message") << ":" << wbString_quote(wbLogEntry_getMessage(elem)) << ",\n";
        ss << wbString_quote("file") << ":" << wbString_quote(wbLogEntry_getFile(elem)) << ",\n";
        ss << wbString_quote("function") << ":" << wbString_quote(wbLogEntry_getFunction(elem)) << ",\n";
        ss << wbString_quote("line") << ":" << wbLogEntry_getLine(elem) << ",\n";
        ss << wbString_quote("time") << ":" << wbLogEntry_getTime(elem) << "\n";
        ss << "}";

        return ss.str();
    }
    return "";
}

static inline string wbLogEntry_toXML(wbLogEntry_t elem) {
    if (elem != NULL) {
        stringstream ss;

        ss << "<entry>\n";
        ss << "<type>" << "LoggerElement" << "</type>\n";
        ss << "<level>" << wbLogEntry_getLevel(elem) << "</level>\n";
        ss << "<message>" << wbLogEntry_getMessage(elem) << "</message>\n";
        ss << "<file>" << wbLogEntry_getFile(elem) << "</file>\n";
        ss << "<function>" << wbLogEntry_getFunction(elem) << "</function>\n";
        ss << "<line>" << wbLogEntry_getLine(elem) << "</line>\n";
        ss << "<time>" << wbLogEntry_getTime(elem) << "</time>\n";
        ss << "</entry>\n";

        return ss.str();
    }
    return "";
}

wbLogger_t wbLogger_new() {
    wbLogger_t logger;

    logger = wbNew(struct st_wbLogger_t);

    wbLogger_setLength(logger, 0);
    wbLogger_setHead(logger, NULL);
#ifndef NDEBUG
    wbLogger_getLevel(logger) = wbLogLevel_TRACE;
#else
    wbLogger_getLevel(logger) = wbLogLevel_OFF;
#endif

    return logger;
}


static inline void _wbLogger_setLevel(wbLogger_t logger, wbLogLevel_t level) {
    wbLogger_getLevel(logger) = level;
}

static inline void _wbLogger_setLevel(wbLogLevel_t level) {
    wb_init();
    _wbLogger_setLevel(_logger, level);
}

#define wbLogger_setLevel(level)				_wbLogger_setLevel(wbLogLevel_##level)

void wbLogger_clear(wbLogger_t logger) {
    if (logger != NULL) {
        wbLogEntry_t tmp;
        wbLogEntry_t iter;

        iter = wbLogger_getHead(logger);
        while (iter != NULL) {
            tmp = wbLogEntry_getNext(iter);
            wbLogEntry_delete(iter);
            iter = tmp;
        }

        wbLogger_setLength(logger, 0);
        wbLogger_setHead(logger, NULL);
    }
}

void wbLogger_delete(wbLogger_t logger) {
    if (logger != NULL) {
        wbLogger_clear(logger);
        wbDelete(logger);
    }
    return ;
}

void wbLogger_append(wbLogLevel_t level, string msg, const char * file,
                     const char * fun, int line) {
    wbLogEntry_t elem;
    wbLogger_t logger;

    wb_init();

    logger = _logger;

    if (wbLogger_getLevel(logger) < level) {
        return ;
    }

    elem = wbLogEntry_initialize(level, msg, file, fun, line);

    if (wbLogger_getHead(logger) == NULL) {
        wbLogger_setHead(logger, elem);
    } else {
        wbLogEntry_t prev = wbLogger_getHead(logger);

        while (wbLogEntry_hasNext(prev)) {
            prev = wbLogEntry_getNext(prev);
        }
        wbLogEntry_setNext(prev, elem);
    }

#if 0
    if (level <= wbLogger_getLevel(logger) && elem) {
        const char * levelName = getLevelName(level);

        fprintf(stderr,
                "= LOG: %s: %s (In %s:%s on line %d). =\n",
                levelName,
                wbLogEntry_getMessage(elem),
                wbLogEntry_getFile(elem),
                wbLogEntry_getFunction(elem),
                wbLogEntry_getLine(elem));
    }
#endif

    wbLogger_incrementLength(logger);

    return ;
}

string wbLogger_toJSON() {
    return wbLogger_toJSON(_logger);
}

string wbLogger_toJSON(wbLogger_t logger) {
    if (logger != NULL) {
        wbLogEntry_t iter;
        stringstream ss;

        ss << "{\n";
        ss << wbString_quote("elements") << ":[\n";
        for (iter = wbLogger_getHead(logger); iter != NULL; iter = wbLogEntry_getNext(iter)) {
            ss << wbLogEntry_toJSON(iter);
            if (wbLogEntry_getNext(iter) != NULL) {
                ss << ",\n";
            }
        }
        ss << "]\n";
        ss << "}\n";

        return ss.str();
    }
    return "";
}


string wbLogger_toXML() {
    return wbLogger_toXML(_logger);
}

string wbLogger_toXML(wbLogger_t logger) {
    if (logger != NULL) {
        wbLogEntry_t iter;
        stringstream ss;

        ss << "<logger>\n";
        ss << "<type>" << "Logger" << "</type>\n";
        ss << "<elements>\n";
        for (iter = wbLogger_getHead(logger); iter != NULL; iter = wbLogEntry_getNext(iter)) {
            ss << wbLogEntry_toXML(iter);
        }
        ss << "</elements>\n";
        ss << "</logger>\n";

        return ss.str();
    }
    return "";
}