indilogger.h

Go to the documentation of this file.

/*******************************************************************************
  Copyright (C) 2012 Evidence Srl - www.evidence.eu.com
 
 Adapted to INDI Library by Jasem Mutlaq & Geehalel.
 
 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Library General Public
 License version 2 as published by the Free Software Foundation.
 
 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
 Library General Public License for more details.
 
 You should have received a copy of the GNU Library General Public License
 along with this library; see the file COPYING.LIB.  If not, write to
 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 Boston, MA 02110-1301, USA.
*******************************************************************************/
 
#pragma once
 
#include "indiapi.h"
#include "defaultdevice.h"
 
#include <stdarg.h>
#include <fstream>
#include <ostream>
#include <string>
#include <sstream>
#include <sys/time.h>
 
#define DEBUG_CONF(outputFile, configuration, fileVerbosityLevel, screenVerbosityLevel)                       \
    {                                                                                                         \
        Logger::getInstance().configure(outputFile, configuration, fileVerbosityLevel, screenVerbosityLevel); \
    }
 
/*
#define DEBUG(priority, msg) { \
        std::ostringstream __debug_stream__; \
        __debug_stream__ << msg; \
        Logger::getInstance().print(priority, __FILE__, __LINE__, \
                        __debug_stream__.str()); \
        }
*/
#define DEBUG(priority, msg) INDI::Logger::getInstance().print(getDeviceName(), priority, __FILE__, __LINE__, msg)
#define DEBUGF(priority, msg, ...) \
    INDI::Logger::getInstance().print(getDeviceName(), priority, __FILE__, __LINE__, msg, __VA_ARGS__)
 
#define DEBUGDEVICE(device, priority, msg) INDI::Logger::getInstance().print(device, priority, __FILE__, __LINE__, msg)
#define DEBUGFDEVICE(device, priority, msg, ...) \
    INDI::Logger::getInstance().print(device, priority, __FILE__, __LINE__, msg, __VA_ARGS__)
 
#define LOG_ERROR(txt)  DEBUG(INDI::Logger::DBG_ERROR, (txt))
#define LOG_WARN(txt)   DEBUG(INDI::Logger::DBG_WARNING, (txt))
#define LOG_INFO(txt)   DEBUG(INDI::Logger::DBG_SESSION, (txt))
#define LOG_DEBUG(txt)  DEBUG(INDI::Logger::DBG_DEBUG, (txt))
#define LOG_EXTRA1(txt)  DEBUG(INDI::Logger::DBG_EXTRA_1, (txt))
#define LOG_EXTRA2(txt)  DEBUG(INDI::Logger::DBG_EXTRA_2, (txt))
#define LOG_EXTRA3(txt)  DEBUG(INDI::Logger::DBG_EXTRA_3, (txt))
 
#define LOGF_ERROR(fmt, ...) DEBUGF(INDI::Logger::DBG_ERROR, (fmt), __VA_ARGS__)
#define LOGF_WARN(fmt, ...)  DEBUGF(INDI::Logger::DBG_WARNING, (fmt), __VA_ARGS__)
#define LOGF_INFO(fmt, ...)  DEBUGF(INDI::Logger::DBG_SESSION, (fmt), __VA_ARGS__)
#define LOGF_DEBUG(fmt, ...) DEBUGF(INDI::Logger::DBG_DEBUG, (fmt), __VA_ARGS__)
#define LOGF_EXTRA1(fmt, ...) DEBUGF(INDI::Logger::DBG_EXTRA_1, (fmt), __VA_ARGS__)
#define LOGF_EXTRA2(fmt, ...) DEBUGF(INDI::Logger::DBG_EXTRA_2, (fmt), __VA_ARGS__)
#define LOGF_EXTRA3(fmt, ...) DEBUGF(INDI::Logger::DBG_EXTRA_3, (fmt), __VA_ARGS__)
 
 
namespace INDI
{
class Logger
{
        enum loggerConf_
        {
            L_nofile_   = 1 << 0,
            L_file_     = 1 << 1,
            L_noscreen_ = 1 << 2,
            L_screen_   = 1 << 3
        };
 
#ifdef LOGGER_MULTITHREAD
        static pthread_mutex_t lock_;
#endif
 
        bool configured_ { false };
 
        static Logger *m_;
 
        static std::string logFile_;
 
        static std::string logDir_;
 
        static loggerConf_ configuration_;
 
        std::ofstream out_;
        struct timeval initialTime_;
        static unsigned int fileVerbosityLevel_;
        static unsigned int screenVerbosityLevel_;
        static unsigned int rememberscreenlevel_;
 
        Logger();
 
        ~Logger();
 
        inline static void lock();
 
        inline static void unlock();
 
        static INDI::DefaultDevice *parentDevice;
 
    public:
        enum VerbosityLevel
        {
            DBG_IGNORE  = 0x0,
            DBG_ERROR   = 0x1,
            DBG_WARNING = 0x2,
            DBG_SESSION = 0x4,
            DBG_DEBUG   = 0x8,
            DBG_EXTRA_1 = 0x10,
            DBG_EXTRA_2 = 0X20,
            DBG_EXTRA_3 = 0x40,
            DBG_EXTRA_4 = 0x80
        };
 
        struct switchinit
        {
            char name[MAXINDINAME];
            char label[MAXINDILABEL];
            ISState state;
            unsigned int levelmask;
        };
 
        static const unsigned int defaultlevel = DBG_ERROR | DBG_WARNING | DBG_SESSION;
        static const unsigned int nlevels      = 8;
        static struct switchinit LoggingLevelSInit[nlevels];
        static ISwitch LoggingLevelS[nlevels];
        static ISwitchVectorProperty LoggingLevelSP;
        static ISwitch ConfigurationS[2];
        static ISwitchVectorProperty ConfigurationSP;
        typedef loggerConf_ loggerConf;
        static const loggerConf file_on    = L_nofile_;
        static const loggerConf file_off   = L_file_;
        static const loggerConf screen_on  = L_noscreen_;
        static const loggerConf screen_off = L_screen_;
        static unsigned int customLevel;
        static unsigned int nDevices;
 
        static std::string getLogFile()
        {
            return logFile_;
        }
        static loggerConf_ getConfiguration()
        {
            return configuration_;
        }
 
        static Logger &getInstance();
 
        static bool saveConfigItems(FILE *fp);
 
        int addDebugLevel(const char *debugLevelName, const char *LoggingLevelName);
 
        void print(const char *devicename, const unsigned int verbosityLevel, const std::string &sourceFile,
                   const int codeLine,
                   //const std::string&         message,
                   const char *message, ...);
 
        void configure(const std::string &outputFile, const loggerConf configuration, const int fileVerbosityLevel,
                       const int screenVerbosityLevel);
 
        static struct switchinit DebugLevelSInit[nlevels];
        static ISwitch DebugLevelS[nlevels];
        static ISwitchVectorProperty DebugLevelSP;
        static bool ISNewSwitch(const char *dev, const char *name, ISState *states, char *names[], int n);
        static bool initProperties(INDI::DefaultDevice *device);
        static bool updateProperties(bool enable);
        static char Tags[nlevels][MAXINDINAME];
 
        static unsigned int rank(unsigned int l);
};
 
inline Logger::loggerConf operator|(Logger::loggerConf __a, Logger::loggerConf __b)
{
    return Logger::loggerConf(static_cast<int>(__a) | static_cast<int>(__b));
}
 
inline Logger::loggerConf operator&(Logger::loggerConf __a, Logger::loggerConf __b)
{
    return Logger::loggerConf(static_cast<int>(__a) & static_cast<int>(__b));
}
}