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/Portability.hh>
#include <log4cpp/Appender.hh>
#include <log4cpp/LoggingEvent.hh>
#include <log4cpp/Priority.hh>
#include <log4cpp/CategoryStream.hh>
#include <log4cpp/threading/Threading.hh>
#include <log4cpp/convenience.h>

#include <map>
#include <vector>
#include <cstdarg>
#include <stdexcept>

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;

    };

}
#endif // _LOG4CPP_CATEGORY_HH