Category.hh

Go to the documentation of this file.

/*
 * Category.hh
 *
 * Copyright 2000, LifeLine Networks BV (www.lifeline.nl). All rights reserved.
 * Copyright 2000, Bastiaan Bakker. All rights reserved.
 *
 * See the COPYING file for the terms of usage and distribution.
 */
 
#ifndef _LOG4CPP_CATEGORY_HH
#define _LOG4CPP_CATEGORY_HH
 
#include <log4cpp/Appender.hh>
#include <log4cpp/CategoryStream.hh>
#include <log4cpp/LoggingEvent.hh>
#include <log4cpp/Portability.hh>
#include <log4cpp/Priority.hh>
#include <log4cpp/threading/Threading.hh>
 
#include <cstdarg>
#include <map>
#include <stdexcept>
#include <vector>
 
namespace log4cpp {
 
    class LOG4CPP_EXPORT Category {
        friend class HierarchyMaintainer;
 
      public:
        static Category& getRoot();
 
        static void setRootPriority(Priority::Value priority);
 
        static Priority::Value getRootPriority() LOG4CPP_NOTHROW;
 
        static Category& getInstance(const std::string& name);
 
        static Category* exists(const std::string& name);
 
        static std::vector<Category*>* getCurrentCategories();
 
        static void shutdown();
 
        static void shutdownForced();
 
        virtual ~Category();
 
        virtual const std::string& getName() const LOG4CPP_NOTHROW;
 
        virtual void setPriority(Priority::Value priority);
 
        virtual Priority::Value getPriority() const LOG4CPP_NOTHROW;
 
        virtual Priority::Value getChainedPriority() const LOG4CPP_NOTHROW;
 
        virtual bool isPriorityEnabled(Priority::Value priority) const LOG4CPP_NOTHROW;
 
        virtual void addAppender(Appender* appender);
 
        virtual void addAppender(Appender& appender);
 
        inline void setAppender(Appender* appender) {
            if (appender) {
                addAppender(appender);
            } else {
                removeAllAppenders();
            }
        };
 
        inline void setAppender(Appender& appender) {
            addAppender(appender);
        };
 
        virtual Appender* getAppender() const;
 
        virtual Appender* getAppender(const std::string& name) const;
 
        virtual AppenderSet getAllAppenders() const;
 
        virtual void removeAllAppenders();
 
        virtual void removeAppender(Appender* appender);
 
        virtual bool ownsAppender() const LOG4CPP_NOTHROW {
            return ownsAppender(getAppender());
        };
 
        virtual bool ownsAppender(Appender* appender) const LOG4CPP_NOTHROW;
 
        virtual void callAppenders(const LoggingEvent& event) LOG4CPP_NOTHROW;
 
        virtual void setAdditivity(bool additivity);
 
        virtual bool getAdditivity() const LOG4CPP_NOTHROW;
 
        virtual Category* getParent() LOG4CPP_NOTHROW;
 
        virtual const Category* getParent() const LOG4CPP_NOTHROW;
 
        virtual void log(Priority::Value priority, const char* stringFormat, ...) LOG4CPP_NOTHROW;
 
        virtual void log(Priority::Value priority, const std::string& message) LOG4CPP_NOTHROW;
 
        virtual void logva(Priority::Value priority, const char* stringFormat, va_list va) LOG4CPP_NOTHROW;
 
        void debug(const char* stringFormat, ...) LOG4CPP_NOTHROW;
 
        void debug(const std::string& message) LOG4CPP_NOTHROW;
 
        inline bool isDebugEnabled() const LOG4CPP_NOTHROW {
            return isPriorityEnabled(Priority::DEBUG);
        };
 
        inline CategoryStream debugStream() {
            return getStream(Priority::DEBUG);
        }
 
        void info(const char* stringFormat, ...) LOG4CPP_NOTHROW;
 
        void info(const std::string& message) LOG4CPP_NOTHROW;
 
        inline bool isInfoEnabled() const LOG4CPP_NOTHROW {
            return isPriorityEnabled(Priority::INFO);
        };
 
        inline CategoryStream infoStream() {
            return getStream(Priority::INFO);
        }
 
        void notice(const char* stringFormat, ...) LOG4CPP_NOTHROW;
 
        void notice(const std::string& message) LOG4CPP_NOTHROW;
 
        inline bool isNoticeEnabled() const LOG4CPP_NOTHROW {
            return isPriorityEnabled(Priority::NOTICE);
        };
 
        inline CategoryStream noticeStream() {
            return getStream(Priority::NOTICE);
        }
 
        void warn(const char* stringFormat, ...) LOG4CPP_NOTHROW;
 
        void warn(const std::string& message) LOG4CPP_NOTHROW;
 
        inline bool isWarnEnabled() const LOG4CPP_NOTHROW {
            return isPriorityEnabled(Priority::WARN);
        };
 
        inline CategoryStream warnStream() {
            return getStream(Priority::WARN);
        };
 
        void error(const char* stringFormat, ...) LOG4CPP_NOTHROW;
 
        void error(const std::string& message) LOG4CPP_NOTHROW;
 
        inline bool isErrorEnabled() const LOG4CPP_NOTHROW {
            return isPriorityEnabled(Priority::ERROR);
        };
 
        inline CategoryStream errorStream() {
            return getStream(Priority::ERROR);
        };
 
        void crit(const char* stringFormat, ...) LOG4CPP_NOTHROW;
 
        void crit(const std::string& message) LOG4CPP_NOTHROW;
 
        inline bool isCritEnabled() const LOG4CPP_NOTHROW {
            return isPriorityEnabled(Priority::CRIT);
        };
 
        inline CategoryStream critStream() {
            return getStream(Priority::CRIT);
        };
 
        void alert(const char* stringFormat, ...) LOG4CPP_NOTHROW;
 
        void alert(const std::string& message) LOG4CPP_NOTHROW;
 
        inline bool isAlertEnabled() const LOG4CPP_NOTHROW {
            return isPriorityEnabled(Priority::ALERT);
        };
 
        inline CategoryStream alertStream() LOG4CPP_NOTHROW {
            return getStream(Priority::ALERT);
        };
 
        void emerg(const char* stringFormat, ...) LOG4CPP_NOTHROW;
 
        void emerg(const std::string& message) LOG4CPP_NOTHROW;
 
        inline bool isEmergEnabled() const LOG4CPP_NOTHROW {
            return isPriorityEnabled(Priority::EMERG);
        };
 
        inline CategoryStream emergStream() {
            return getStream(Priority::EMERG);
        };
 
        void fatal(const char* stringFormat, ...) LOG4CPP_NOTHROW;
 
        void fatal(const std::string& message) LOG4CPP_NOTHROW;
 
        inline bool isFatalEnabled() const LOG4CPP_NOTHROW {
            return isPriorityEnabled(Priority::FATAL);
        };
 
        inline CategoryStream fatalStream() {
            return getStream(Priority::FATAL);
        };
 
        virtual CategoryStream getStream(Priority::Value priority);
 
        virtual CategoryStream operator<<(Priority::Value priority);
 
      protected:
        Category(const std::string& name, Category* parent, Priority::Value priority = Priority::NOTSET);
 
        virtual void _logUnconditionally(Priority::Value priority, const char* format,
                                         va_list arguments) LOG4CPP_NOTHROW;
 
        virtual void _logUnconditionally2(Priority::Value priority, const std::string& message) LOG4CPP_NOTHROW;
 
      private:
        /* prevent copying and assignment */
        Category(const Category& other);
        Category& operator=(const Category& other);
 
        const std::string _name;
 
        Category* _parent;
 
        volatile Priority::Value _priority;
 
        typedef std::map<Appender*, bool> OwnsAppenderMap;
 
        virtual bool ownsAppender(Appender* appender, OwnsAppenderMap::iterator& i2) LOG4CPP_NOTHROW;
 
        AppenderSet _appender;
        mutable threading::Mutex _appenderSetMutex;
 
        OwnsAppenderMap _ownsAppender;
 
        volatile bool _isAdditive;
    };
 
} // namespace log4cpp
#endif // _LOG4CPP_CATEGORY_HH