oflog/include/dcmtk/oflog/logger.h

Go to the documentation of this file.

// Module:  Log4CPLUS
// File:    logger.h
// Created: 6/2001
// Author:  Tad E. Smith
//
//
// Copyright 2001-2009 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 "dcmtk/oflog/config.h"
#include "dcmtk/oflog/loglevel.h"
#include "dcmtk/oflog/tstring.h"
#include "dcmtk/oflog/streams.h"
#include "dcmtk/oflog/spi/apndatch.h"
#include "dcmtk/oflog/spi/logfact.h"

//#include <vector>


namespace log4cplus
{
    // Forward declarations

    class Appender;
    class Hierarchy;
    class HierarchyLocker;
    class DefaultLoggerFactory;

    namespace spi
    {

        class LoggerImpl;

    }


    typedef OFList<Logger> LoggerList;
    typedef OFListIterator(Logger) LoggerListIterator;


    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=NULL, int line=-1,
                 const char* function=NULL) const;

        void forcedLog(LogLevel ll, const log4cplus::tstring& message,
                       const char* file=NULL, int line=-1,
                       const char* function=NULL) const;

        void callAppenders(const spi::InternalLoggingEvent& event) const;

        LogLevel getChainedLogLevel() const;

        LogLevel getLogLevel() const;

        void setLogLevel(LogLevel ll);

        Hierarchy& getHierarchy() const;

        log4cplus::tstring 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 ();
        Logger(const Logger& rhs);
        Logger& operator=(const Logger& rhs);
        virtual ~Logger();

        void swap (Logger &);

        Logger getParent() const;

    protected:
      // Data
        spi::LoggerImpl * value;

    private:
      // Ctors
        Logger(spi::LoggerImpl * ptr);

      // 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);
    };



    class TraceLogger
    {
    public:
        TraceLogger(const Logger& l, const log4cplus::tstring& _msg,
                    const char* _file=NULL, int _line=-1)
          : logger(l), msg(_msg), file(_file), line(_line)
        { if(logger.isEnabledFor(TRACE_LOG_LEVEL))
              logger.forcedLog(TRACE_LOG_LEVEL, LOG4CPLUS_TEXT("ENTER: ") + msg, file, line);
        }

        ~TraceLogger()
        { if(logger.isEnabledFor(TRACE_LOG_LEVEL))
              logger.forcedLog(TRACE_LOG_LEVEL, LOG4CPLUS_TEXT("EXIT:  ") + msg, file, line);
        }

    private:
        TraceLogger(const TraceLogger&);
        TraceLogger& operator=(const TraceLogger&);
        Logger logger;
        log4cplus::tstring msg;
        const char* file;
        int line;
    };

} // end namespace log4cplus


#include "dcmtk/oflog/logmacro.h"


#endif // _LOG4CPLUS_LOGGERHEADER_

---

Generated on 6 Jan 2011 for OFFIS DCMTK Version 3.6.0 by Doxygen 1.5.1