/*

 * Licensed to the Apache Software Foundation (ASF) under one or more

 * contributor license agreements.  See the NOTICE file distributed with

 * this work for additional information regarding copyright ownership.

 * The ASF licenses this file to You under the Apache License, Version 2.0

 * (the "License"); you may not use this file except in compliance with

 * the License.  You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

#ifndef _LOG4CXX_LOGGER_H

#define _LOG4CXX_LOGGER_H

#include <log4cxx/spi/appenderattachable.h>

#include <log4cxx/level.h>

#include <log4cxx/helpers/pool.h>

#include <log4cxx/spi/location/locationinfo.h>

#include <log4cxx/helpers/resourcebundle.h>

#include <log4cxx/helpers/asyncbuffer.h>

#include <log4cxx/helpers/messagebuffer.h>

namespace LOG4CXX_NS

{

namespace spi

{

class LoggerRepository;

LOG4CXX_PTR_DEF(LoggerRepository);

class LoggerFactory;

LOG4CXX_PTR_DEF(LoggerFactory);

}

class Logger;

/** smart pointer to a Logger class */

LOG4CXX_PTR_DEF(Logger);

LOG4CXX_LIST_DEF(LoggerList, LoggerPtr);

/**

This is the central class in the log4cxx package. Most logging

operations, except configuration, are done through this class.

*/

class LOG4CXX_EXPORT Logger

  : public virtual spi::AppenderAttachable

{

  public:

    DECLARE_ABSTRACT_LOG4CXX_OBJECT(Logger)

    BEGIN_LOG4CXX_CAST_MAP()

    LOG4CXX_CAST_ENTRY(Logger)

    LOG4CXX_CAST_ENTRY(spi::AppenderAttachable)

    END_LOG4CXX_CAST_MAP()

  private:

    LOG4CXX_DECLARE_PRIVATE_MEMBER_PTR(LoggerPrivate, m_priv)

    int m_threshold; //!< The cached level of this logger

  public:

    /**

    This constructor initializes a new <code>logger</code> instance and

    sets its name.

    <p>It is intended to be only used by factory-classes.

    */

    Logger(const LogString& name);

#if LOG4CXX_ABI_VERSION <= 15

    [[ deprecated( "Pool is no longer required" ) ]]

    Logger(helpers::Pool& pool, const LogString& name);

#endif

    ~Logger();

    /**

    Add <code>newAppender</code> to the list of appenders of this

    Logger instance.

    <p>If <code>newAppender</code> is already in the list of

    appenders, then it won't be added again.

    */

    void addAppender(const AppenderPtr newAppender) override;

    /**

    Call the appenders in the hierrachy starting at

    <code>this</code>.  If no appenders could be found, emit a

    warning.

    <p>This method calls all the appenders inherited from the

    hierarchy circumventing any evaluation of whether to log or not

    to log the particular log request.

    @param event the event to log.

    @param p memory pool for any allocations needed to process request.

    */

    void callAppenders(const spi::LoggingEventPtr& event, helpers::Pool& p) const;

    /**

    Close all attached appenders implementing the AppenderAttachable

    interface.

    */

    void closeNestedAppenders();

    /**

    Add a new logging event containing \c msg and \c location to attached appender(s) if this logger is enabled for <code>DEBUG</code> events.

    <p>This method first checks if this logger is <code>DEBUG</code>

    enabled by comparing the level of this logger with the

    DEBUG level. If this logger is

    <code>DEBUG</code> enabled, it proceeds to call all the

    registered appenders in this logger and also higher in the

    hierarchy depending on the value of the additivity flag.

    @param msg the message string to log.

    @param location The source code location of the logging request.

    */

    void debug(const std::string& msg, const LOG4CXX_NS::spi::LocationInfo& location) const;

    /**

    Add a new logging event containing \c msg to attached appender(s) if this logger is enabled for <code>DEBUG</code> events.

    <p>This method first checks if this logger is <code>DEBUG</code>

    enabled by comparing the level of this logger with the

    DEBUG level. If this logger is

    <code>DEBUG</code> enabled, it proceeds to call all the

    registered appenders in this logger and also higher in the

    hierarchy depending on the value of the additivity flag.

    @param msg the message string to log.

    See also #LOG4CXX_DEBUG.

    */

    void debug(const std::string& msg) const;

#if LOG4CXX_WCHAR_T_API

    /**

    Add a new logging event containing \c msg and \c location to attached appender(s) if this logger is enabled for <code>DEBUG</code> events.

    <p>This method first checks if this logger is <code>DEBUG</code>

    enabled by comparing the level of this logger with the

    DEBUG level. If this logger is

    <code>DEBUG</code> enabled, it proceeds to call all the

    registered appenders in this logger and also higher in the

    hierarchy depending on the value of the additivity flag.

    @param msg the message string to log.

    @param location The source code location of the logging request.

    See also #LOG4CXX_DEBUG.

    */

    void debug(const std::wstring& msg, const LOG4CXX_NS::spi::LocationInfo& location) const;

    /**

    Add a new logging event containing \c msg to attached appender(s) if this logger is enabled for <code>DEBUG</code> events.

    <p>This method first checks if this logger is <code>DEBUG</code>

    enabled by comparing the level of this logger with the

    DEBUG level. If this logger is

    <code>DEBUG</code> enabled, it proceeds to call all the

    registered appenders in this logger and also higher in the

    hierarchy depending on the value of the additivity flag.

    @param msg the message string to log.

    See also #LOG4CXX_DEBUG.

    */

    void debug(const std::wstring& msg) const;

#endif

#if LOG4CXX_UNICHAR_API

    /**

    Add a new logging event containing \c msg and \c location to attached appender(s) if this logger is enabled for <code>DEBUG</code> events.

    <p>This method first checks if this logger is <code>DEBUG</code>

    enabled by comparing the level of this logger with the

    DEBUG level. If this logger is

    <code>DEBUG</code> enabled, it proceeds to call all the

    registered appenders in this logger and also higher in the

    hierarchy depending on the value of the additivity flag.

    @param msg the message string to log.

    @param location The source code location of the logging request.

    See also #LOG4CXX_DEBUG.

    */

    void debug(const std::basic_string<UniChar>& msg, const LOG4CXX_NS::spi::LocationInfo& location) const;

    /**

    Add a new logging event containing \c msg to attached appender(s) if this logger is enabled for <code>DEBUG</code> events.

    <p>This method first checks if this logger is <code>DEBUG</code>

    enabled by comparing the level of this logger with the

    DEBUG level. If this logger is

    <code>DEBUG</code> enabled, it proceeds to call all the

    registered appenders in this logger and also higher in the

    hierarchy depending on the value of the additivity flag.

    @param msg the message string to log.

    See also #LOG4CXX_DEBUG.

    */

    void debug(const std::basic_string<UniChar>& msg) const;

#endif

#if LOG4CXX_CFSTRING_API

    /**

    Add a new logging event containing \c msg and \c location to attached appender(s) if this logger is enabled for <code>DEBUG</code> events.

    <p>This method first checks if this logger is <code>DEBUG</code>

    enabled by comparing the level of this logger with the

    DEBUG level. If this logger is

    <code>DEBUG</code> enabled, it proceeds to call all the

    registered appenders in this logger and also higher in the

    hierarchy depending on the value of the additivity flag.

    @param msg the message string to log.

    @param location The source code location of the logging request.

    See also #LOG4CXX_DEBUG.

    */

    void debug(const CFStringRef& msg, const LOG4CXX_NS::spi::LocationInfo& location) const;

    /**

    Add a new logging event containing \c msg to attached appender(s) if this logger is enabled for <code>DEBUG</code> events.

    <p>This method first checks if this logger is <code>DEBUG</code>

    enabled by comparing the level of this logger with the

    DEBUG level. If this logger is

    <code>DEBUG</code> enabled, it proceeds to call all the

    registered appenders in this logger and also higher in the

    hierarchy depending on the value of the additivity flag.

    @param msg the message string to log.

    See also #LOG4CXX_DEBUG.

    */

    void debug(const CFStringRef& msg) const;

#endif

    /**

    Add a new logging event containing \c msg and \c location to attached appender(s) if this logger is enabled for <code>ERROR</code> events.

    <p>This method first checks if this logger is <code>ERROR</code>

    enabled by comparing the level of this logger with the

    ERROR level. If this logger is

    <code>ERROR</code> enabled, it proceeds to call all the

    registered appenders in this logger and also higher in the

    hierarchy depending on the value of the additivity flag.

    @param msg the message string to log.

    @param location The source code location of the logging request.

    See also #LOG4CXX_ERROR.

    */

    void error(const std::string& msg, const LOG4CXX_NS::spi::LocationInfo& location) const;

    /**

    Add a new logging event containing \c msg to attached appender(s) if this logger is enabled for <code>ERROR</code> events.

    <p>This method first checks if this logger is <code>ERROR</code>

    enabled by comparing the level of this logger with the

    ERROR level. If this logger is

    <code>ERROR</code> enabled, it proceeds to call all the

    registered appenders in this logger and also higher in the

    hierarchy depending on the value of the additivity flag.

    @param msg the message string to log.

    See also #LOG4CXX_ERROR.

    */

    void error(const std::string& msg) const;

#if LOG4CXX_WCHAR_T_API

    /**

    Add a new logging event containing \c msg to attached appender(s) if this logger is enabled for <code>ERROR</code> events.

    <p>This method first checks if this logger is <code>ERROR</code>

    enabled by comparing the level of this logger with the

    ERROR level. If this logger is

    <code>ERROR</code> enabled, it proceeds to call all the

    registered appenders in this logger and also higher in the

    hierarchy depending on the value of the additivity flag.

    @param msg the message string to log.

    See also #LOG4CXX_ERROR.

    */

    void error(const std::wstring& msg) const;

    /**

    Add a new logging event containing \c msg and \c location to attached appender(s) if this logger is enabled for <code>ERROR</code> events.

    <p>This method first checks if this logger is <code>ERROR</code>

    enabled by comparing the level of this logger with the

    ERROR level. If this logger is

    <code>ERROR</code> enabled, it proceeds to call all the

    registered appenders in this logger and also higher in the

    hierarchy depending on the value of the additivity flag.

    @param msg the message string to log.

    @param location The source code location of the logging request.

    See also #LOG4CXX_ERROR.

    */

    void error(const std::wstring& msg, const LOG4CXX_NS::spi::LocationInfo& location) const;

#endif

#if LOG4CXX_UNICHAR_API

    /**

    Add a new logging event containing \c msg and \c location to attached appender(s) if this logger is enabled for <code>ERROR</code> events.

    <p>This method first checks if this logger is <code>ERROR</code>

    enabled by comparing the level of this logger with the

    ERROR level. If this logger is

    <code>ERROR</code> enabled, it proceeds to call all the

    registered appenders in this logger and also higher in the

    hierarchy depending on the value of the additivity flag.

    @param msg the message string to log.

    @param location The source code location of the logging request.

    See also #LOG4CXX_ERROR.

    */

    void error(const std::basic_string<UniChar>& msg, const LOG4CXX_NS::spi::LocationInfo& location) const;

    /**

    Add a new logging event containing \c msg to attached appender(s) if this logger is enabled for <code>ERROR</code> events.

    <p>This method first checks if this logger is <code>ERROR</code>

    enabled by comparing the level of this logger with the

    ERROR level. If this logger is

    <code>ERROR</code> enabled, it proceeds to call all the

    registered appenders in this logger and also higher in the

    hierarchy depending on the value of the additivity flag.

    @param msg the message string to log.

    See also #LOG4CXX_ERROR.

    */

    void error(const std::basic_string<UniChar>& msg) const;

#endif

#if LOG4CXX_CFSTRING_API

    /**

    Add a new logging event containing \c msg and \c location to attached appender(s) if this logger is enabled for <code>ERROR</code> events.

    <p>This method first checks if this logger is <code>ERROR</code>

    enabled by comparing the level of this logger with the

    ERROR level. If this logger is

    <code>ERROR</code> enabled, it proceeds to call all the

    registered appenders in this logger and also higher in the

    hierarchy depending on the value of the additivity flag.

    @param msg the message string to log.

    @param location The source code location of the logging request.

    See also #LOG4CXX_ERROR.

    */

    void error(const CFStringRef& msg, const LOG4CXX_NS::spi::LocationInfo& location) const;

    /**

    Add a new logging event containing \c msg to attached appender(s) if this logger is enabled for <code>ERROR</code> events.

    <p>This method first checks if this logger is <code>ERROR</code>

    enabled by comparing the level of this logger with the

    ERROR level. If this logger is

    <code>ERROR</code> enabled, it proceeds to call all the

    registered appenders in this logger and also higher in the

    hierarchy depending on the value of the additivity flag.

    @param msg the message string to log.

    See also #LOG4CXX_ERROR.

    */

    void error(const CFStringRef& msg) const;

#endif

    /**

    Add a new logging event containing \c msg and \c location to attached appender(s) if this logger is enabled for <code>FATAL</code> events.

    <p>This method first checks if this logger is <code>FATAL</code>

    enabled by comparing the level of this logger with the

    FATAL level. If this logger is

    <code>FATAL</code> enabled, it proceeds to call all the

    registered appenders in this logger and also higher in the

    hierarchy depending on the value of the additivity flag.

    @param msg the message string to log.

    @param location The source code location of the logging request.

    See also #LOG4CXX_FATAL.

    */

    void fatal(const std::string& msg, const LOG4CXX_NS::spi::LocationInfo& location) const;

    /**

    Add a new logging event containing \c msg to attached appender(s) if this logger is enabled for <code>FATAL</code> events.

    <p>This method first checks if this logger is <code>ERROR</code>

    enabled by comparing the level of this logger with the

    ERROR level. If this logger is

    <code>ERROR</code> enabled, it proceeds to call all the

    registered appenders in this logger and also higher in the

    hierarchy depending on the value of the additivity flag.

    @param msg the message string to log.

    See also #LOG4CXX_FATAL.

    */

    void fatal(const std::string& msg) const;

#if LOG4CXX_WCHAR_T_API

    /**

    Add a new logging event containing \c msg and \c location to attached appender(s) if this logger is enabled for <code>FATAL</code> events.

    <p>This method first checks if this logger is <code>ERROR</code>

    enabled by comparing the level of this logger with the

    ERROR level. If this logger is

    <code>ERROR</code> enabled, it proceeds to call all the

    registered appenders in this logger and also higher in the

    hierarchy depending on the value of the additivity flag.

    @param msg the message string to log.

    @param location The source code location of the logging request.

    See also #LOG4CXX_FATAL.

    */

    void fatal(const std::wstring& msg, const LOG4CXX_NS::spi::LocationInfo& location) const;

    /**

    Add a new logging event containing \c msg to attached appender(s) if this logger is enabled for <code>FATAL</code> events.

    <p>This method first checks if this logger is <code>ERROR</code>

    enabled by comparing the level of this logger with the

    ERROR level. If this logger is

    <code>ERROR</code> enabled, it proceeds to call all the

    registered appenders in this logger and also higher in the

    hierarchy depending on the value of the additivity flag.

    @param msg the message string to log.

    See also #LOG4CXX_FATAL.

    */

    void fatal(const std::wstring& msg) const;

#endif

#if LOG4CXX_UNICHAR_API

    /**

    Add a new logging event containing \c msg and \c location to attached appender(s) if this logger is enabled for <code>FATAL</code> events.

    <p>This method first checks if this logger is <code>ERROR</code>

    enabled by comparing the level of this logger with the

    ERROR level. If this logger is

    <code>ERROR</code> enabled, it proceeds to call all the

    registered appenders in this logger and also higher in the

    hierarchy depending on the value of the additivity flag.

    @param msg the message string to log.

    @param location The source code location of the logging request.

    See also #LOG4CXX_FATAL.

    */

    void fatal(const std::basic_string<UniChar>& msg, const LOG4CXX_NS::spi::LocationInfo& location) const;

    /**

    Add a new logging event containing \c msg to attached appender(s) if this logger is enabled for <code>FATAL</code> events.

    <p>This method first checks if this logger is <code>ERROR</code>

    enabled by comparing the level of this logger with the

    ERROR level. If this logger is

    <code>ERROR</code> enabled, it proceeds to call all the

    registered appenders in this logger and also higher in the

    hierarchy depending on the value of the additivity flag.

    @param msg the message string to log.

    See also #LOG4CXX_FATAL.

    */

    void fatal(const std::basic_string<UniChar>& msg) const;

#endif

#if LOG4CXX_CFSTRING_API

    /**

    Add a new logging event containing \c msg and \c location to attached appender(s) if this logger is enabled for <code>FATAL</code> events.

    <p>This method first checks if this logger is <code>ERROR</code>

    enabled by comparing the level of this logger with the

    ERROR level. If this logger is

    <code>ERROR</code> enabled, it proceeds to call all the

    registered appenders in this logger and also higher in the

    hierarchy depending on the value of the additivity flag.

    @param msg the message string to log.

    @param location The source code location of the logging request.

    See also #LOG4CXX_FATAL.

    */

    void fatal(const CFStringRef& msg, const LOG4CXX_NS::spi::LocationInfo& location) const;

    /**

    Add a new logging event containing \c msg to attached appender(s) if this logger is enabled for <code>FATAL</code> events.

    <p>This method first checks if this logger is <code>ERROR</code>

    enabled by comparing the level of this logger with the

    ERROR level. If this logger is

    <code>ERROR</code> enabled, it proceeds to call all the

    registered appenders in this logger and also higher in the

    hierarchy depending on the value of the additivity flag.

    @param msg the message string to log.

    See also #LOG4CXX_FATAL.

    */

    void fatal(const CFStringRef& msg) const;

#endif

    /**

    Add a new logging event containing \c message and \c location to attached appender(s)

    without further checks.

    @param level The logging event level.

    @param message The text to add to the logging event.

    @param location The source code location of the logging request.

    */

    void addEvent(const LevelPtr& level, std::string&& message

      , const spi::LocationInfo& location = spi::LocationInfo::getLocationUnavailable()) const;

    /**

    Add to attached appender(s) a new \c level LoggingEvent which was requested at \c sourceLocation where the message is built asynchronously by \c messageAppender

    without further checks.

    @param level The logging event level.

    @param message The text to add to the logging event.

    @param location The source code location of the logging request.

    */

    void addEvent(const LevelPtr& level, helpers::AsyncBuffer&& messageAppender

      , const spi::LocationInfo& sourceLocation = spi::LocationInfo::getLocationUnavailable()) const;

    /**

    Add a new fatal level logging event containing \c message and \c location to attached appender(s)

    without further checks.

    @param message The text to add to the logging event.

    @param location The source code location of the logging request.

    */

    void addFatalEvent(std::string&& message, const spi::LocationInfo& location = spi::LocationInfo::getLocationUnavailable()) const;

    /**

    Add to attached appender(s) a new FATAL level LoggingEvent which was requested at \c sourceLocation where the message is built asynchronously by \c messageAppender

    without further checks.

    @param message The text to add to the logging event.

    @param location The source code location of the logging request.

    */

    void addFatalEvent(helpers::AsyncBuffer&& messageAppender, const spi::LocationInfo& location = spi::LocationInfo::getLocationUnavailable()) const;

    /**

    Add a new error level logging event containing \c message and \c location to attached appender(s)

    without further checks.

    @param message The text to add to the logging event.

    @param location The source code location of the logging request.

    */

    void addErrorEvent(std::string&& message, const spi::LocationInfo& location = spi::LocationInfo::getLocationUnavailable()) const;

    /**

    Add to attached appender(s) a new ERROR level LoggingEvent which was requested at \c sourceLocation where the message is built asynchronously by \c messageAppender

    without further checks.

    @param message The text to add to the logging event.

    @param location The source code location of the logging request.

    */

    void addErrorEvent(helpers::AsyncBuffer&& messageAppender, const spi::LocationInfo& location = spi::LocationInfo::getLocationUnavailable()) const;

    /**

    Add a new warning level logging event containing \c message and \c location to attached appender(s)

    without further checks.

    @param message The text to add to the logging event.

    @param location The source code location of the logging request.

    */

    void addWarnEvent(std::string&& message, const spi::LocationInfo& location = spi::LocationInfo::getLocationUnavailable()) const;

    /**

    Add to attached appender(s) a new WARN level LoggingEvent which was requested at \c sourceLocation where the message is built asynchronously by \c messageAppender

    without further checks.

    @param message The text to add to the logging event.

    @param location The source code location of the logging request.

    */

    void addWarnEvent(helpers::AsyncBuffer&& messageAppender, const spi::LocationInfo& location = spi::LocationInfo::getLocationUnavailable()) const;

    /**

    Add a new info level logging event containing \c message and \c location to attached appender(s)

    without further checks.

    @param message The text to add to the logging event.

    @param location The source code location of the logging request.

    */

    void addInfoEvent(std::string&& message, const spi::LocationInfo& location = spi::LocationInfo::getLocationUnavailable()) const;

    /**

    Add to attached appender(s) a new INFO level LoggingEvent which was requested at \c sourceLocation where the message is built asynchronously by \c messageAppender

    without further checks.

    @param message The text to add to the logging event.

    @param location The source code location of the logging request.

    */

    void addInfoEvent(helpers::AsyncBuffer&& messageAppender, const spi::LocationInfo& location = spi::LocationInfo::getLocationUnavailable()) const;

    /**

    Add a new debug level logging event containing \c message and \c location to attached appender(s)

    without further checks.

    @param message The text to add to the logging event.

    @param location The source code location of the logging request.

    */

    void addDebugEvent(std::string&& message, const spi::LocationInfo& location = spi::LocationInfo::getLocationUnavailable()) const;

    /**

    Add to attached appender(s) a new DEBUG level LoggingEvent which was requested at \c sourceLocation where the message is built asynchronously by \c messageAppender

    without further checks.

    @param message The text to add to the logging event.

    @param location The source code location of the logging request.

    */

    void addDebugEvent(helpers::AsyncBuffer&& messageAppender, const spi::LocationInfo& location = spi::LocationInfo::getLocationUnavailable()) const;

    /**

    Add a new trace level logging event containing \c message and \c location to attached appender(s)

    without further checks.

    @param message The text to add to the logging event.

    @param location The source code location of the logging request.

    */

    void addTraceEvent(std::string&& message, const spi::LocationInfo& location = spi::LocationInfo::getLocationUnavailable()) const;

    /**

    Add to attached appender(s) a new TRACE level LoggingEvent which was requested at \c sourceLocation where the message is built asynchronously by \c messageAppender

    without further checks.

    @param message The text to add to the logging event.

    @param location The source code location of the logging request.

    */

    void addTraceEvent(helpers::AsyncBuffer&& messageAppender, const spi::LocationInfo& location = spi::LocationInfo::getLocationUnavailable()) const;

    /**

    Add a new logging event containing \c message and \c location to attached appender(s)

    without further checks.

    @param level The logging event level.

    @param message The text to add to the logging event.

    @param location The source code location of the logging request.

    */

    void forcedLog(const LevelPtr& level, const std::string& message,

      const LOG4CXX_NS::spi::LocationInfo& location) const;

    /**

    Add a new logging event containing \c message to attached appender(s)

    without further checks.

    @param level The logging event level.

    @param message The text to add to the logging event.

    */

    void forcedLog(const LevelPtr& level, const std::string& message) const;

#if LOG4CXX_WCHAR_T_API

    /**

    Add a new logging event containing \c message and \c location to attached appender(s)

    without further checks.

    @param level The logging event level.

    @param message The text to add to the logging event.

    @param location The source code location of the logging request.

    */

    void addEvent(const LevelPtr& level, std::wstring&& message

      , const spi::LocationInfo& location = spi::LocationInfo::getLocationUnavailable()) const;

    /**

    Add a new fatal level logging event containing \c message and \c location to attached appender(s)

    without further checks.

    @param message The text to add to the logging event.

    @param location The source code location of the logging request.

    */

    void addFatalEvent(std::wstring&& message, const spi::LocationInfo& location = spi::LocationInfo::getLocationUnavailable()) const;

    /**

    Add a new error level logging event containing \c message and \c location to attached appender(s)

    without further checks.

    @param message The text to add to the logging event.

    @param location The source code location of the logging request.

    */

    void addErrorEvent(std::wstring&& message, const spi::LocationInfo& location = spi::LocationInfo::getLocationUnavailable()) const;

    /**

    Add a new warning level logging event containing \c message and \c location to attached appender(s)

    without further checks.

    @param message The text to add to the logging event.

    @param location The source code location of the logging request.

    */

    void addWarnEvent(std::wstring&& message, const spi::LocationInfo& location = spi::LocationInfo::getLocationUnavailable()) const;

    /**

    Add a new info level logging event containing \c message and \c location to attached appender(s)

    without further checks.

    @param message The text to add to the logging event.

    @param location The source code location of the logging request.

    */

    void addInfoEvent(std::wstring&& message, const spi::LocationInfo& location = spi::LocationInfo::getLocationUnavailable()) const;

    /**

    Add a new debug level logging event containing \c message and \c location to attached appender(s)

    without further checks.

    @param message The text to add to the logging event.

    @param location The source code location of the logging request.

    */

    void addDebugEvent(std::wstring&& message, const spi::LocationInfo& location = spi::LocationInfo::getLocationUnavailable()) const;

    /**

    Add a new trace level logging event containing \c message and \c location to attached appender(s)

    without further checks.

    @param message The text to add to the logging event.

    @param location The source code location of the logging request.

    */

    void addTraceEvent(std::wstring&& message, const spi::LocationInfo& location = spi::LocationInfo::getLocationUnavailable()) const;

    /**

    Add a new logging event containing \c message and \c location to attached appender(s)

    without further checks.

    @param level The logging event level.

    @param message The text to add to the logging event.

    @param location The source code location of the logging request.

    */

    void forcedLog(const LevelPtr& level, const std::wstring& message,

      const LOG4CXX_NS::spi::LocationInfo& location) const;

    /**

    Add a new logging event containing \c message to attached appender(s)

    without further checks.

    @param level The logging event level.

    @param message The text to add to the logging event.

    */

    void forcedLog(const LevelPtr& level, const std::wstring& message) const;

#endif

#if LOG4CXX_UNICHAR_API

    /**

    Add a new logging event containing \c message and \c location to attached appender(s)

    without further checks.

    @param level The logging event level.

    @param message The text to add to the logging event.

    @param location The source code location of the logging request.

    */

    void addEvent(const LevelPtr& level, std::basic_string<UniChar>&& message,

      const spi::LocationInfo& location = spi::LocationInfo::getLocationUnavailable()) const;

    /**

    Add a new fatal level logging event containing \c message and \c location to attached appender(s)

    without further checks.

    @param message The text to add to the logging event.

    @param location The source code location of the logging request.

    */

    void addFatalEvent(std::basic_string<UniChar>&& message,const spi::LocationInfo& location = spi::LocationInfo::getLocationUnavailable()) const;

    /**

    Add a new error level logging event containing \c message and \c location to attached appender(s)

    without further checks.

    @param message The text to add to the logging event.

    @param location The source code location of the logging request.

    */

    void addErrorEvent(std::basic_string<UniChar>&& message,const spi::LocationInfo& location = spi::LocationInfo::getLocationUnavailable()) const;

    /**

    Add a new warning level logging event containing \c message and \c location to attached appender(s)

    without further checks.

    @param message The text to add to the logging event.

    @param location The source code location of the logging request.

    */

    void addWarnEvent(std::basic_string<UniChar>&& message,const spi::LocationInfo& location = spi::LocationInfo::getLocationUnavailable()) const;

    /**

    Add a new info level logging event containing \c message and \c location to attached appender(s)

    without further checks.

    @param message The text to add to the logging event.

    @param location The source code location of the logging request.

    */

    void addInfoEvent(std::basic_string<UniChar>&& message,const spi::LocationInfo& location = spi::LocationInfo::getLocationUnavailable()) const;

    /**

    Add a new debug level logging event containing \c message and \c location to attached appender(s)

    without further checks.

    @param message The text to add to the logging event.

    @param location The source code location of the logging request.

    */

    void addDebugEvent(std::basic_string<UniChar>&& message,const spi::LocationInfo& location = spi::LocationInfo::getLocationUnavailable()) const;

    /**

    Add a new trace level logging event containing \c message and \c location to attached appender(s)

    without further checks.

    @param message The text to add to the logging event.

    @param location The source code location of the logging request.

    */

    void addTraceEvent(std::basic_string<UniChar>&& message,const spi::LocationInfo& location = spi::LocationInfo::getLocationUnavailable()) const;

    /**

    Add a new logging event containing \c message and \c location to attached appender(s)

    without further checks.

    @param level The logging event level.

    @param message The text to add to the logging event.

    @param location The source code location of the logging request.

    */

    void forcedLog(const LevelPtr& level, const std::basic_string<UniChar>& message,

      const LOG4CXX_NS::spi::LocationInfo& location) const;

    /**

    Add a new logging event containing \c message to attached appender(s)

    without further checks.

    @param level The logging event level.

    @param message The text to add to the logging event.

    */

    void forcedLog(const LevelPtr& level, const std::basic_string<UniChar>& message) const;

#endif

#if LOG4CXX_CFSTRING_API

    /**

    Add a new logging event containing \c message and \c location to attached appender(s)

    without further checks.

    @param level The logging event level.

    @param message The text to add to the logging event.

    @param location The source code location of the logging request.

    */

    void forcedLog(const LevelPtr& level, const CFStringRef& message,

      const LOG4CXX_NS::spi::LocationInfo& location) const;

    /**

    Add a new logging event containing \c message to attached appender(s)

    without further checks.

    @param level The logging event level.

    @param message The text to add to the logging event.

    */

    void forcedLog(const LevelPtr& level, const CFStringRef& message) const;

#endif

    /**

    Add a new logging event containing \c message and \c location to attached appender(s)

    without further checks.

    @param level The logging event level.

    @param message the message string to log.

    @param location location of the logging statement.

    */

    void addEventLS(const LevelPtr& level, LogString&& message

      , const spi::LocationInfo& location = spi::LocationInfo::getLocationUnavailable()) const;

    /**

    Add a new logging event containing \c message and \c location to attached appender(s)

    without further checks.

    @param level The logging event level.

    @param message the message string to log.

    @param location location of the logging statement.

    */

    void forcedLogLS(const LevelPtr& level, const LogString& message,

      const LOG4CXX_NS::spi::LocationInfo& location) const;

    /**

    Get the additivity flag for this logger.

    */

    bool getAdditivity() const;

    /**

    Get the appenders contained in this logger as an AppenderList.

    If no appenders can be found, then an empty AppenderList

    is returned.

    @return AppenderList An collection of the appenders in this logger.*/

    AppenderList getAllAppenders() const override;

    /**

    Look for the appender named as <code>name</code>.

    <p>Return the appender with that name if in the list. Return

    <code>NULL</code> otherwise.  */

    AppenderPtr getAppender(const LogString& name) const override;

    /**

    Starting from this logger, search the logger hierarchy for a

    non-null level and return it.

    <p>The Logger class is designed so that this method executes as

    quickly as possible.

    @throws RuntimeException if all levels are null in the hierarchy

    */

    virtual const LevelPtr& getEffectiveLevel() const;

    /**

    Return the the LoggerRepository where this

    <code>Logger</code> is attached.

    */

    spi::LoggerRepository* getLoggerRepository() const;

    /**

    * Get the logger name.

    * @return logger name as LogString.

    */

    const LogString& getName() const;

    /**

    * Put name of this logger into \c name in current encoding.

    * @param name buffer to which name is appended.

    */

    void getName(std::string& name) const;

#if LOG4CXX_WCHAR_T_API

    /**

    * Put name of this logger into \c name.

    * @param name buffer to which name is appended.

    */

    void getName(std::wstring& name) const;

#endif

#if LOG4CXX_UNICHAR_API

    /**

    * Put name of this logger into \c name.

    * @param name buffer to which name is appended.

    */

    void getName(std::basic_string<UniChar>& name) const;

#endif

#if LOG4CXX_CFSTRING_API

    /**

    * Put name of this logger into \c name.

    * @param name buffer to which name is appended.

    */

    void getName(CFStringRef& name) const;

#endif

    /**

    The parent of this logger. Note that the parent of a

    given logger may change during the lifetime of the logger.

    <p>The root logger will return <code>0</code>.

    */

    LoggerPtr getParent() const;

    /**

    The assigned Level, if any, for this logger.

    @return Level - the assigned Level, can be null.

    */

    const LevelPtr& getLevel() const;

    /**

    * Retrieve a logger by name in current encoding.

    * @param name logger name.

    */

    static LoggerPtr getLogger(const std::string& name);

    /**

    * Retrieve a logger by name in current encoding.

    * @param name logger name.

    */

    static LoggerPtr getLogger(const char* const name);

#if LOG4CXX_WCHAR_T_API

    /**

    * Retrieve a logger by name.

    * @param name logger name.

    */

    static LoggerPtr getLogger(const std::wstring& name);

    /**

    * Retrieve a logger by name.

    * @param name logger name.

    */

    static LoggerPtr getLogger(const wchar_t* const name);

#endif

#if LOG4CXX_UNICHAR_API

    /**

    * Retrieve a logger by name.

    * @param name logger name.

    */

    static LoggerPtr getLogger(const std::basic_string<UniChar>& name);

#endif

#if LOG4CXX_CFSTRING_API

    /**

    * Retrieve a logger by name.

    * @param name logger name.

    */

    static LoggerPtr getLogger(const CFStringRef& name);

#endif

    /**

    * Retrieve a logger by name in Unicode.

    * @param name logger name.

    */

    static LoggerPtr getLoggerLS(const LogString& name);

    /**

    Retrieve the root logger.

    */

    static LoggerPtr getRootLogger();

    /**

    Like #getLogger except that the type of logger

    instantiated depends on the type returned by the

    LoggerFactory#makeNewLoggerInstance method of the

    <code>factory</code> parameter.

    <p>This method is intended to be used by sub-classes.

    @param name The name of the logger to retrieve.

    @param factory A LoggerFactory implementation that will

    actually create a new Instance.

    */

    static LoggerPtr getLoggerLS(const LogString& name,

      const LOG4CXX_NS::spi::LoggerFactoryPtr& factory);

    /**

    Like #getLogger except that the type of logger

    instantiated depends on the type returned by the

    LoggerFactory#makeNewLoggerInstance method of the

    <code>factory</code> parameter.

    <p>This method is intended to be used by sub-classes.

    @param name The name of the logger to retrieve.

    @param factory A LoggerFactory implementation that will

    actually create a new Instance.

    */

    static LoggerPtr getLogger(const std::string& name,

      const LOG4CXX_NS::spi::LoggerFactoryPtr& factory);

#if LOG4CXX_WCHAR_T_API

    /**

    Like #getLogger except that the type of logger

    instantiated depends on the type returned by the

    LoggerFactory#makeNewLoggerInstance method of the

    <code>factory</code> parameter.

    <p>This method is intended to be used by sub-classes.

    @param name The name of the logger to retrieve.

    @param factory A LoggerFactory implementation that will

    actually create a new Instance.

    */

    static LoggerPtr getLogger(const std::wstring& name,

      const LOG4CXX_NS::spi::LoggerFactoryPtr& factory);

#endif

#if LOG4CXX_UNICHAR_API

    /**

    Like #getLogger except that the type of logger

    instantiated depends on the type returned by the

    LoggerFactory#makeNewLoggerInstance method of the

    <code>factory</code> parameter.

    <p>This method is intended to be used by sub-classes.

    @param name The name of the logger to retrieve.

    @param factory A LoggerFactory implementation that will

    actually create a new Instance.

    */

    static LoggerPtr getLogger(const std::basic_string<UniChar>& name,

      const LOG4CXX_NS::spi::LoggerFactoryPtr& factory);

#endif

#if LOG4CXX_CFSTRING_API

    /**

    Like #getLogger except that the type of logger

    instantiated depends on the type returned by the

    LoggerFactory#makeNewLoggerInstance method of the

    <code>factory</code> parameter.

    <p>This method is intended to be used by sub-classes.

    @param name The name of the logger to retrieve.

    @param factory A LoggerFactory implementation that will

    actually create a new Instance.

    */

    static LoggerPtr getLogger(const CFStringRef& name,

      const LOG4CXX_NS::spi::LoggerFactoryPtr& factory);

#endif

    /**

    Return the <em>inherited</em> ResourceBundle for this logger.

    This method walks the hierarchy to find the appropriate resource bundle.

    It will return the resource bundle attached to the closest ancestor of

    this logger, much like the way priorities are searched. In case there

    is no bundle in the hierarchy then <code>NULL</code> is returned.

    */

    helpers::ResourceBundlePtr getResourceBundle() const;

  protected:

    /**

    Returns the string resource corresponding to <code>key</code> in this

    logger's inherited resource bundle.

    If the resource cannot be found, then an {@link #error error} message

    will be logged complaining about the missing resource.

    @see #getResourceBundle.

    */

    LogString getResourceBundleString(const LogString& key) const;

  public:

    /**

    Add a new logging event containing \c msg to attached appender(s) if this logger is enabled for <code>INFO</code> events.

    <p>This method first checks if this logger is <code>INFO</code>

    enabled by comparing the level of this logger with the

    INFO level. If this logger is

    <code>INFO</code> enabled, it proceeds to call all the

    registered appenders in this logger and also higher in the

    hierarchy depending on the value of the additivity flag.

    @param msg the message string to log.

    @param location The source code location of the logging request.

    See also #LOG4CXX_INFO.

    */

    void info(const std::string& msg, const LOG4CXX_NS::spi::LocationInfo& location) const;

    /**

    Add a new logging event containing \c msg to attached appender(s) if this logger is enabled for <code>INFO</code> events.

    <p>This method first checks if this logger is <code>INFO</code>

    enabled by comparing the level of this logger with the

    INFO level. If this logger is

    <code>INFO</code> enabled, it proceeds to call all the

    registered appenders in this logger and also higher in the

    hierarchy depending on the value of the additivity flag.

    @param msg the message string to log.

    See also #LOG4CXX_INFO.

    */

    void info(const std::string& msg) const;

#if LOG4CXX_WCHAR_T_API

    /**

    Add a new logging event containing \c msg to attached appender(s) if this logger is enabled for <code>INFO</code> events.

    <p>This method first checks if this logger is <code>INFO</code>

    enabled by comparing the level of this logger with the

    INFO level. If this logger is

    <code>INFO</code> enabled, it proceeds to call all the

    registered appenders in this logger and also higher in the

    hierarchy depending on the value of the additivity flag.

    @param msg the message string to log.

    @param location The source code location of the logging request.

    See also #LOG4CXX_INFO.

    */

    void info(const std::wstring& msg, const LOG4CXX_NS::spi::LocationInfo& location) const;

    /**

    Add a new logging event containing \c msg to attached appender(s) if this logger is enabled for <code>INFO</code> events.

    <p>This method first checks if this logger is <code>INFO</code>

    enabled by comparing the level of this logger with the

    INFO level. If this logger is

    <code>INFO</code> enabled, it proceeds to call all the

    registered appenders in this logger and also higher in the

    hierarchy depending on the value of the additivity flag.

    @param msg the message string to log.

    See also #LOG4CXX_INFO.

    */

    void info(const std::wstring& msg) const;

#endif

#if LOG4CXX_UNICHAR_API

    /**

    Add a new logging event containing \c msg to attached appender(s) if this logger is enabled for <code>INFO</code> events.

    <p>This method first checks if this logger is <code>INFO</code>

    enabled by comparing the level of this logger with the

    INFO level. If this logger is

    <code>INFO</code> enabled, it proceeds to call all the

    registered appenders in this logger and also higher in the

    hierarchy depending on the value of the additivity flag.

    @param msg the message string to log.

    @param location The source code location of the logging request.

            */

    void info(const std::basic_string<UniChar>& msg, const LOG4CXX_NS::spi::LocationInfo& location) const;

    /**

    Add a new logging event containing \c msg to attached appender(s) if this logger is enabled for <code>INFO</code> events.

    <p>This method first checks if this logger is <code>INFO</code>

    enabled by comparing the level of this logger with the

    INFO level. If this logger is