loggingBaseLog.h

Go to the documentation of this file.

#ifndef logging_base_log_H
#define logging_base_log_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: loggingBaseLog.h,v 1.14 2010/03/25 22:07:23 javarias 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>

namespace Logging 
{
    //------------------------------------------------------------------------------
    class BaseLog
    {
      public:

        virtual ~BaseLog(){}

        enum Priority
        {
            LM_SHUTDOWN = 01,
            LM_TRACE = 02,

        LM_DELOUSE = 03,
            
            LM_DEBUG = 04,
            
            LM_INFO = 010,
            
            LM_NOTICE = 020,
            
            LM_WARNING = 040,
            
            LM_ERROR = 0200,
            
            LM_CRITICAL = 0400,
            
            LM_ALERT = 01000,
            
            LM_EMERGENCY = 02000
        };


        struct LogRecord {
            Priority priority;
            std::string message;
            std::string file;
            unsigned long line;
            std::string method;
            unsigned long long timeStamp;
        };
        
        //----------------------------------------------------
        virtual void
        log(Priority priority,
            const std::string &message,
            const std::string &file,
            unsigned long line,
            const std::string &method);
            
        virtual void
        log(const LogRecord &lr) = 0;

        //----------------------------------------------------
        virtual std::string
        getName() const = 0;

        static const std::string FIELD_UNAVAILABLE;

        static const std::string GLOBAL_LOGGER_NAME;

        static const std::string ANONYMOUS_LOGGER_NAME;

        static const std::string STATIC_LOGGER_NAME;
    };
    //------------------------------------------------------------------------------
    template <class P>
    class RefCounted
    {
      public:
        RefCounted() 
            {
                pCount_ = new unsigned int();
                assert(pCount_);
                *pCount_ = 1;
            }
        
        RefCounted(const RefCounted& rhs) 
            : pCount_(rhs.pCount_)
            {}
        
        // MWCW lacks template friends, hence the following kludge
        template <typename P1>
        RefCounted(const RefCounted<P1>& rhs) 
            : pCount_(reinterpret_cast<const RefCounted&>(rhs).pCount_)
            {}
        
        P Clone(const P& val)
            {
                ++*pCount_;
                return val;
            }
        
        bool Release(const P&)
            {
                if (!--*pCount_)
                    {
                    delete pCount_;
                    return true;
                    }
                return false;
            }
        
        void Swap(RefCounted& rhs)
            { std::swap(pCount_, rhs.pCount_); }
        
        enum { destructiveCopy = false };
        
      private:
        // Data
        unsigned int* pCount_;
    };  

#ifdef MAKE_VXWORKS
// we have to define (copy from loki) our own RefCountedMT for VxWorks since the one for loki is too compley for VxWorks compiler
        template <class P>
        class RefCountedMT : public Loki::ObjectLevelLockable<RefCountedMT<P>, LOKI_DEFAULT_MUTEX >
        {
            typedef Loki::ObjectLevelLockable<RefCountedMT<P>, LOKI_DEFAULT_MUTEX > base_type;
            typedef typename base_type::IntType       CountType;
            typedef volatile CountType               *CountPtrType;

        public:
            RefCountedMT()
            {
                pCount_ = reinterpret_cast<CountPtrType>(
                    Loki::SmallObject<LOKI_DEFAULT_THREADING_NO_OBJ_LEVEL>::operator new(
                        sizeof(*pCount_)));
                assert(pCount_);
                // *pCount_ = 1;
                Loki::ObjectLevelLockable<RefCountedMT, LOKI_DEFAULT_MUTEX>::AtomicAssign(*pCount_, 1);
            }

            RefCountedMT(const RefCountedMT& rhs) : 
                Loki::ObjectLevelLockable<RefCountedMT<P>, LOKI_DEFAULT_MUTEX>( rhs ),
                pCount_(rhs.pCount_)
            {}

            //MWCW lacks template friends, hence the following kludge
            template <typename P1>
            RefCountedMT(const RefCountedMT<P1>& rhs) 
            : pCount_(reinterpret_cast<const RefCountedMT<P>&>(rhs).pCount_)
            {}

            P Clone(const P& val)
            {
                Loki::ObjectLevelLockable<RefCountedMT, LOKI_DEFAULT_MUTEX>::AtomicIncrement(*pCount_);
                return val;
            }

            bool Release(const P&)
            {
                if (! Loki::ObjectLevelLockable<RefCountedMT, LOKI_DEFAULT_MUTEX>::AtomicDecrement(*pCount_))
                {
                    Loki::SmallObject<LOKI_DEFAULT_THREADING_NO_OBJ_LEVEL>::operator delete(
                        const_cast<CountType *>(pCount_), 
                        sizeof(*pCount_));
                    return true;
                }
                return false;
            }

            void Swap(RefCountedMT& rhs)
            { std::swap(pCount_, rhs.pCount_); }

            enum { destructiveCopy = false };

        private:
            // Data
            CountPtrType pCount_;
        };
#endif //MAKE_VXWORKS
};

#endif