logger.h

Go to the documentation of this file.

// -*- C++ -*-
// Module:  Log4CPLUS
// File:    logger.h
// Created: 6/2001
// Author:  Tad E. Smith
//
//
// Copyright 2001-2017 Tad E. Smith
//
// Licensed 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 LOG4CPLUS_LOGGERHEADER_
#define LOG4CPLUS_LOGGERHEADER_
 
#include <log4cplus/config.hxx>
 
#if defined (LOG4CPLUS_HAVE_PRAGMA_ONCE)
#pragma once
#endif
 
#include <log4cplus/loglevel.h>
#include <log4cplus/tstring.h>
#include <log4cplus/spi/appenderattachable.h>
#include <log4cplus/spi/loggerfactory.h>
 
#include <vector>
 
 
namespace log4cplus
{
    // Forward declarations
 
    class Appender;
    class Hierarchy;
    class HierarchyLocker;
    class DefaultLoggerFactory;
 
    namespace spi
    {
 
        class LoggerImpl;
 
    }
 
 
    typedef std::vector<Logger> LoggerList;
 
 
    class LOG4CPLUS_EXPORT Logger
        : public log4cplus::spi::AppenderAttachable
    {
    public:
      // Static Methods
        static bool exists(const log4cplus::tstring& name);
 
        /*
         * Returns all the currently defined loggers in the default
         * hierarchy.
         *
         * The root logger is <em>not</em> included in the returned
         * list.
        */
        static LoggerList getCurrentLoggers();
 
        static Hierarchy& getDefaultHierarchy();
 
        static Logger getInstance(const log4cplus::tstring& name);
 
        static Logger getInstance(const log4cplus::tstring& name,
            spi::LoggerFactory& factory);
 
        static Logger getRoot();
 
        static void shutdown();
 
      // Non-Static Methods
        void assertion(bool assertionVal, const log4cplus::tstring& msg) const;
 
        void closeNestedAppenders() const;
 
        bool isEnabledFor(LogLevel ll) const;
 
        void log(LogLevel ll, const log4cplus::tstring& message,
            const char* file = LOG4CPLUS_CALLER_FILE (),
            int line = LOG4CPLUS_CALLER_LINE (),
            const char* function = LOG4CPLUS_CALLER_FUNCTION ()) const;
 
        void log(spi::InternalLoggingEvent const &) const;
 
        void forcedLog(LogLevel ll, const log4cplus::tstring& message,
            const char* file = LOG4CPLUS_CALLER_FILE (),
            int line = LOG4CPLUS_CALLER_LINE (),
            const char* function = LOG4CPLUS_CALLER_FUNCTION ()) const;
 
        void forcedLog(spi::InternalLoggingEvent const &) const;
 
        void callAppenders(const spi::InternalLoggingEvent& event) const;
 
        LogLevel getChainedLogLevel() const;
 
        LogLevel getLogLevel() const;
 
        void setLogLevel(LogLevel ll);
 
        Hierarchy& getHierarchy() const;
 
        log4cplus::tstring const & getName() const;
 
        bool getAdditivity() const;
 
        void setAdditivity(bool additive);
 
      // AppenderAttachable Methods
        virtual void addAppender(SharedAppenderPtr newAppender);
 
        virtual SharedAppenderPtrList getAllAppenders();
 
        virtual SharedAppenderPtr getAppender(const log4cplus::tstring& name);
 
        virtual void removeAllAppenders();
 
        virtual void removeAppender(SharedAppenderPtr appender);
 
        virtual void removeAppender(const log4cplus::tstring& name);
 
        Logger () LOG4CPLUS_NOEXCEPT;
        Logger(const Logger& rhs) LOG4CPLUS_NOEXCEPT;
        Logger& operator=(const Logger& rhs) LOG4CPLUS_NOEXCEPT;
        Logger (Logger && rhs) LOG4CPLUS_NOEXCEPT;
        Logger & operator = (Logger && rhs) LOG4CPLUS_NOEXCEPT;
        virtual ~Logger();
 
        void swap (Logger &) LOG4CPLUS_NOEXCEPT;
 
        Logger getParent() const;
 
    protected:
      // Data
        spi::LoggerImpl * value = nullptr;
 
    private:
      // Ctors
        Logger(spi::LoggerImpl * ptr) LOG4CPLUS_NOEXCEPT;
 
      // Friends
        friend class log4cplus::spi::LoggerImpl;
        friend class log4cplus::Hierarchy;
        friend class log4cplus::HierarchyLocker;
        friend class log4cplus::DefaultLoggerFactory;
    };
 
 
    class LOG4CPLUS_EXPORT DefaultLoggerFactory : public spi::LoggerFactory {
    public:
        Logger makeNewLoggerInstance(const log4cplus::tstring& name, Hierarchy& h);
 
    protected:
        virtual spi::LoggerImpl * makeNewLoggerImplInstance(
            const log4cplus::tstring& name, Hierarchy& h);
    };
 
 
} // end namespace log4cplus
 
 
#endif // LOG4CPLUS_LOGGERHEADER_