Log4gLogger

typedef struct {
} Log4gLogger;

The Log4gLogger structure does not have any public members.

Log4gLoggerClass

typedef struct {
    Log4gLoggerGetEffectiveLevel get_effective_level;
    Log4gLoggerSetLevel set_level;
} Log4gLoggerClass;

log4g_logger_new ()

Log4gLogger *       log4g_logger_new                    (const gchar *name);

Create a new logger object and set its name.

This fuction is intended for internal use. You should not create Loggers directly.

See: log4g_logger_get_logger()

Since 0.1

log4g_logger_get_name ()

const gchar *       log4g_logger_get_name               (Log4gLogger *self);

Retrieve the fully-qualified name of a logger.

Since 0.1

log4g_logger_set_name ()

void                log4g_logger_set_name               (Log4gLogger *self,
                                                         const gchar *name);

Set the name of a logger.

This method should only be called by sub-classes. Calling this method on a logger in the logger repository will have disastrous effects on the logger hierarchy.

Since 0.1

log4g_logger_get_parent ()

Log4gLogger *       log4g_logger_get_parent             (Log4gLogger *self);

Retrieve the parent of this logger.

Since 0.1

log4g_logger_set_parent ()

void                log4g_logger_set_parent             (Log4gLogger *self,
                                                         Log4gLogger *parent);

Set the parent of a logger.

Since 0.1

log4g_logger_get_level ()

Log4gLevel *        log4g_logger_get_level              (Log4gLogger *self);

Retrieve the level threshold of a logger.

Since 0.1

log4g_logger_set_level ()

void                log4g_logger_set_level              (Log4gLogger *self,
                                                         Log4gLevel *level);

Calls the set_level function from the Log4gLoggerClass of self.

Since 0.1

log4g_logger_get_additivity ()

gboolean            log4g_logger_get_additivity         (Log4gLogger *self);

Retrieve the additivity flag for a logger.

See: log4g_logger_set_additivity()

Since 0.1

log4g_logger_set_additivity ()

void                log4g_logger_set_additivity         (Log4gLogger *self,
                                                         gboolean additive);

Set the additivity flag for a logger.

Logger additivity determines if a logger inherits the appenders of its ancestors. If this flag is set to TRUE (the default value is TRUE) then events logged to this logger will be propagated to the appenders of its ancestors. If this flags is set to FALSE then the appenders of this logger will not be inherited.

Since 0.1

log4g_logger_get_logger_repository ()

gpointer            log4g_logger_get_logger_repository  (Log4gLogger *self);

Retrieve the repository where a logger is attached. See Log4gLoggerRepositoryInterface.

Since 0.1

log4g_logger_set_logger_repository ()

void                log4g_logger_set_logger_repository  (Log4gLogger *self,
                                                         gpointer repository);

Set the repository a logger is attached to.

You probably do not want to call this function.

See: Log4gLoggerRepositoryInterface

Since 0.1

log4g_logger_get_effective_level ()

Log4gLevel *        log4g_logger_get_effective_level    (Log4gLogger *self);

Calls the get_effective_level function from the Log4gLoggerClass of self.

Since 0.1

log4g_logger_add_appender ()

void                log4g_logger_add_appender           (Log4gLogger *self,
                                                         Log4gAppender *appender);

Add an appender to the list of appenders for self.

If appender is already in the list of appenders for self then it will not be added again.

See: Log4gAppenderAttachableInterface

Since 0.1

log4g_logger_get_all_appenders ()

const GArray *      log4g_logger_get_all_appenders      (Log4gLogger *self);

Retrieve all appenders attached to a self.

See: Log4gAppenderAttachableInterface

Since 0.1

log4g_logger_get_appender ()

Log4gAppender *     log4g_logger_get_appender           (Log4gLogger *self,
                                                         const gchar *name);

Retrieve an appender attached to a logger by name.

See: Log4gAppenderAttachableInterface

Since 0.1

log4g_logger_is_attached ()

gboolean            log4g_logger_is_attached            (Log4gLogger *self,
                                                         Log4gAppender *appender);

Determine if an appender is attached to a logger.

See: Log4gAppenderAttachableInterface

Since 0.1

log4g_logger_remove_all_appenders ()

void                log4g_logger_remove_all_appenders   (Log4gLogger *self);

Remove all appenders from a logger.

See: Log4gAppenderAttachableInterface

Since 0.1

log4g_logger_remove_appender ()

void                log4g_logger_remove_appender        (Log4gLogger *self,
                                                         Log4gAppender *appender);

Remove an appender from a logger.

If appender is not attached to self then this function does nothing.

See: Log4gAppenderAttachableInterface

Since 0.1

log4g_logger_remove_appender_name ()

void                log4g_logger_remove_appender_name   (Log4gLogger *self,
                                                         const gchar *name);

Remove an appender from a logger by name.

If name is not found then this function does nothing.

See: Log4gAppenderAttachableInterface

Since 0.1

log4g_logger_close_nested_appenders ()

void                log4g_logger_close_nested_appenders (Log4gLogger *self);

Close all attached appenders implementing the Log4gAppenderAttachable interface.

See: Log4gAppenderAttachableInterface

Since 0.1

log4g_logger_call_appenders ()

void                log4g_logger_call_appenders         (Log4gLogger *self,
                                                         Log4gLoggingEvent *event);

Append a logging event to all appenders attached to this logger.

See: Log4gLoggingEvent

Since 0.1

log4g_logger_is_trace_enabled ()

gboolean            log4g_logger_is_trace_enabled       (Log4gLogger *self);

Check if a logger is enabled for the LOG4G_LEVEL_TRACE level.

This function is useful if you have a to perform a costly operation to construct a log message.

Since 0.1

log4g_logger_is_debug_enabled ()

gboolean            log4g_logger_is_debug_enabled       (Log4gLogger *self);

Check if a logger is enabled for the LOG4G_LEVEL_DEBUG level.

Since 0.1

log4g_logger_is_info_enabled ()

gboolean            log4g_logger_is_info_enabled        (Log4gLogger *self);

Check if a logger is enabled for the LOG4G_LEVEL_INFO level.

Since 0.1

log4g_logger_is_warn_enabled ()

gboolean            log4g_logger_is_warn_enabled        (Log4gLogger *self);

Check if a logger is enabled for the LOG4G_LEVEL_WARN level.

Since 0.1

log4g_logger_is_error_enabled ()

gboolean            log4g_logger_is_error_enabled       (Log4gLogger *self);

Check if a logger is enabled for the LOG4G_LEVEL_ERROR level.

Since 0.1

log4g_logger_is_fatal_enabled ()

gboolean            log4g_logger_is_fatal_enabled       (Log4gLogger *self);

Check if a logger is enabled for the LOG4G_LEVEL_FATAL level.

Since 0.1

log4g_logger_get_logger ()

Log4gLogger *       log4g_logger_get_logger             (const gchar *name);

Retrieve a named logger.

If the named logger already exists, then the existing instance will be returned. Otherwise a new instance is created.

Loggers inherit their default level from their nearest ancestor with a set level.

Since 0.1

log4g_logger_get_root_logger ()

Log4gLogger *       log4g_logger_get_root_logger        (void);

Retrieve the root logger for the current logger repository.

Calling log4g_logger_get_name() on the root logger always returns the string "root". Calling log4g_logger_get_logger("root") however does not retrieve the root logger but a logger just under root named "root".

Calling this function is the only way to retrieve the root logger.

Since 0.1

log4g_logger_get_logger_factory ()

Log4gLogger *       log4g_logger_get_logger_factory     (const gchar *name,
                                                         gpointer factory);

Retrieve a named logger.

If the named logger already exists, then the existing instance will be returned. Otherwise factory is used to create a new instance.

Since 0.1

log4g_logger_forced_log ()

void                log4g_logger_forced_log             (Log4gLogger *self,
                                                         Log4gLevel *level,
                                                         const gchar *function,
                                                         const gchar *file,
                                                         const gchar *line,
                                                         const gchar *format,
                                                         va_list ap);

Create and log a new event without further checks.

Since 0.1

Log4gLoggerGetEffectiveLevel ()

Log4gLevel          (*Log4gLoggerGetEffectiveLevel)     (Log4gLogger *self);

Starting from this category, search the category hierarchy for a non-NULL and return it. If a non-NULL level is not found, this function returns the level of the root logger.

Since 0.1

Log4gLoggerSetLevel ()

void                (*Log4gLoggerSetLevel)              (Log4gLogger *self,
                                                         Log4gLevel *level);

Since 0.1