logger_impl.h

Go to the documentation of this file.

// Copyright (C) 2011-2022 Internet Systems Consortium, Inc. ("ISC")
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
#ifndef LOGGER_IMPL_H
#define LOGGER_IMPL_H
 
#include <stdarg.h>
#include <time.h>
 
#include <iostream>
#include <cstdlib>
#include <string>
#include <map>
#include <utility>
 
#include <boost/shared_ptr.hpp>
#include <boost/noncopyable.hpp>
 
// log4cplus logger header file
#include <log4cplus/logger.h>
 
// Kea logger files
#include <log/logger_level_impl.h>
#include <log/message_types.h>
#include <log/interprocess/interprocess_sync.h>
#include <log/output_option.h>
 
namespace isc {
namespace log {
 
 
class LoggerImpl : public boost::noncopyable {
public:
 
    LoggerImpl(const std::string& name);
 
 
    virtual ~LoggerImpl();
 
 
    static std::string getVersion();
 
 
    virtual std::string getName() {
        return (name_);
    }
    virtual std::string getName() {…}
 
 
    virtual void setSeverity(Severity severity, int dbglevel = 1);
 
 
    virtual Severity getSeverity();
 
 
    virtual Severity getEffectiveSeverity();
 
 
    virtual int getDebugLevel();
 
 
    virtual int getEffectiveDebugLevel();
 
 
    virtual bool isDebugEnabled(int dbglevel = MIN_DEBUG_LEVEL) {
        Level level(DEBUG, dbglevel);
        return logger_.isEnabledFor(LoggerLevelImpl::convertFromBindLevel(level));
    }
    virtual bool isDebugEnabled(int dbglevel = MIN_DEBUG_LEVEL) {…}
 
    virtual bool isInfoEnabled() {
        return (logger_.isEnabledFor(log4cplus::INFO_LOG_LEVEL));
    }
    virtual bool isInfoEnabled() {…}
 
    virtual bool isWarnEnabled() {
        return (logger_.isEnabledFor(log4cplus::WARN_LOG_LEVEL));
    }
    virtual bool isWarnEnabled() {…}
 
    virtual bool isErrorEnabled() {
        return (logger_.isEnabledFor(log4cplus::ERROR_LOG_LEVEL));
    }
    virtual bool isErrorEnabled() {…}
 
    virtual bool isFatalEnabled() {
        return (logger_.isEnabledFor(log4cplus::FATAL_LOG_LEVEL));
    }
    virtual bool isFatalEnabled() {…}
 
    void outputRaw(const Severity& severity, const std::string& message);
 
    boost::shared_ptr<std::string> lookupMessage(const MessageID& id);
 
    void setInterprocessSync(isc::log::interprocess::InterprocessSync* sync);
 
    bool hasAppender(OutputOption::Destination const destination);
 
    bool operator==(const LoggerImpl& other) const {
        return (name_ == other.name_);
    }
    bool operator==(const LoggerImpl& other) const  {…}
 
private:
    std::string                  name_;   
    log4cplus::Logger            logger_; 
    isc::log::interprocess::InterprocessSync* sync_;
};
class LoggerImpl : public boost::noncopyable {…};
 
} // namespace log
} // namespace isc
 
 
#endif // LOGGER_IMPL_H