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.16 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 "loggingBaseExport.h"
#include "acsutilTimeStamp.h"
#include "loggingStatistics.h"

namespace Logging 
{
    //------------------------------------------------------------------------------
    class loggingBase_EXPORT BaseLog
    {
    public:
        // Default constructor
        BaseLog();

        // Default constructor
        virtual ~BaseLog(){}

        // Statistics object
        loggingStatistics stats;

                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