Log.c File Reference

#include <assert.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include "Config.h"
#include <unistd.h>
#include "Log.h"

Go to the source code of this file.

Macros
#define	_Class   _Log

Functions
static void	_log (const Log *self, LogLevel level, const char *fmt, va_list args)
Class *	_Log (void)
static void	dealloc (Object *self)
static void	debug (const Log *self, const char *fmt,...)
static void	destroy (Class *clazz)
static void	error (const Log *self, const char *fmt,...)
static void	fatal (const Log *self, const char *fmt,...)
static void	flush (const Log *self)
static void	info (const Log *self, const char *fmt,...)
static Log *	init (Log *self)
static void	initialize (Class *clazz)
static Log *	initWithName (Log *self, const char *name)
static Log *	sharedInstance (void)
static void	trace (const Log *self, const char *fmt,...)
static void	warn (const Log *self, const char *fmt,...)

Variables
static Log *	_sharedInstance

Macro Definition Documentation

_Class

#define _Class   _Log

Definition at line 39 of file Log.c.

Function Documentation

_log()

static void _log ( const Log *  self, LogLevel  level, const char *  fmt, va_list  args  )

static

Definition at line 158 of file Log.c.

                                                                                 {
 
    const char *levels[] = { "TRACE", "DEBUG", "INFO", "WARN", "ERROR", "FATAL" };
    assert(level < lengthof(levels));
 
    if (level < self->level) {
        return;
    }
 
    assert(self->file);
 
    const time_t date = time(NULL);
    const struct tm *localDate = localtime(&date);
 
    char buffer[128];
    strftime(buffer, sizeof(buffer), self->format, localDate);
 
    char *c = buffer;
    while (*c) {
 
        if (*c == '%') {
            _Bool token = true;
 
            if (*(c + 1) == 'n') {
                fputs(self->name, self->file);
            } else if (*(c + 1) == 'l') {
                fputs(levels[level], self->file);
            } else if (*(c + 1) == 'm') {
                vfprintf(self->file, fmt, args);
            } else {
                token = false;
            }
 
            if (token) {
                c++;
                c++;
                continue;
            }
        }
 
        fputc(*c, self->file);
        c++;
    }
 
    fputc('\n', self->file);
    fflush(self->file);
}

_Log()

Class * _Log

(

void

)

Definition at line 285 of file Log.c.

                  {
    static Class *clazz;
    static Once once;
 
    do_once(&once, {
        clazz = _initialize(&(const ClassDef) {
            .name = "Log",
            .superclass = _Object(),
            .instanceSize = sizeof(Log),
            .interfaceOffset = offsetof(Log, interface),
            .interfaceSize = sizeof(LogInterface),
            .initialize = initialize,
            .destroy = destroy,
        });
    });
 
    return clazz;
}

dealloc()

static void dealloc ( Object *  self )

static

See also

Object::dealloc(Object *)

Definition at line 46 of file Log.c.

                                  {
 
    Log *this = (Log *) self;
 
    if (!isatty(fileno(this->file))) {
        const int err = fclose(this->file);
        assert(err == 0);
    }
 
    free(this->name);
 
    super(Object, self, dealloc);
}

debug()

static void debug ( const Log *  self, const char *  fmt,   ...  )

static

Definition at line 66 of file Log.c.

                                                         {
 
    va_list args;
    va_start(args, fmt);
 
    $(self, log, LogLevelDebug, fmt, args);
 
    va_end(args);
}

destroy()

static void destroy ( Class *  clazz )

static

See also

Class::destroy(Class *)

Definition at line 276 of file Log.c.

                                  {
 
    _sharedInstance = release(_sharedInstance);
}

error()

static void error ( const Log *  self, const char *  fmt,   ...  )

static

Definition at line 80 of file Log.c.

                                                         {
 
    va_list args;
    va_start(args, fmt);
 
    $(self, log, LogLevelError, fmt, args);
 
    va_end(args);
}

fatal()

static void fatal ( const Log *  self, const char *  fmt,   ...  )

static

Definition at line 94 of file Log.c.

                                                         {
 
    va_list args;
    va_start(args, fmt);
 
    $(self, log, LogLevelFatal, fmt, args);
 
    va_end(args);
}

flush()

static void flush ( const Log *  self )

static

Definition at line 108 of file Log.c.

                                   {
 
    assert(self->file);
    fflush(self->file);
}

info()

static void info ( const Log *  self, const char *  fmt,   ...  )

static

Definition at line 118 of file Log.c.

                                                        {
 
    va_list args;
    va_start(args, fmt);
 
    $(self, log, LogLevelInfo, fmt, args);
 
    va_end(args);
}

init()

static Log * init ( Log *  self )

static

Definition at line 132 of file Log.c.

                            {
 
    return $(self, initWithName, NULL);
}

initialize()

static void initialize ( Class *  clazz )

static

See also

Class::initialize(Class *)

Definition at line 256 of file Log.c.

                                     {
 
    ((ObjectInterface *) clazz->interface)->dealloc = dealloc;
 
    ((LogInterface *) clazz->interface)->debug = debug;
    ((LogInterface *) clazz->interface)->error = error;
    ((LogInterface *) clazz->interface)->fatal = fatal;
    ((LogInterface *) clazz->interface)->flush = flush;
    ((LogInterface *) clazz->interface)->info = info;
    ((LogInterface *) clazz->interface)->init = init;
    ((LogInterface *) clazz->interface)->initWithName = initWithName;
    ((LogInterface *) clazz->interface)->log = _log;
    ((LogInterface *) clazz->interface)->trace = trace;
    ((LogInterface *) clazz->interface)->sharedInstance = sharedInstance;
    ((LogInterface *) clazz->interface)->warn = warn;
}

initWithName()

static Log * initWithName ( Log *  self, const char *  name  )

static

Definition at line 141 of file Log.c.

                                                      {
 
    self = (Log *) super(Object, self, init);
    if (self) {
        self->name = strdup(name ?: "default");
        self->level = LogLevelInfo;
        self->format = LOG_FORMAT_DEFAULT;
        self->file = stdout;
    }
 
    return self;
}

sharedInstance()

static Log * sharedInstance ( void  )

static

Definition at line 212 of file Log.c.

                                 {
 
    static Once once;
 
    do_once(&once, {
        _sharedInstance = $(alloc(Log), init);
    });
 
    return _sharedInstance;
}

trace()

static void trace ( const Log *  self, const char *  fmt,   ...  )

static

Definition at line 227 of file Log.c.

                                                         {
 
    va_list args;
    va_start(args, fmt);
 
    $(self, log, LogLevelTrace, fmt, args);
 
    va_end(args);
}

warn()

static void warn ( const Log *  self, const char *  fmt,   ...  )

static

Definition at line 241 of file Log.c.

                                                        {
 
    va_list args;
    va_start(args, fmt);
 
    $(self, log, LogLevelWarn, fmt, args);
 
    va_end(args);
}

Variable Documentation

_sharedInstance

Log* _sharedInstance

static

Definition at line 206 of file Log.c.