logger.cpp

/*---------------------------------------------------------------------------*\
*
*  bitpit
*
*  Copyright (C) 2015-2021 OPTIMAD engineering Srl
*
*  -------------------------------------------------------------------------
*  License
*  This file is part of bitpit.
*
*  bitpit is free software: you can redistribute it and/or modify it
*  under the terms of the GNU Lesser General Public License v3 (LGPL)
*  as published by the Free Software Foundation.
*
*  bitpit is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
*  FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
*  License for more details.
*
*  You should have received a copy of the GNU Lesser General Public License
*  along with bitpit. If not, see <http://www.gnu.org/licenses/>.
*
\*---------------------------------------------------------------------------*/
 
#include <array>
#include <cassert>
#include <cctype>
#include <cmath>
#include <chrono>
#include <cstdio>
#include <ctime>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <memory>
#include <sstream>
#include <functional>
#include <sys/types.h>
#include <sys/stat.h>
#include <type_traits>
 
#include "compiler.hpp"
#include "fileHandler.hpp"
#include "logger.hpp"
 
namespace bitpit{


LoggerBuffer::LoggerBuffer(int nProcesses, int rank, std::size_t bufferSize)
    : m_buffer(bufferSize + 1),
      m_nProcesses(nProcesses), m_rank(rank),
      m_consoleEnabled(false), m_console(&std::cout),
      m_fileEnabled(false), m_file(nullptr),
      m_settings(std::make_shared<Settings>())
{
    // Set the buffer
    char *bufferBegin = &m_buffer.front();
    setp(bufferBegin, bufferBegin + m_buffer.size() - 1);
 
    // Initialize console stream
    setConsoleEnabled(true);
 
    // Initialize file stream
    setFileEnabled(false);
 
    // Set parallel data
    if (m_nProcesses > 1) {
        int nDigits = static_cast<int>(std::ceil(log10(m_nProcesses)));
        std::ostringstream convert;
        convert << std::setw(nDigits) << m_rank;
        m_rankPrefix = "#" + convert.str();
    } else {
        m_rankPrefix = "";
    }
 
    // Default settings
    m_settings->context = "";
    m_settings->indentation = 0;
    m_settings->consoleTimestampEnabled = false;
    m_settings->fileTimestampEnabled = false;
}

LoggerBuffer::~LoggerBuffer()
{
    sync();
}

int LoggerBuffer::getProcessCount() const
{
    return m_nProcesses;
}

int LoggerBuffer::getRank() const
{
    return m_rank;
}

LoggerBuffer::int_type LoggerBuffer::overflow(int_type character)
{
    if (character != traits_type::eof()) {
        // Write the character to the buffer and then increment pptr() by
        // calling pbump(1). It's always safe to write the charater to the
        // buffer because we reserved an extra char at the end of our buffer
        // in the constructor.
        assert(std::less_equal<char *>()(pptr(), epptr()));
        *pptr() = character;
        pbump(1);
 
        // Flush the stream
        if (sync() == 0) {
            return character;
        }
    }
 
    return traits_type::eof();
}

int LoggerBuffer::sync()
{
    return flush(false);
}

int LoggerBuffer::flush(bool terminate)
{
    // Get buffer information
    const char *bufferBegin = pbase();
    const char *bufferEnd   = pptr();
    if (bufferBegin == bufferEnd) {
        return 0;
    }
 
    // Flush buffer a line at the time
    static const std::string EMPTY_STRING = "";
 
    const char *lineBegin = nullptr;
    const char *lineEnd   = bufferBegin;
    while (lineEnd != bufferEnd) {
        // Update line information
        lineBegin = lineEnd;
        for (lineEnd = lineBegin; lineEnd != bufferEnd; ++lineEnd) {
            if (*lineEnd == '\n') {
                lineEnd += 1;
                break;
            }
        }
 
        // Detect if a new line must be added at the end of the line
        bool terminateLine = false;
        if (terminate && (lineEnd == bufferEnd)) {
            if (bufferBegin == bufferEnd) {
                terminateLine = true;
            } else if (*(bufferEnd - 1) != '\n') {
                terminateLine = true;
            }
        }
 
        // Get timestamp
        std::string timestamp;
        if (m_settings->consoleTimestampEnabled || m_settings->fileTimestampEnabled) {
            timestamp = getTimestamp();
        }
 
        // Flush line to console
        if (m_console && m_consoleEnabled) {
            const std::string *consoleTimestamp;
            if (m_settings->consoleTimestampEnabled) {
                consoleTimestamp = &timestamp;
            } else {
                consoleTimestamp = &EMPTY_STRING;
            }
 
            int status = flushLine(*m_console, lineBegin, lineEnd, *consoleTimestamp, terminateLine);
            if (status != 0) {
                return status;
            }
        }
 
        // Flush line to file
        if (m_file && m_fileEnabled && m_file->is_open()) {
            const std::string *fileTimestamp;
            if (m_settings->fileTimestampEnabled) {
                fileTimestamp = &timestamp;
            } else {
                fileTimestamp = &EMPTY_STRING;
            }
 
            int status = flushLine(*m_file, lineBegin, lineEnd, *fileTimestamp, terminateLine);
            if (status != 0) {
                return status;
            }
        }
    }
 
    // Reset the internal pointer
    pbump(static_cast<int>(bufferBegin - bufferEnd));
 
    return 0;
}

int LoggerBuffer::flushLine(std::ostream &stream, const char *begin, const char *end,
                            const std::string &timestamp, bool terminate)
{
    if (!timestamp.empty()) {
        stream << "[" + timestamp + "] ";
        if ((stream.rdstate() & std::ifstream::failbit) != 0) {
            return -1;
        }
    }
 
    if (!m_rankPrefix.empty()) {
        stream << m_rankPrefix << " :: ";
        if ((stream.rdstate() & std::ifstream::failbit) != 0) {
            return -1;
        }
    }
 
    if (!m_settings->context.empty()) {
        stream << m_settings->context + " :: ";
        if ((stream.rdstate() & std::ifstream::failbit) != 0) {
            return -1;
        }
    }
 
    for (int i = 0; i < m_settings->indentation; ++i) {
        stream << " ";
        if ((stream.rdstate() & std::ifstream::failbit) != 0) {
            return -1;
        }
    }
 
    stream.write(begin, end - begin);
    if ((stream.rdstate() & std::ifstream::failbit) != 0) {
        return -1;
    }
 
    if (terminate) {
        stream << "\n";
        if ((stream.rdstate() & std::ifstream::failbit) != 0) {
            return -1;
        }
    }
 
    return 0;
}

void LoggerBuffer::setConsoleEnabled(bool enabled)
{
    if (m_consoleEnabled == enabled) {
        return;
    }
 
    flush(true);
 
    m_consoleEnabled = enabled;
}

void LoggerBuffer::setConsoleStream(std::ostream *console)
{
    flush(true);
 
    m_console = console;
}

std::ostream & LoggerBuffer::getConsoleStream()
{
    return *m_console;
}

void LoggerBuffer::setFileEnabled(bool enabled)
{
    if (m_fileEnabled == enabled) {
        return;
    }
 
    flush(true);
 
    m_fileEnabled = enabled;
}

void LoggerBuffer::setFileStream(std::ofstream *file)
{
    flush(true);
 
    m_file = file;
}

std::ofstream & LoggerBuffer::getFileStream()
{
    return *m_file;
}

const LoggerBuffer::Settings * LoggerBuffer::getSettings() const
{
    return m_settings.get();
}

void LoggerBuffer::setSettings(const std::shared_ptr<Settings> &settings)
{
    if (settings.get() == m_settings.get()) {
        return;
    }
 
    flush(true);
 
    m_settings = settings;
}

std::string LoggerBuffer::getTimestamp() const
{
    static const std::string TIMESTAMP_FORMAT = "%Y-%m-%d %H:%M:%S";
 
    auto currentClock = std::chrono::system_clock::now();
    std::time_t currentTime = std::chrono::system_clock::to_time_t(currentClock);
 
    auto seconds = std::chrono::duration_cast<std::chrono::seconds>(currentClock.time_since_epoch());
    auto millisecs = std::chrono::duration_cast<std::chrono::milliseconds>(currentClock.time_since_epoch() - seconds);
    std::array<char, 11> millisecsBuffer;
    std::snprintf(millisecsBuffer.data(), millisecsBuffer.size(), "%03u", static_cast<unsigned int>(millisecs.count()));
 
    std::string timestamp;
    timestamp.resize(23);
    std::strftime(&timestamp[0], timestamp.size(), TIMESTAMP_FORMAT.c_str(), localtime(&currentTime));
    timestamp[19] = '.';
    timestamp[20] = millisecsBuffer[0];
    timestamp[21] = millisecsBuffer[1];
    timestamp[22] = millisecsBuffer[2];
 
    return timestamp;
}


Logger::Logger(const std::string &name, const std::shared_ptr<LoggerBuffer> &buffer)
    : std::ios(nullptr), std::ostream(nullptr),
      m_name(name),
      m_buffer(buffer), m_bufferSettings(std::make_shared<LoggerBuffer::Settings>()),
      m_defaultSeverity(log::LEVEL_INFO), m_defaultVisibility(log::VISIBILITY_MASTER),
      m_consoleDisabledThreshold(log::LEVEL_NOTSET), m_consoleVerbosityThreshold(log::LEVEL_INFO),
      m_fileDisabledThreshold(log::LEVEL_NOTSET), m_fileVerbosityThreshold(log::LEVEL_INFO)
{
    // St stream buffer
    basic_ios<char>::rdbuf(m_buffer.get());
 
    // Default settings
    m_bufferSettings->context = "";
    m_bufferSettings->indentation = 0;
    m_bufferSettings->consoleTimestampEnabled = false;
    m_bufferSettings->fileTimestampEnabled = true;
}

void Logger::disable(log::Level level)
{
    disableConsole(level);
    disableFile(level);
}

void Logger::disableConsole(log::Level level)
{
    m_consoleDisabledThreshold = level;
}

void Logger::disableFile(log::Level level)
{
    m_fileDisabledThreshold = level;
}

void Logger::setDefaultSeverity(log::Level severity)
{
    // Set default severity
    assert(severity != log::Level::LEVEL_NOTSET);
    m_defaultSeverity = severity;
}

log::Level Logger::getDefaultSeverity()
{
    return m_defaultSeverity;
}

void Logger::setPriority(log::Priority priority)
{
    setDefaultSeverity(priority);
}

log::Priority Logger::getPriority()
{
    return getDefaultSeverity();
}

void Logger::setDefaultVisibility(log::Visibility visibility)
{
    // Set default visibility
    assert(visibility != log::VISIBILITY_NOTSET);
    m_defaultVisibility = visibility;
}

log::Visibility Logger::getDefaultVisibility()
{
    return m_defaultVisibility;
}

void Logger::setVisibility(log::Visibility visibility)
{
    setDefaultVisibility(visibility);
}

log::Visibility Logger::getVisibility()
{
    return getDefaultVisibility();
}

void Logger::setVerbosities(log::Level threshold)
{
    setConsoleVerbosity(threshold);
    setFileVerbosity(threshold);
}

void Logger::setTimestampEnabled(bool enabled)
{
    setConsoleTimestampEnabled(enabled);
    setFileTimestampEnabled(enabled);
}

bool Logger::isConsoleTimestampEnabled() const
{
    return m_bufferSettings->consoleTimestampEnabled;
}

void Logger::setConsoleTimestampEnabled(bool enabled)
{
    if (m_bufferSettings->consoleTimestampEnabled == enabled) {
        return;
    }
 
    m_buffer->flush(true);
 
    m_bufferSettings->consoleTimestampEnabled = enabled;
}

void Logger::setConsoleVerbosity(log::Level threshold)
{
    // Set verbosity threshold
    m_consoleVerbosityThreshold = threshold;
}

void Logger::enableBufferStreams(log::Level severity, log::Visibility visibility)
{
    // Enable console stream
    bool isConsoleEnabled = true;
    if (severity <= m_consoleDisabledThreshold) {
        isConsoleEnabled = false;
    } else if (visibility == log::VISIBILITY_MASTER && (m_buffer->getRank() != 0)) {
        isConsoleEnabled = false;
    } else {
        isConsoleEnabled = (severity >= m_consoleVerbosityThreshold);
    }
    m_buffer->setConsoleEnabled(isConsoleEnabled);
 
    // Enable file stream
    bool isFileEnabled = true;
    if (severity <= m_fileDisabledThreshold) {
        isFileEnabled = false;
    } else if (visibility == log::VISIBILITY_MASTER && (m_buffer->getRank() != 0)) {
        isFileEnabled = false;
    } else {
        isFileEnabled = (severity >= m_fileVerbosityThreshold);
    }
    m_buffer->setFileEnabled(isFileEnabled);
}

log::Level Logger::getConsoleVerbosity()
{
    return m_consoleVerbosityThreshold;
}

bool Logger::isFileTimestampEnabled() const
{
    return m_bufferSettings->fileTimestampEnabled;
}

void Logger::setFileTimestampEnabled(bool enabled)
{
    if (m_bufferSettings->fileTimestampEnabled == enabled) {
        return;
    }
 
    m_buffer->flush(true);
 
    m_bufferSettings->fileTimestampEnabled = enabled;
}

void Logger::setFileVerbosity(log::Level threshold)
{
    // Set verbosity threshold
    m_fileVerbosityThreshold = threshold;
}

log::Level Logger::getFileVerbosity()
{
    return m_fileVerbosityThreshold;
}

void Logger::setContext(const std::string &context)
{
    if (m_bufferSettings->context == context) {
        return;
    }
 
    m_buffer->flush(true);
 
    m_bufferSettings->context = context;
}

std::string Logger::getContext()
{
    return m_bufferSettings->context;
}

void Logger::setIndentation(int delta)
{
    if (delta == 0) {
        return;
    }
 
    m_buffer->flush(true);
 
    m_bufferSettings->indentation += delta;
}

int Logger::getIndentation()
{
    return m_bufferSettings->indentation;
}

std::string Logger::getName() const
{
    return m_name;
}

void Logger::println(const std::string &line)
{
    print(line + '\n');
}

void Logger::println(const std::string &line, log::Level severity)
{
    print(line + '\n', severity);
}

void Logger::println(const std::string &line, log::Visibility visibility)
{
    print(line + '\n', visibility);
}

void Logger::println(const std::string &line, log::Level severity, log::Visibility visibility)
{
    print(line + '\n', severity, visibility);
}

void Logger::print(const std::string &message)
{
    print(message, getDefaultSeverity(), getDefaultVisibility());
}

void Logger::print(const std::string &message, log::Level severity)
{
    print(message, severity, getDefaultVisibility());
}

void Logger::print(const std::string &message, log::Visibility visibility)
{
    print(message, getDefaultSeverity(), visibility);
}

void Logger::print(const std::string &message, log::Level severity, log::Visibility visibility)
{
    print<const std::string &>(message, severity, visibility);
}

 
/*
    Initialize logger manager instance.
*/
std::unique_ptr<LoggerManager> LoggerManager::m_manager = nullptr;
 
/*
    Default name for the logger.
*/
std::string LoggerManager::BITPIT_LOG_NAME = "bitpit";
 
/*
    Default directory for the logger.
*/
std::string LoggerManager::BITPIT_LOG_DIRECTORY = ".";

LoggerManager::LoggerManager()
    : m_defaultName(BITPIT_LOG_NAME), m_defaultDirectory(BITPIT_LOG_DIRECTORY),
    m_mode(log::MODE_SEPARATE)
{
 
}

LoggerManager::~LoggerManager()
{
    // Get a list of the loggers
    std::vector<std::string> loggerNames;
    loggerNames.reserve(m_loggers.size());
    for (const auto &entry : m_loggers) {
        loggerNames.push_back(entry.first);
    }
 
    // Destroy all the loggers
    for (const std::string &name : loggerNames) {
        destroy(name, true);
    }
}

LoggerManager & LoggerManager::manager()
{
    if (!m_manager) {
        m_manager = std::unique_ptr<LoggerManager>(new LoggerManager());
    }
 
    return *m_manager;
}

Logger & LoggerManager::cout(log::Level defaultSeverity, log::Visibility defaultVisibility)
{
    return cout(m_defaultName, defaultSeverity, defaultVisibility);
}

Logger & LoggerManager::cout(const std::string &name, log::Level defaultSeverity, log::Visibility defaultVisibility)
{
    // Get the logger
    if (m_loggers.count(name) == 0) {
        if (!isInitialized()) {
            setMode(log::MODE_SEPARATE);
        }
 
        if (name == m_defaultName) {
            _create(name, false, m_defaultDirectory, 1, 0);
        } else {
            create(name, false, m_defaultDirectory, 1, 0);
        }
    }
 
    Logger &logger = *(m_loggers.at(name));
 
    // Set default properties
    if (defaultSeverity != log::Level::LEVEL_NOTSET) {
        logger.setDefaultSeverity(defaultSeverity);
    }
 
    if (defaultVisibility != log::VISIBILITY_NOTSET) {
        logger.setDefaultVisibility(defaultVisibility);
    }
 
    // Return the logger
    return logger;
}

Logger & LoggerManager::critical(log::Visibility defaultVisibility)
{
    return critical(m_defaultName, defaultVisibility);
}

Logger & LoggerManager::critical(const std::string &name, log::Visibility defaultVisibility)
{
    return cout(name, log::Level::LEVEL_CRITICAL, defaultVisibility);
}

Logger & LoggerManager::error(log::Visibility defaultVisibility)
{
    return error(m_defaultName, defaultVisibility);
}

Logger & LoggerManager::error(const std::string &name, log::Visibility defaultVisibility)
{
    return cout(name, log::Level::LEVEL_ERROR, defaultVisibility);
}

Logger & LoggerManager::warning(log::Visibility defaultVisibility)
{
    return warning(m_defaultName, defaultVisibility);
}

Logger & LoggerManager::warning(const std::string &name, log::Visibility defaultVisibility)
{
    return cout(name, log::Level::LEVEL_WARNING, defaultVisibility);
}

Logger & LoggerManager::info(log::Visibility defaultVisibility)
{
    return info(m_defaultName, defaultVisibility);
}

Logger & LoggerManager::info(const std::string &name, log::Visibility defaultVisibility)
{
    return cout(name, log::Level::LEVEL_INFO, defaultVisibility);
}

Logger & LoggerManager::debug(log::Visibility defaultVisibility)
{
    return debug(m_defaultName, defaultVisibility);
}

Logger & LoggerManager::debug(const std::string &name, log::Visibility defaultVisibility)
{
    return cout(name, log::Level::LEVEL_DEBUG, defaultVisibility);
}

void LoggerManager::initialize(log::Mode mode, bool reset,
                            int nProcesses, int rank)
{
    initialize(mode, m_defaultName, reset, m_defaultDirectory, nProcesses, rank);
}

void LoggerManager::initialize(log::Mode mode, bool reset, const std::string &directory,
                            int nProcesses, int rank)
{
    initialize(mode, m_defaultName, reset, directory, nProcesses, rank);
}

void LoggerManager::initialize(log::Mode mode, const std::string &name, bool reset,
                            const std::string &directory,
                            int nProcesses, int rank)
{
    if (isInitialized()) {
        log::cout().println("Logger initialization has to be called before creating the loggers.");
        return;
    }
 
    // Set mode
    setMode(mode);
 
    // Set the dafault data
    m_defaultName      = name;
    m_defaultDirectory = directory;
 
    // Create the logger
    _create(m_defaultName, reset, directory, nProcesses, rank);
}

void LoggerManager::create(const std::string &name, bool reset,
                           int nProcesses, int rank)
{
    create(name, reset, m_defaultDirectory, nProcesses, rank);
}

void LoggerManager::create(const std::string &name, bool reset,
                           const std::string &directory,
                           int nProcesses, int rank)
{
    // Its not possible to create a log with the default name nor a log
    // with the same name of an existent logger nor a log with an empty
    // name
    if (exists(name)) {
        m_loggerUsers[name]++;
 
        cout(name) << "Detected an attemp to create the logger \"" << name << "\" twice" << std::endl;
        cout(name) << "The previously created logger will be used." << std::endl;
        return;
    } else if (name == m_defaultName) {
        cout(m_defaultName) << "Detected an attemp to overwrite the default logger" << std::endl;
        cout(m_defaultName) << "The name of the default logger is \"" << name << "\"" << std::endl;
        return;
    } else if (name == "") {
        cout() << "Detected an attemp to create a logger with an empty name" << std::endl;
        return;
    }
 
    // Create the logger
    if (m_mode == log::MODE_SEPARATE) {
        _create(name, reset, directory, nProcesses, rank);
    } else {
        Logger &defaultLogger = cout(m_defaultName);
        _create(name, defaultLogger.m_buffer);
    }
}

bool LoggerManager::destroy(const std::string &name, bool force)
{
    if (!exists(name)) {
        return false;
    }
 
    // Decrement the users
    int &nUsers = m_loggerUsers[name];
    nUsers--;
 
    // If the logger has no users we can delete it
    if (nUsers == 0 || force) {
        // Remove the logger from the manager
        m_loggers.erase(name);
        m_loggerUsers.erase(name);
 
        // If the logger has it own file stream, delete it
        if (m_fileStreams.count(name) > 0) {
            // Close the stream
            std::ofstream &fileStream = *(m_fileStreams.at(name));
            fileStream.close();
 
            // Remove the stream
            m_fileStreams.erase(name);
        }
 
        return true;
    } else {
        return false;
    }
}

bool LoggerManager::exists(const std::string &name) const
{
    return (m_loggers.count(name) != 0);
}

bool LoggerManager::isInitialized() const
{
    return (m_loggers.size() > 0);
}

bool LoggerManager::setMode(log::Mode mode)
{
    if (isInitialized()) {
        cout().println("The policy has to be set before creating the loggers.");
        return false;
    }
 
    m_mode = mode;
    return true;
}

log::Mode LoggerManager::getMode() const
{
    return m_mode;
}

void LoggerManager::_create(const std::string &name, bool reset,
                            const std::string &directory,
                            int nProcesses, int rank)
{
    // Get the file path
    FileHandler fileHandler;
    fileHandler.setDirectory(directory);
    fileHandler.setName(name);
    fileHandler.setAppendix("log");
    fileHandler.setParallel(nProcesses > 1);
    if (nProcesses > 1) {
        fileHandler.setBlock(rank);
    }
 
    std::string filePath = fileHandler.getPath();
 
    // Create the file stream
    std::ios_base::openmode fileMode;
    if (reset) {
        fileMode = std::ofstream::out;
    } else {
        fileMode = std::ofstream::app;
    }
 
    m_fileStreams[name] = std::unique_ptr<std::ofstream>(new std::ofstream());
    std::ofstream &fileStream = *(m_fileStreams.at(name));
    fileStream.rdbuf()->pubsetbuf(0, 0);
    fileStream.open(filePath, fileMode);
 
    // Use cout as console stream
    std::ostream &consoleStream = std::cout;
 
    // Create the buffer
    std::shared_ptr<LoggerBuffer> buffer = std::make_shared<LoggerBuffer>(nProcesses, rank, 256);
    buffer->setFileStream(&fileStream);
    buffer->setConsoleStream(&consoleStream);
 
    // Create the logger
    _create(name, buffer);
}

void LoggerManager::_create(const std::string &name, std::shared_ptr<LoggerBuffer> &buffer)
{
    m_loggers[name]     = std::unique_ptr<Logger>(new Logger(name,  buffer));
    m_loggerUsers[name] = 1;
}

void LoggerManager::setVerbosities(log::Level threshold)
{
    for (auto &entry : m_loggers) {
        entry.second->setVerbosities(threshold);
    }
}

void LoggerManager::setConsoleVerbosity(log::Level threshold)
{
    for (auto &entry : m_loggers) {
        entry.second->setConsoleVerbosity(threshold);
    }
}

void LoggerManager::setFileVerbosity(log::Level threshold)
{
    for (auto &entry : m_loggers) {
        entry.second->setFileVerbosity(threshold);
    }
}

std::string LoggerManager::getDefaultName() const
{
    return m_defaultName;
}

std::string LoggerManager::getDefaultDirectory() const
{
    return m_defaultDirectory;
}
 
// Logger global functions
namespace log {




 
    // Generic global functions

    LoggerManager & manager()
    {
        return LoggerManager::manager();
    }

    Logger & cout(log::Level defaultSeverity, log::Visibility defaultVisibility)
    {
        return manager().cout(defaultSeverity, defaultVisibility);
    }

    Logger & cout(const std::string &name, log::Level defaultSeverity, log::Visibility defaultVisibility)
    {
        return manager().cout(name, defaultSeverity, defaultVisibility);
    }

    Logger & critical(log::Visibility defaultVisibility)
    {
        return manager().critical(defaultVisibility);
    }

    Logger & critical(const std::string &name, log::Visibility defaultVisibility)
    {
        return manager().critical(name, defaultVisibility);
    }

    Logger & error(log::Visibility defaultVisibility)
    {
        return manager().error(defaultVisibility);
    }

    Logger & error(const std::string &name, log::Visibility defaultVisibility)
    {
        return manager().error(name, defaultVisibility);
    }

    Logger & warning(log::Visibility defaultVisibility)
    {
        return manager().warning(defaultVisibility);
    }

    Logger & warning(const std::string &name, log::Visibility defaultVisibility)
    {
        return manager().warning(name, defaultVisibility);
    }

    Logger & info(log::Visibility defaultVisibility)
    {
        return manager().info(defaultVisibility);
    }

    Logger & info(const std::string &name, log::Visibility defaultVisibility)
    {
        return manager().info(name, defaultVisibility);
    }

    Logger & debug(log::Visibility defaultVisibility)
    {
        return manager().debug(defaultVisibility);
    }

    Logger & debug(const std::string &name, log::Visibility defaultVisibility)
    {
        return manager().debug(name, defaultVisibility);
    }
 
    // Manipulators global functions

    Logger & setContext(Logger &logger, const std::string &context)
    {
        logger.setContext(context);
 
        return logger;
    }

    LoggerManipulator<std::string> context(const std::string &context)
    {
        return LoggerManipulator<std::string>(setContext, context);
    }

    Logger & setDefaultSeverity(Logger &logger, const log::Level &severity)
    {
        logger.setDefaultSeverity(severity);
 
        return logger;
    }

    LoggerManipulator<log::Level> defaultSeverity(const log::Level &severity)
    {
        return LoggerManipulator<log::Level>(setDefaultSeverity, severity);
    }

    Logger & setPriority(Logger &logger, const log::Priority &priority)
    {
        logger.setDefaultSeverity(priority);
 
        return logger;
    }

    LoggerManipulator<log::Priority> priority(const log::Priority &priority)
    {
        return LoggerManipulator<log::Priority>(setDefaultSeverity, priority);
    }

    Logger & setDefaultVisibility(Logger &logger, const log::Visibility &visibility)
    {
        logger.setDefaultVisibility(visibility);
 
        return logger;
    }

    LoggerManipulator<log::Visibility> defaultVisibility(const log::Visibility &visibility)
    {
        return LoggerManipulator<log::Visibility>(setDefaultVisibility, visibility);
    }

    Logger & setVisibility(Logger &logger, const log::Visibility &visibility)
    {
        logger.setDefaultVisibility(visibility);
 
        return logger;
    }

    LoggerManipulator<log::Visibility> visibility(const log::Visibility &visibility)
    {
        return LoggerManipulator<log::Visibility>(setDefaultVisibility, visibility);
    }

    Logger & setVerbosities(Logger &logger, const log::Level &threshold)
    {
        logger.setVerbosities(threshold);
 
        return logger;
    }

    LoggerManipulator<log::Level> verbosities(const log::Level &threshold)
    {
        return LoggerManipulator<log::Level>(setVerbosities, threshold);
    }

    Logger & setConsoleVerbosity(Logger &logger, const log::Level &threshold)
    {
        logger.setConsoleVerbosity(threshold);
 
        return logger;
    }

    LoggerManipulator<log::Level> consoleVerbosity(const log::Level &threshold)
    {
        return LoggerManipulator<log::Level>(setConsoleVerbosity, threshold);
    }

    Logger & setFileVerbosity(Logger &logger, const log::Level &threshold)
    {
        logger.setFileVerbosity(threshold);
 
        return logger;
    }

    LoggerManipulator<log::Level> fileVerbosity(const log::Level &threshold)
    {
        return LoggerManipulator<log::Level>(setFileVerbosity, threshold);
    }

    Logger & disable(Logger &logger, const log::Level &level)
    {
        logger.disable(level);
 
        return logger;
    }

    LoggerManipulator<log::Level> disable(const log::Level &level)
    {
        return LoggerManipulator<log::Level>(disable, level);
    }

    Logger & disableConsole(Logger &logger, const log::Level &level)
    {
        logger.disableConsole(level);
 
        return logger;
    }

    LoggerManipulator<log::Level> disableConsole(const log::Level &level)
    {
        return LoggerManipulator<log::Level>(disableConsole, level);
    }

    Logger & disableFile(Logger &logger, const log::Level &level)
    {
        logger.disableFile(level);
 
        return logger;
    }

    LoggerManipulator<log::Level> disableFile(const log::Level &level)
    {
        return LoggerManipulator<log::Level>(disableFile, level);
    }

    Logger & setIndentation(Logger &logger, const int &delta)
    {
        logger.setIndentation(delta);
 
        return logger;
    }

    LoggerManipulator<int> indent(int delta)
    {
        return LoggerManipulator<int>(setIndentation, delta);
    }
}
 
}