log4cxx/logger.h

Go to the documentation of this file.

/*
 * 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;
LOG4CXX_PTR_DEF(Logger);
LOG4CXX_LIST_DEF(LoggerList, LoggerPtr);
 
 
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; 
 
    public:
        Logger(const LogString& name);
#if LOG4CXX_ABI_VERSION <= 15
        [[ deprecated( "Pool is no longer required" ) ]]
        Logger(helpers::Pool& pool, const LogString& name);
#endif
        ~Logger();
 
 
        void addAppender(const AppenderPtr newAppender) override;
 
 
#if LOG4CXX_ABI_VERSION <= 15
        [[ deprecated( "Pool is no longer required" ) ]]
        void callAppenders(const spi::LoggingEventPtr& event, helpers::Pool& p) const;
#endif
        void callAppenders(const spi::LoggingEventPtr& event) const;
 
        void closeNestedAppenders();
 
        void debug(const std::string& msg, const LOG4CXX_NS::spi::LocationInfo& location) const;
        void debug(const std::string& msg) const;
#if LOG4CXX_WCHAR_T_API
        void debug(const std::wstring& msg, const LOG4CXX_NS::spi::LocationInfo& location) const;
        void debug(const std::wstring& msg) const;
#endif
#if LOG4CXX_UNICHAR_API
        void debug(const std::basic_string<UniChar>& msg, const LOG4CXX_NS::spi::LocationInfo& location) const;
        void debug(const std::basic_string<UniChar>& msg) const;
#endif
#if LOG4CXX_CFSTRING_API
        void debug(const CFStringRef& msg, const LOG4CXX_NS::spi::LocationInfo& location) const;
        void debug(const CFStringRef& msg) const;
#endif
 
        void error(const std::string& msg, const LOG4CXX_NS::spi::LocationInfo& location) const;
        void error(const std::string& msg) const;
#if LOG4CXX_WCHAR_T_API
        void error(const std::wstring& msg) const;
        void error(const std::wstring& msg, const LOG4CXX_NS::spi::LocationInfo& location) const;
#endif
#if LOG4CXX_UNICHAR_API
        void error(const std::basic_string<UniChar>& msg, const LOG4CXX_NS::spi::LocationInfo& location) const;
        void error(const std::basic_string<UniChar>& msg) const;
#endif
#if LOG4CXX_CFSTRING_API
        void error(const CFStringRef& msg, const LOG4CXX_NS::spi::LocationInfo& location) const;
        void error(const CFStringRef& msg) const;
#endif
 
        void fatal(const std::string& msg, const LOG4CXX_NS::spi::LocationInfo& location) const;
        void fatal(const std::string& msg) const;
#if LOG4CXX_WCHAR_T_API
        void fatal(const std::wstring& msg, const LOG4CXX_NS::spi::LocationInfo& location) const;
        void fatal(const std::wstring& msg) const;
#endif
#if LOG4CXX_UNICHAR_API
        void fatal(const std::basic_string<UniChar>& msg, const LOG4CXX_NS::spi::LocationInfo& location) const;
        void fatal(const std::basic_string<UniChar>& msg) const;
#endif
#if LOG4CXX_CFSTRING_API
        void fatal(const CFStringRef& msg, const LOG4CXX_NS::spi::LocationInfo& location) const;
        void fatal(const CFStringRef& msg) const;
#endif
 
        void addEvent(const LevelPtr& level, std::string&& message
            , const spi::LocationInfo& location = spi::LocationInfo::getLocationUnavailable()) const;
 
        void addEvent(const LevelPtr& level, helpers::AsyncBuffer&& messageAppender
            , const spi::LocationInfo& sourceLocation = spi::LocationInfo::getLocationUnavailable()) const;
 
        void addFatalEvent(std::string&& message, const spi::LocationInfo& location = spi::LocationInfo::getLocationUnavailable()) const;
 
        void addFatalEvent(helpers::AsyncBuffer&& messageAppender, const spi::LocationInfo& location = spi::LocationInfo::getLocationUnavailable()) const;
 
        void addErrorEvent(std::string&& message, const spi::LocationInfo& location = spi::LocationInfo::getLocationUnavailable()) const;
 
        void addErrorEvent(helpers::AsyncBuffer&& messageAppender, const spi::LocationInfo& location = spi::LocationInfo::getLocationUnavailable()) const;
 
        void addWarnEvent(std::string&& message, const spi::LocationInfo& location = spi::LocationInfo::getLocationUnavailable()) const;
 
        void addWarnEvent(helpers::AsyncBuffer&& messageAppender, const spi::LocationInfo& location = spi::LocationInfo::getLocationUnavailable()) const;
 
        void addInfoEvent(std::string&& message, const spi::LocationInfo& location = spi::LocationInfo::getLocationUnavailable()) const;
 
        void addInfoEvent(helpers::AsyncBuffer&& messageAppender, const spi::LocationInfo& location = spi::LocationInfo::getLocationUnavailable()) const;
 
        void addDebugEvent(std::string&& message, const spi::LocationInfo& location = spi::LocationInfo::getLocationUnavailable()) const;
 
        void addDebugEvent(helpers::AsyncBuffer&& messageAppender, const spi::LocationInfo& location = spi::LocationInfo::getLocationUnavailable()) const;
 
        void addTraceEvent(std::string&& message, const spi::LocationInfo& location = spi::LocationInfo::getLocationUnavailable()) const;
 
        void addTraceEvent(helpers::AsyncBuffer&& messageAppender, const spi::LocationInfo& location = spi::LocationInfo::getLocationUnavailable()) const;
 
        void forcedLog(const LevelPtr& level, const std::string& message,
            const LOG4CXX_NS::spi::LocationInfo& location) const;
        void forcedLog(const LevelPtr& level, const std::string& message) const;
 
#if LOG4CXX_WCHAR_T_API
        void addEvent(const LevelPtr& level, std::wstring&& message
            , const spi::LocationInfo& location = spi::LocationInfo::getLocationUnavailable()) const;
 
        void addFatalEvent(std::wstring&& message, const spi::LocationInfo& location = spi::LocationInfo::getLocationUnavailable()) const;
 
        void addErrorEvent(std::wstring&& message, const spi::LocationInfo& location = spi::LocationInfo::getLocationUnavailable()) const;
 
        void addWarnEvent(std::wstring&& message, const spi::LocationInfo& location = spi::LocationInfo::getLocationUnavailable()) const;
 
        void addInfoEvent(std::wstring&& message, const spi::LocationInfo& location = spi::LocationInfo::getLocationUnavailable()) const;
 
        void addDebugEvent(std::wstring&& message, const spi::LocationInfo& location = spi::LocationInfo::getLocationUnavailable()) const;
 
        void addTraceEvent(std::wstring&& message, const spi::LocationInfo& location = spi::LocationInfo::getLocationUnavailable()) const;
 
        void forcedLog(const LevelPtr& level, const std::wstring& message,
            const LOG4CXX_NS::spi::LocationInfo& location) const;
        void forcedLog(const LevelPtr& level, const std::wstring& message) const;
#endif
#if LOG4CXX_UNICHAR_API
        void addEvent(const LevelPtr& level, std::basic_string<UniChar>&& message,
            const spi::LocationInfo& location = spi::LocationInfo::getLocationUnavailable()) const;
        void addFatalEvent(std::basic_string<UniChar>&& message,const spi::LocationInfo& location = spi::LocationInfo::getLocationUnavailable()) const;
        void addErrorEvent(std::basic_string<UniChar>&& message,const spi::LocationInfo& location = spi::LocationInfo::getLocationUnavailable()) const;
        void addWarnEvent(std::basic_string<UniChar>&& message,const spi::LocationInfo& location = spi::LocationInfo::getLocationUnavailable()) const;
        void addInfoEvent(std::basic_string<UniChar>&& message,const spi::LocationInfo& location = spi::LocationInfo::getLocationUnavailable()) const;
        void addDebugEvent(std::basic_string<UniChar>&& message,const spi::LocationInfo& location = spi::LocationInfo::getLocationUnavailable()) const;
        void addTraceEvent(std::basic_string<UniChar>&& message,const spi::LocationInfo& location = spi::LocationInfo::getLocationUnavailable()) const;
 
        void forcedLog(const LevelPtr& level, const std::basic_string<UniChar>& message,
            const LOG4CXX_NS::spi::LocationInfo& location) const;
        void forcedLog(const LevelPtr& level, const std::basic_string<UniChar>& message) const;
#endif
#if LOG4CXX_CFSTRING_API
        void forcedLog(const LevelPtr& level, const CFStringRef& message,
            const LOG4CXX_NS::spi::LocationInfo& location) const;
        void forcedLog(const LevelPtr& level, const CFStringRef& message) const;
#endif
        void addEventLS(const LevelPtr& level, LogString&& message
            , const spi::LocationInfo& location = spi::LocationInfo::getLocationUnavailable()) const;
 
        void forcedLogLS(const LevelPtr& level, const LogString& message,
            const LOG4CXX_NS::spi::LocationInfo& location) const;
 
        bool getAdditivity() const;
 
        AppenderList getAllAppenders() const override;
 
        AppenderPtr getAppender(const LogString& name) const override;
 
        virtual const LevelPtr& getEffectiveLevel() const;
 
#if LOG4CXX_ABI_VERSION <= 15
        spi::LoggerRepository* getLoggerRepository() const;
#endif
 
        const LogString& getName() const;
 
        void getName(std::string& name) const;
#if LOG4CXX_WCHAR_T_API
        void getName(std::wstring& name) const;
#endif
#if LOG4CXX_UNICHAR_API
        void getName(std::basic_string<UniChar>& name) const;
#endif
#if LOG4CXX_CFSTRING_API
        void getName(CFStringRef& name) const;
#endif
 
        LoggerPtr getParent() const;
 
 
        const LevelPtr& getLevel() const;
 
#if 15 < LOG4CXX_ABI_VERSION
        static spi::LoggerRepositoryPtr getLoggerRepository();
#endif
 
        static LoggerPtr getLogger(const std::string& name);
        static LoggerPtr getLogger(const char* const name);
#if LOG4CXX_WCHAR_T_API
        static LoggerPtr getLogger(const std::wstring& name);
        static LoggerPtr getLogger(const wchar_t* const name);
#endif
#if LOG4CXX_UNICHAR_API
        static LoggerPtr getLogger(const std::basic_string<UniChar>& name);
#endif
#if LOG4CXX_CFSTRING_API
        static LoggerPtr getLogger(const CFStringRef& name);
#endif
        static LoggerPtr getLoggerLS(const LogString& name);
 
        static LoggerPtr getRootLogger();
 
        static LoggerPtr getLoggerLS(const LogString& name,
            const LOG4CXX_NS::spi::LoggerFactoryPtr& factory);
        static LoggerPtr getLogger(const std::string& name,
            const LOG4CXX_NS::spi::LoggerFactoryPtr& factory);
#if LOG4CXX_WCHAR_T_API
        static LoggerPtr getLogger(const std::wstring& name,
            const LOG4CXX_NS::spi::LoggerFactoryPtr& factory);
#endif
#if LOG4CXX_UNICHAR_API
        static LoggerPtr getLogger(const std::basic_string<UniChar>& name,
            const LOG4CXX_NS::spi::LoggerFactoryPtr& factory);
#endif
#if LOG4CXX_CFSTRING_API
        static LoggerPtr getLogger(const CFStringRef& name,
            const LOG4CXX_NS::spi::LoggerFactoryPtr& factory);
#endif
 
        helpers::ResourceBundlePtr getResourceBundle() const;
 
    protected:
        LogString getResourceBundleString(const LogString& key) const;
 
    public:
        void info(const std::string& msg, const LOG4CXX_NS::spi::LocationInfo& location) const;
        void info(const std::string& msg) const;
#if LOG4CXX_WCHAR_T_API
        void info(const std::wstring& msg, const LOG4CXX_NS::spi::LocationInfo& location) const;
        void info(const std::wstring& msg) const;
#endif
#if LOG4CXX_UNICHAR_API
        void info(const std::basic_string<UniChar>& msg, const LOG4CXX_NS::spi::LocationInfo& location) const;
        void info(const std::basic_string<UniChar>& msg) const;
#endif
#if LOG4CXX_CFSTRING_API
        void info(const CFStringRef& msg, const LOG4CXX_NS::spi::LocationInfo& location) const;
        void info(const CFStringRef& msg) const;
#endif
 
        bool isAttached(const AppenderPtr appender) const override;
 
        bool isDebugEnabled() const;
 
        inline static bool isDebugEnabledFor(const LoggerPtr& logger)
        {
            return logger && logger->m_threshold <= Level::DEBUG_INT && logger->isDebugEnabled();
        }
 
        bool isEnabledFor(const LevelPtr& level) const;
 
 
        bool isInfoEnabled() const;
 
        inline static bool isInfoEnabledFor(const LoggerPtr& logger)
        {
            return logger && logger->m_threshold <= Level::INFO_INT && logger->isInfoEnabled();
        }
 
        bool isWarnEnabled() const;
 
        inline static bool isWarnEnabledFor(const LoggerPtr& logger)
        {
            return logger && logger->m_threshold <= Level::WARN_INT && logger->isWarnEnabled();
        }
 
        bool isErrorEnabled() const;
 
        inline static bool isErrorEnabledFor(const LoggerPtr& logger)
        {
            return logger && logger->m_threshold <= Level::ERROR_INT && logger->isErrorEnabled();
        }
 
        bool isFatalEnabled() const;
 
        inline static bool isFatalEnabledFor(const LoggerPtr& logger)
        {
            return logger && logger->m_threshold <= Level::FATAL_INT && logger->isFatalEnabled();
        }
 
        bool isTraceEnabled() const;
 
        inline static bool isTraceEnabledFor(const LoggerPtr& logger)
        {
            return logger && logger->m_threshold <= Level::TRACE_INT && logger->isTraceEnabled();
        }
 
        void l7dlog(const LevelPtr& level, const LogString& key,
            const LOG4CXX_NS::spi::LocationInfo& locationInfo,
            const std::vector<LogString>& values) const;
        void l7dlog(const LevelPtr& level, const std::string& key,
            const LOG4CXX_NS::spi::LocationInfo& locationInfo) const;
        void l7dlog(const LevelPtr& level, const std::string& key,
            const LOG4CXX_NS::spi::LocationInfo& locationInfo,
            const std::string& val) const;
        void l7dlog(const LevelPtr& level, const std::string& key,
            const LOG4CXX_NS::spi::LocationInfo& locationInfo,
            const std::string& val1, const std::string& val2) const;
        void l7dlog(const LevelPtr& level, const std::string& key,
            const LOG4CXX_NS::spi::LocationInfo& locationInfo,
            const std::string& val1, const std::string& val2, const std::string& val3) const;
 
#if LOG4CXX_WCHAR_T_API
        void l7dlog(const LevelPtr& level, const std::wstring& key,
            const LOG4CXX_NS::spi::LocationInfo& locationInfo) const;
        void l7dlog(const LevelPtr& level, const std::wstring& key,
            const LOG4CXX_NS::spi::LocationInfo& locationInfo,
            const std::wstring& val) const;
        void l7dlog(const LevelPtr& level, const std::wstring& key,
            const LOG4CXX_NS::spi::LocationInfo& locationInfo,
            const std::wstring& val1, const std::wstring& val2) const;
        void l7dlog(const LevelPtr& level, const std::wstring& key,
            const LOG4CXX_NS::spi::LocationInfo& locationInfo,
            const std::wstring& val1, const std::wstring& val2, const std::wstring& val3) const;
#endif
#if LOG4CXX_UNICHAR_API
        void l7dlog(const LevelPtr& level, const std::basic_string<UniChar>& key,
            const LOG4CXX_NS::spi::LocationInfo& locationInfo) const;
        void l7dlog(const LevelPtr& level, const std::basic_string<UniChar>& key,
            const LOG4CXX_NS::spi::LocationInfo& locationInfo,
            const std::basic_string<UniChar>& val) const;
        void l7dlog(const LevelPtr& level, const std::basic_string<UniChar>& key,
            const LOG4CXX_NS::spi::LocationInfo& locationInfo,
            const std::basic_string<UniChar>& val1, const std::basic_string<UniChar>& val2) const;
        void l7dlog(const LevelPtr& level, const std::basic_string<UniChar>& key,
            const LOG4CXX_NS::spi::LocationInfo& locationInfo,
            const std::basic_string<UniChar>& val1, const std::basic_string<UniChar>& val2,
            const std::basic_string<UniChar>& val3) const;
#endif
#if LOG4CXX_CFSTRING_API
        void l7dlog(const LevelPtr& level, const CFStringRef& key,
            const LOG4CXX_NS::spi::LocationInfo& locationInfo) const;
        void l7dlog(const LevelPtr& level, const CFStringRef& key,
            const LOG4CXX_NS::spi::LocationInfo& locationInfo,
            const CFStringRef& val1) const;
        void l7dlog(const LevelPtr& level, const CFStringRef& key,
            const LOG4CXX_NS::spi::LocationInfo& locationInfo,
            const CFStringRef& val1, const CFStringRef& val2) const;
        void l7dlog(const LevelPtr& level, const CFStringRef& key,
            const LOG4CXX_NS::spi::LocationInfo& locationInfo,
            const CFStringRef& val1, const CFStringRef& val2,
            const CFStringRef& val3) const;
#endif
 
        void log(const LevelPtr& level, const std::string& message,
            const LOG4CXX_NS::spi::LocationInfo& location) const;
        void log(const LevelPtr& level, const std::string& message) const;
#if LOG4CXX_WCHAR_T_API
        void log(const LevelPtr& level, const std::wstring& message,
            const LOG4CXX_NS::spi::LocationInfo& location) const;
        void log(const LevelPtr& level, const std::wstring& message) const;
#endif
#if LOG4CXX_UNICHAR_API
        void log(const LevelPtr& level, const std::basic_string<UniChar>& message,
            const LOG4CXX_NS::spi::LocationInfo& location) const;
        void log(const LevelPtr& level, const std::basic_string<UniChar>& message) const;
#endif
#if LOG4CXX_CFSTRING_API
        void log(const LevelPtr& level, const CFStringRef& message,
            const LOG4CXX_NS::spi::LocationInfo& location) const;
        void log(const LevelPtr& level, const CFStringRef& message) const;
#endif
        void logLS(const LevelPtr& level, const LogString& message,
            const LOG4CXX_NS::spi::LocationInfo& location) const;
 
 
 
        void removeAllAppenders() override;
 
        void removeAppender(const AppenderPtr appender) override;
 
        void removeAppender(const LogString& name) override;
 
        bool replaceAppender(const AppenderPtr& oldAppender, const AppenderPtr& newAppender) LOG4CXX_16_VIRTUAL_SPECIFIER;
 
        void replaceAppenders(const AppenderList& newList) LOG4CXX_16_VIRTUAL_SPECIFIER;
 
        void setAdditivity(bool additive);
 
    protected:
        friend class Hierarchy;
 
        void removeHierarchy();
        void setHierarchy(spi::LoggerRepository* repository);
        void setParent(LoggerPtr parentLogger);
        void updateThreshold();
 
    public: // Unit testing support methods
        void changeParentTo(const LoggerPtr& otherLogger) { setParent(otherLogger); }
 
        bool isThresholdEqualTo(const LevelPtr& level) const;
 
        bool isThresholdEqualTo(const LoggerPtr& other) const;
 
        bool isThresholdValid() const;
 
    private:
        spi::LoggerRepository* getHierarchy() const;
 
    public:
        virtual void setLevel(const LevelPtr level);
 
        void setResourceBundle(const helpers::ResourceBundlePtr& bundle);
 
#if LOG4CXX_WCHAR_T_API
        void warn(const std::wstring& msg, const LOG4CXX_NS::spi::LocationInfo& location) const;
        void warn(const std::wstring& msg) const;
#endif
#if LOG4CXX_UNICHAR_API
        void warn(const std::basic_string<UniChar>& msg, const LOG4CXX_NS::spi::LocationInfo& location) const;
        void warn(const std::basic_string<UniChar>& msg) const;
#endif
#if LOG4CXX_CFSTRING_API
        void warn(const CFStringRef& msg, const LOG4CXX_NS::spi::LocationInfo& location) const;
        void warn(const CFStringRef& msg) const;
#endif
        void warn(const std::string& msg, const LOG4CXX_NS::spi::LocationInfo& location) const;
        void warn(const std::string& msg) const;
 
#if LOG4CXX_WCHAR_T_API
        void trace(const std::wstring& msg, const LOG4CXX_NS::spi::LocationInfo& location) const;
        void trace(const std::wstring& msg) const;
#endif
#if LOG4CXX_UNICHAR_API
        void trace(const std::basic_string<UniChar>& msg, const LOG4CXX_NS::spi::LocationInfo& location) const;
        void trace(const std::basic_string<UniChar>& msg) const;
#endif
#if LOG4CXX_CFSTRING_API
        void trace(const CFStringRef& msg, const LOG4CXX_NS::spi::LocationInfo& location) const;
        void trace(const CFStringRef& msg) const;
#endif
        void trace(const std::string& msg, const LOG4CXX_NS::spi::LocationInfo& location) const;
        void trace(const std::string& msg) const;
 
        void reconfigure( const AppenderList& newList, bool newAdditivity );
 
    private:
        //
        //  prevent copy and assignment
        Logger(const Logger&);
        Logger& operator=(const Logger&);
};
LOG4CXX_LIST_DEF(LoggerList, LoggerPtr);
}
 
#if !defined(LOG4CXX_UNLIKELY)
    #if __GNUC__ >= 3
        #define LOG4CXX_UNLIKELY(expr) __builtin_expect(expr, 0)
    #else
        #define LOG4CXX_UNLIKELY(expr) expr
    #endif
#endif
 
#if defined(LOG4CXX_ENABLE_STACKTRACE) && !defined(LOG4CXX_STACKTRACE)
    #ifndef __has_include
        #include <boost/stacktrace.hpp>
        #define LOG4CXX_STACKTRACE ::LOG4CXX_NS::MDC mdc_("stacktrace", LOG4CXX_EOL + boost::stacktrace::to_string(boost::stacktrace::stacktrace()));
    #elif __has_include(<stacktrace>)
        #include <stacktrace>
        #define LOG4CXX_STACKTRACE ::LOG4CXX_NS::MDC mdc_("stacktrace", LOG4CXX_EOL + std::stacktrace::to_string(std::stacktrace::stacktrace()));
    #elif __has_include(<boost/stacktrace.hpp>)
        #include <boost/stacktrace.hpp>
        #define LOG4CXX_STACKTRACE ::LOG4CXX_NS::MDC mdc_("stacktrace", LOG4CXX_EOL + boost::stacktrace::to_string(boost::stacktrace::stacktrace()));
    #else
        #warning "Stacktrace requested but no implementation found"
    #endif
#endif /* LOG4CXX_ENABLE_STACKTRACE */
 
#if !defined(LOG4CXX_STACKTRACE)
#define LOG4CXX_STACKTRACE
#endif
 
#ifndef LOG4CXX_FMT_VA_ARG
#if __cplusplus >= 202002L
    #define LOG4CXX_FMT_VA_ARG(...) __VA_OPT__(,) __VA_ARGS__
#else
    #define LOG4CXX_FMT_VA_ARG(...) , __VA_ARGS__
#endif
#endif
 
#define LOG4CXX_LOG(logger, level, message) do { \
        if (logger->isEnabledFor(level)) {\
            ::LOG4CXX_NS::helpers::MessageBuffer oss_; \
            logger->addEvent(level, oss_.extract_str(oss_ << message), LOG4CXX_LOCATION); }} while (0)
 
#define LOG4CXX_LOG_FMT(logger, level, fmt, ...) do { \
        if (logger->isEnabledFor(level)) {\
            logger->addEvent(level, ::LOG4CXX_FORMAT_NS::format(fmt LOG4CXX_FMT_VA_ARG(__VA_ARGS__) ), LOG4CXX_LOCATION); }} while (0)
 
#define LOG4CXX_LOGLS(logger, level, message) do { \
        if (logger->isEnabledFor(level)) {\
            ::LOG4CXX_NS::helpers::LogCharMessageBuffer oss_; \
            logger->addEvent(level, oss_.extract_str(oss_ << message), LOG4CXX_LOCATION); }} while (0)
 
#if !defined(LOG4CXX_THRESHOLD) || LOG4CXX_THRESHOLD <= 10000
#define LOG4CXX_DEBUG(logger, message) do { \
        if (LOG4CXX_UNLIKELY(::LOG4CXX_NS::Logger::isDebugEnabledFor(logger))) {\
            ::LOG4CXX_NS::helpers::MessageBuffer oss_; \
            logger->addDebugEvent(oss_.extract_str(oss_ << message), LOG4CXX_LOCATION); }} while (0)
 
#define LOG4CXX_DEBUG_FMT(logger, fmt, ...) do { \
        if (LOG4CXX_UNLIKELY(::LOG4CXX_NS::Logger::isDebugEnabledFor(logger))) {\
            logger->addDebugEvent(::LOG4CXX_FORMAT_NS::format(fmt LOG4CXX_FMT_VA_ARG(__VA_ARGS__) ), LOG4CXX_LOCATION); }} while (0)
#else
#define LOG4CXX_DEBUG(logger, message)
#define LOG4CXX_DEBUG_FMT(logger, fmt, ...)
#endif
 
#if !defined(LOG4CXX_THRESHOLD) || LOG4CXX_THRESHOLD <= 5000
#define LOG4CXX_TRACE(logger, message) do { \
        if (LOG4CXX_UNLIKELY(::LOG4CXX_NS::Logger::isTraceEnabledFor(logger))) {\
            ::LOG4CXX_NS::helpers::MessageBuffer oss_; \
            logger->addTraceEvent(oss_.extract_str(oss_ << message), LOG4CXX_LOCATION); }} while (0)
 
#define LOG4CXX_TRACE_FMT(logger, fmt, ...) do { \
        if (LOG4CXX_UNLIKELY(::LOG4CXX_NS::Logger::isTraceEnabledFor(logger))) {\
            logger->addTraceEvent(::LOG4CXX_FORMAT_NS::format(fmt LOG4CXX_FMT_VA_ARG(__VA_ARGS__)), LOG4CXX_LOCATION); }} while (0)
#else
#define LOG4CXX_TRACE(logger, message)
#define LOG4CXX_TRACE_FMT(logger, fmt, ...)
#endif
 
#if !defined(LOG4CXX_THRESHOLD) || LOG4CXX_THRESHOLD <= 20000
#define LOG4CXX_INFO(logger, message) do { \
        if (::LOG4CXX_NS::Logger::isInfoEnabledFor(logger)) {\
            ::LOG4CXX_NS::helpers::MessageBuffer oss_; \
            logger->addInfoEvent(oss_.extract_str(oss_ << message), LOG4CXX_LOCATION); }} while (0)
 
#define LOG4CXX_INFO_FMT(logger, fmt, ...) do { \
        if (::LOG4CXX_NS::Logger::isInfoEnabledFor(logger)) {\
            logger->addInfoEvent(::LOG4CXX_FORMAT_NS::format(fmt LOG4CXX_FMT_VA_ARG(__VA_ARGS__)), LOG4CXX_LOCATION); }} while (0)
#else
#define LOG4CXX_INFO(logger, message)
#define LOG4CXX_INFO_FMT(logger, fmt, ...)
#endif
 
#if !defined(LOG4CXX_THRESHOLD) || LOG4CXX_THRESHOLD <= 30000
#define LOG4CXX_WARN(logger, message) do { \
        if (::LOG4CXX_NS::Logger::isWarnEnabledFor(logger)) {\
            ::LOG4CXX_NS::helpers::MessageBuffer oss_; \
            logger->addWarnEvent(oss_.extract_str(oss_ << message), LOG4CXX_LOCATION); }} while (0)
 
#define LOG4CXX_WARN_FMT(logger, fmt, ...) do { \
        if (::LOG4CXX_NS::Logger::isWarnEnabledFor(logger)) {\
            logger->addWarnEvent(::LOG4CXX_FORMAT_NS::format(fmt LOG4CXX_FMT_VA_ARG(__VA_ARGS__)), LOG4CXX_LOCATION); }} while (0)
#else
#define LOG4CXX_WARN(logger, message)
#define LOG4CXX_WARN_FMT(logger, fmt, ...)
#endif
 
#if !defined(LOG4CXX_THRESHOLD) || LOG4CXX_THRESHOLD <= 40000
#define LOG4CXX_ERROR(logger, message) do { \
        if (::LOG4CXX_NS::Logger::isErrorEnabledFor(logger)) {\
            ::LOG4CXX_NS::helpers::MessageBuffer oss_; \
            logger->addErrorEvent(oss_.extract_str(oss_ << message), LOG4CXX_LOCATION); }} while (0)
 
#define LOG4CXX_ERROR_FMT(logger, fmt, ...) do { \
        if (::LOG4CXX_NS::Logger::isErrorEnabledFor(logger)) {\
            logger->addErrorEvent(::LOG4CXX_FORMAT_NS::format(fmt LOG4CXX_FMT_VA_ARG(__VA_ARGS__)), LOG4CXX_LOCATION); }} while (0)
 
#define LOG4CXX_ASSERT(logger, condition, message) do { \
        if (!(condition) && ::LOG4CXX_NS::Logger::isErrorEnabledFor(logger)) {\
            ::LOG4CXX_NS::helpers::MessageBuffer oss_; \
            LOG4CXX_STACKTRACE \
            logger->addErrorEvent(oss_.extract_str(oss_ << message), LOG4CXX_LOCATION); }} while (0)
 
#define LOG4CXX_ASSERT_FMT(logger, condition, fmt, ...) do { \
        if (!(condition) && ::LOG4CXX_NS::Logger::isErrorEnabledFor(logger)) {\
            LOG4CXX_STACKTRACE \
            logger->addErrorEvent(::LOG4CXX_FORMAT_NS::format(fmt LOG4CXX_FMT_VA_ARG(__VA_ARGS__)), LOG4CXX_LOCATION); }} while (0)
 
#else
#define LOG4CXX_ERROR(logger, message)
#define LOG4CXX_ERROR_FMT(logger, fmt, ...)
#define LOG4CXX_ASSERT(logger, condition, message)
#define LOG4CXX_ASSERT_FMT(logger, condition, fmt, ...)
#endif
 
#if !defined(LOG4CXX_THRESHOLD) || LOG4CXX_THRESHOLD <= 50000
#define LOG4CXX_FATAL(logger, message) do { \
        if (::LOG4CXX_NS::Logger::isFatalEnabledFor(logger)) {\
            ::LOG4CXX_NS::helpers::MessageBuffer oss_; \
            logger->addFatalEvent(oss_.extract_str(oss_ << message), LOG4CXX_LOCATION); }} while (0)
 
#define LOG4CXX_FATAL_FMT(logger, fmt, ...) do { \
        if (::LOG4CXX_NS::Logger::isFatalEnabledFor(logger)) {\
            logger->addFatalEvent(::LOG4CXX_FORMAT_NS::format(fmt LOG4CXX_FMT_VA_ARG(__VA_ARGS__)), LOG4CXX_LOCATION); }} while (0)
#else
#define LOG4CXX_FATAL(logger, message)
#define LOG4CXX_FATAL_FMT(logger, fmt, ...)
#endif
 
#define LOG4CXX_L7DLOG(logger, level, key) do { \
        if (logger->isEnabledFor(level)) {\
            logger->l7dlog(level, key, LOG4CXX_LOCATION); }} while (0)
 
#define LOG4CXX_L7DLOG1(logger, level, key, p1) do { \
        if (logger->isEnabledFor(level)) {\
            logger->l7dlog(level, key, LOG4CXX_LOCATION, p1); }} while (0)
 
#define LOG4CXX_L7DLOG2(logger, level, key, p1, p2) do { \
        if (logger->isEnabledFor(level)) {\
            logger->l7dlog(level, key, LOG4CXX_LOCATION, p1, p2); }} while (0)
 
#define LOG4CXX_L7DLOG3(logger, level, key, p1, p2, p3) do { \
        if (logger->isEnabledFor(level)) {\
            logger->l7dlog(level, key, LOG4CXX_LOCATION, p1, p2, p3); }} while (0)
 
#include <log4cxx/spi/loggerrepository.h>
 
#endif //_LOG4CXX_LOGGER_H