loggingLogger.h

Go to the documentation of this file.

#ifndef logging_logger_H
#define logging_logger_H
/*******************************************************************************
* ALMA - Atacama Large Millimiter Array
* (c) Associated Universities Inc., 2005 
* 
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
* 
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
* Lesser General Public License for more details.
* 
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
*
* "@(#) $Id: loggingLogger.h,v 1.27 2012/02/29 12:50:09 tstaig Exp $"
*
* who       when      what
* --------  --------  ----------------------------------------------
* dfugate  2005-03-09  created
*/

#ifndef __cplusplus
#error This is a C++ include file and cannot be used from plain C
#endif

#include <string>
#include <lokiSmartPtr.h>
#include <list>
#include "loggingBaseLog.h"
#include "loggingHandler.h"
#include <ace/Thread_Mutex.h>
#include <ace/Singleton.h>
#include <ace/Thread_Manager.h>   // it is here just that we can print ID of the thread !!!

namespace Logging 
{

    //------------------------------------------------------------------------------
    class loggingBase_EXPORT Logger : public virtual BaseLog
    {
      public:
        //----------------------------------------------------
#ifndef MAKE_VXWORKS
        typedef Loki::SmartPtr<Logger, 
#ifdef __CYGWIN__
                               Logging::RefCounted,
#else
                               Loki::RefCountedMTAdj<Loki::ObjectLevelLockable>::RefCountedMT,
#endif
                               Loki::AllowConversion,
                               Loki::NoCheck,
                               Loki::DefaultSPStorage> LoggerSmartPtr;
#else
        typedef Loki::SmartPtr<Logger, 
                               RefCountedMT,
                               Loki::AllowConversion,
                               Loki::NoCheck,
                               Loki::DefaultSPStorage> LoggerSmartPtr;
#endif

        // Loggers list
        typedef std::list<Logger*> LoggerList;
        
        // Implementation of external function that configures logger 
        typedef void (*ConfigureLoggerFunction)(const std::string& loggerName);
        
        virtual LoggerSmartPtr
        getLogger(const std::string &loggerName) = 0;

    int getLocalLevel();
    int getRemoteLevel();
    int
    getLocalLevel(const std::string &loggerName);
    int
    getRemoteLevel(const std::string &loggerName);
        static LoggerSmartPtr getAnonymousLogger();

        static void     setAnonymousLogger(LoggerSmartPtr anonyLogger);
        
        static LoggerSmartPtr getStaticLogger();

        static void     setStaticLogger(LoggerSmartPtr anonyLogger);
        
        static LoggerSmartPtr getGlobalLogger();
        
        static void setGlobalLogger(LoggerSmartPtr globalLogger);
        
        virtual std::string     getName() const;
        
        virtual ~Logger();
        
        virtual void
        addHandler(Handler::HandlerSmartPtr newHandler_p);
        
        virtual bool 
        removeHandler(const std::string &handlerName);
        
        virtual void
        log(const LogRecord &lr);

        virtual void
        log(Priority priority,
            const std::string &message,
            const std::string &file,
            unsigned long line,
            const std::string &method)
            {
                BaseLog::log(priority, message, file, line, method);
            }

        virtual void
        log(Priority priority,
            const std::string &message)
            {
                log(priority,
                    message,
                    FIELD_UNAVAILABLE,
                    0UL,
                    FIELD_UNAVAILABLE);
            }
        
        virtual void 
        setName(const std::string &newName);

        virtual void
        setLevels(Priority remotePriority,Priority localPriority, int type);
        
        virtual void
        setLevels(const std::string &loggerName, Priority remotePriority,Priority localPriority, int type);
    
    void setLevelsLoggerHandlers(Priority remotePriority,Priority localPriority, int type);
        virtual bool
        exists(const std::string &loggerName);

        virtual std::list<std::string>
        getLoggerNames();

        static void
        setConfigureLoggerFunction(ConfigureLoggerFunction configureLoggerFunction) {configureLoggerFunction_m=configureLoggerFunction;}
        
        static void
        configureLogger(const std::string& loggerName)
        {
                if (configureLoggerFunction_m)
                        (*configureLoggerFunction_m)(loggerName);
        }
        
      protected:
        //----------------------------------------------------
        Logger(const std::string &loggerName);

        virtual void
        acquireHandlerMutex() {}

        virtual void 
        releaseHandlerMutex() {}
        
      private:
        //----------------------------------------------------
        std::string loggerName_m;
        
        std::list<Handler::HandlerSmartPtr> handlers_m;

        class Logger_ptr{
                public:
                        Logger_ptr(){globalLogger_m=(Logger *)0;anonymousLogger_m=(Logger *)0;staticLogger_m=(Logger *)0;}
                        ~Logger_ptr(){globalLogger_m=(Logger *)0;anonymousLogger_m=(Logger *)0;staticLogger_m=(Logger *)0;}
                        LoggerSmartPtr globalLogger_m;
                        LoggerSmartPtr anonymousLogger_m;
                        
                        LoggerSmartPtr staticLogger_m;
                        
                        LoggerList loggers_m;
        };

        static ACE_Thread_Mutex loggersMutex_m;

        static ConfigureLoggerFunction configureLoggerFunction_m;

    };
    //------------------------------------------------------------------------------
};

#endif