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 "Base/GCException.h"
#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>
 
LOG4CPP_NS_BEGIN
 
    class LOG4CPP_EXPORT Category {
        friend class HierarchyMaintainer;
 
        public:
        static Category& getRoot();
 
        static void setRootPriority(Priority::Value priority);
 
        static Priority::Value getRootPriority() throw();
 
        static Category& getInstance(const std::string& name);
            
        static Category* exists(const std::string& name);
 
        static std::vector<Category*>* getCurrentCategories();
 
        static void shutdown();
 
        virtual ~Category();
        
        virtual const std::string& getName() const throw(); 
        
        virtual void setPriority(Priority::Value priority);
            //throw(GenICam::InvalidArgumentException);
 
        virtual Priority::Value getPriority() const throw();
 
        virtual Priority::Value getChainedPriority() const throw();
 
        virtual bool isPriorityEnabled(Priority::Value priority) const throw();
        
        virtual void addAppender(Appender* appender);
        //throw(GenICam::InvalidArgumentException);
 
        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 throw() {
            return ownsAppender(getAppender());
        };
 
        virtual bool ownsAppender(Appender* appender) const throw();
 
        virtual void callAppenders(const LoggingEvent& event) throw();
        
        virtual void setAdditivity(bool additivity);
 
        virtual bool getAdditivity() const throw();
 
        virtual Category* getParent() throw();
 
        virtual const Category* getParent() const throw();
 
        virtual void log(Priority::Value priority, const char* stringFormat,
                         ...) throw();
 
        virtual void log(Priority::Value priority, 
                         const std::string& message) throw();
        
        virtual void logva(Priority::Value priority, 
                           const char* stringFormat,
                           va_list va) throw();
        
        void debug(const char* stringFormat, ...) throw();
 
        void debug(const std::string& message) throw();
 
        inline bool isDebugEnabled() throw() { 
            if( !_ValidDebugEnabledCache )
            {
                _DebugEnabled = isPriorityEnabled(Priority::DEBUG);
                _ValidDebugEnabledCache = true;
            }
            return _DebugEnabled;
        };
        
        inline CategoryStream debugStream() {
            return getStream(Priority::DEBUG);
        }
 
        void info(const char* stringFormat, ...) throw();
 
        void info_push(const char* stringFormat, ...) throw();
 
        void info_pop(const char* stringFormat, ...) throw();
 
        void info(const std::string& message) throw();
 
        inline bool isInfoEnabled() throw() { 
            if( !_ValidInfoEnabledCache )
            {
                _InfoEnabled = isPriorityEnabled(Priority::INFO);
                _ValidInfoEnabledCache = true;
            }
            return _InfoEnabled;
        };
 
        inline CategoryStream infoStream() {
            return getStream(Priority::INFO);
        }
        
        void notice(const char* stringFormat, ...) throw();
 
        void notice(const std::string& message) throw();
 
        inline bool isNoticeEnabled() const throw() { 
            return isPriorityEnabled(Priority::NOTICE);
        };
 
        inline CategoryStream noticeStream() {
            return getStream(Priority::NOTICE);
        }
        
        void warn(const char* stringFormat, ...) throw();
 
        void warn(const std::string& message) throw();
 
        inline bool isWarnEnabled() throw() { 
            if( !_ValidWarnEnabledCache )
            {
                _WarnEnabled = isPriorityEnabled(Priority::WARN);
                _ValidWarnEnabledCache = true;
            }
            return _WarnEnabled;
        };
 
        inline CategoryStream warnStream() {
            return getStream(Priority::WARN);
        };
        
        void error(const char* stringFormat, ...) throw();
 
        void error(const std::string& message) throw();
 
        inline bool isErrorEnabled() const throw() { 
            return isPriorityEnabled(Priority::ERROR);
        };
        
        inline CategoryStream errorStream() {
            return getStream(Priority::ERROR);
        };
 
        void crit(const char* stringFormat, ...) throw();
 
        void crit(const std::string& message) throw();
 
        inline bool isCritEnabled() const throw() { 
            return isPriorityEnabled(Priority::CRIT);
        };
        
        inline CategoryStream critStream() {
            return getStream(Priority::CRIT);
        };
        
        void alert(const char* stringFormat, ...) throw();
 
        void alert(const std::string& message) throw();
 
        inline bool isAlertEnabled() const throw() { 
            return isPriorityEnabled(Priority::ALERT);
        };
        
        inline CategoryStream alertStream() throw() {
            return getStream(Priority::ALERT);
        };
 
        void emerg(const char* stringFormat, ...) throw();
 
        void emerg(const std::string& message) throw();
 
        inline bool isEmergEnabled() const throw() { 
            return isPriorityEnabled(Priority::EMERG);
        };
        
        inline CategoryStream emergStream() {
            return getStream(Priority::EMERG);
        };
 
        void fatal(const char* stringFormat, ...) throw();
 
        void fatal(const std::string& message) throw();
 
        inline bool isFatalEnabled() const throw() { 
            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) throw();
        
        virtual void _logUnconditionally2(Priority::Value priority, 
                                          const std::string& message) throw();
 
        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) throw();
 
        AppenderSet _appender;
        mutable threading::Mutex _appenderSetMutex;
 
        OwnsAppenderMap _ownsAppender;
 
        volatile bool _isAdditive;
 
        bool _ValidInfoEnabledCache;
 
        bool _InfoEnabled;
        
        bool _ValidDebugEnabledCache;
 
        bool _DebugEnabled;
 
        bool _ValidWarnEnabledCache;
 
        bool _WarnEnabled;
 
        void InvalidateEnabledCache(bool InvalidateAll = true);
    };
 
LOG4CPP_NS_END
#endif // _LOG4CPP_CATEGORY_HH