IsisBase.h

Go to the documentation of this file.

#ifndef ISIS_BASE
#define ISIS_BASE

#ifndef __func__
#define __func__        __FUNCTION__
#endif /* __func */

namespace ISIS
{
        class Base
        {
        protected:
                Base(const std::string& logger_name = "UNKNOWN") : m_logger(NULL), m_logstr(NULL) { setLoggerName(logger_name); }
                Poco::Logger* m_logger;
                Poco::LogStream* m_logstr;
                Poco::Mutex m_logger_lock;  // to protect m_logstr when multiple threads are running in the same class instance 
                void setLoggerName(const std::string& logger_name)
                {
                        m_logger = &Poco::Logger::get(logger_name);
                        if (m_logstr != NULL)
                        {
                                delete m_logstr;
                        }
                        m_logstr = new Poco::LogStream(*m_logger);
                }
                virtual ~Base() { delete m_logstr; }
                virtual std::string loggingPrefix() const { return ""; }
                void setThisLoggerLevel(int level) { m_logger->setLevel(level); }
                static void setAllLoggerLevel(int level) { Poco::Logger::setLevel(Poco::Logger::ROOT, level); }

        private:
                Base(const Base&) : m_logger(NULL), m_logstr(NULL) {  }
                Base& operator=(const Base&) { return *this; }
        };
}

// Logger
#define LOG_TRACE(__arg) \
        poco_trace(*m_logger, std::string("(") + __func__ + ") " + loggingPrefix() + __arg);

#define LOG_DEBUG(__arg) \
        poco_debug(*m_logger, std::string("(") + __func__ + ") " + loggingPrefix() + __arg);

#define LOG_INFORMATION(__arg) \
        poco_information(*m_logger, std::string("(") + __func__ + ") " + loggingPrefix() + __arg);

#define LOG_NOTICE(__arg) \
        poco_notice(*m_logger, std::string("(") + __func__ + ") " + loggingPrefix() + __arg);

#define LOG_WARNING(__arg) \
        poco_warning(*m_logger, std::string("(") + __func__ + ") " + loggingPrefix() + __arg);

#define LOG_ERROR(__arg) \
        poco_error(*m_logger, std::string("(") + __func__ + ") " + loggingPrefix() + __arg);

#define LOG_CRITICAL(__arg) \
        poco_critical(*m_logger, std::string("(") + __func__ + ") " + loggingPrefix() + __arg);

#define LOG_FATAL(__arg) \
        poco_fatal(*m_logger, std::string("(") + __func__ + ") " + loggingPrefix() + __arg);


// LogStr
#define LOGSTR_TRACE(__arg) \
        if (m_logger->trace()) \
        { \
                Poco::Mutex::ScopedLock lock(m_logger_lock); \
            m_logstr->trace() << "(" << __func__ << ") " << loggingPrefix() << __arg << std::endl; \
        }

#define LOGSTR_DEBUG(__arg) \
        if (m_logger->debug()) \
        { \
                Poco::Mutex::ScopedLock lock(m_logger_lock); \
            m_logstr->debug() << "(" << __func__ << ") " << loggingPrefix() << __arg << std::endl; \
        }

#define LOGSTR_INFORMATION(__arg) \
        if (m_logger->information()) \
        { \
                Poco::Mutex::ScopedLock lock(m_logger_lock); \
            m_logstr->information() << "(" << __func__ << ") " << loggingPrefix() << __arg << std::endl; \
        }

#define LOGSTR_NOTICE(__arg) \
        if (m_logger->notice()) \
        { \
                Poco::Mutex::ScopedLock lock(m_logger_lock); \
            m_logstr->notice() << "(" << __func__ << ") " << loggingPrefix() << __arg << std::endl; \
        }

#define LOGSTR_WARNING(__arg) \
        if (m_logger->warning()) \
        { \
                Poco::Mutex::ScopedLock lock(m_logger_lock); \
            m_logstr->warning() << "(" << __func__ << ") " << loggingPrefix() << __arg << std::endl; \
        }

#define LOGSTR_ERROR(__arg) \
        if (m_logger->error()) \
        { \
                Poco::Mutex::ScopedLock lock(m_logger_lock); \
            m_logstr->error() << "(" << __func__ << ") " << loggingPrefix() << __arg << std::endl; \
        }

#define LOGSTR_CRITICAL(__arg) \
        if (m_logger->critical()) \
        { \
                Poco::Mutex::ScopedLock lock(m_logger_lock); \
            m_logstr->critical() << "(" << __func__ << ") " << loggingPrefix() << __arg << std::endl; \
        }

#define LOGSTR_FATAL(__arg) \
        if (m_logger->fatal()) \
        { \
                Poco::Mutex::ScopedLock lock(m_logger_lock); \
            m_logstr->fatal() << "(" << __func__ << ") " << loggingPrefix() << __arg << std::endl; \
        }

#endif /* ISIS_BASE */