cmnLogger.h

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-    */
/* ex: set filetype=cpp softtabstop=4 shiftwidth=4 tabstop=4 cindent expandtab: */
 
/*
  Author(s):  Anton Deguet
  Created on: 2004-08-31
 
  (C) Copyright 2004-2018 Johns Hopkins University (JHU), All Rights Reserved.
 
--- begin cisst license - do not edit ---
 
This software is provided "as is" under an open source license, with
no warranty.  The complete license can be found in license.txt and
http://www.cisst.org/cisst/license.txt.
 
--- end cisst license ---
 
*/
 

#pragma once
 
#ifndef _cmnLogger_h
#define _cmnLogger_h
 
#include <cisstCommon/cmnPortability.h>
#include <cisstCommon/cmnLogLoD.h>
#include <cisstCommon/cmnLODOutputMultiplexer.h>
#include <cisstCommon/cmnMultiplexerStreambuf.h>
#include <cisstCommon/cmnLODMultiplexerStreambuf.h>
 
#include <string>
#include <vector>
#include <fstream>
 
#include <cisstCommon/cmnExport.h>
 
// MJ: some thirdparty drivers on QNX make CMN_LOG macro throw exceptions
// (e.g., std::bad_cast) and the following preprocessor can be used to bypass
// this issue by replacing CMN_LOG with std::cout.
#if (CISST_OS == CISST_QNX)
#define BYPASS_CMN_LOG
#endif
 

#ifdef BYPASS_CMN_LOG
 
  #undef CMN_LOG_CLASS_INSTANCE
  #define CMN_LOG_CLASS_INSTANCE(objectPointer, lod) std::cout
 
#else
 
  #define CMN_LOG_CLASS_INSTANCE(objectPointer, lod)                      \
if (!(cmnLogger::GetMask() & objectPointer->Services()->GetLogMask() & lod)) ; else \
    ((cmnLODOutputMultiplexer(objectPointer->GetLogMultiplexer(), lod).Ref()) << cmnLogLevelToString(lod) << " Class " << objectPointer->Services()->GetName() << ": ")
 
#endif
 
#define CMN_LOG_CLASS(lod) CMN_LOG_CLASS_INSTANCE(this, lod)
 

#define CMN_LOG_CLASS_INSTANCE_INIT_ERROR(objectPointer)   CMN_LOG_CLASS_INSTANCE(objectPointer, CMN_LOG_LEVEL_INIT_ERROR) << CMN_LOG_DETAILS << " "
#define CMN_LOG_CLASS_INSTANCE_INIT_WARNING(objectPointer) CMN_LOG_CLASS_INSTANCE(objectPointer, CMN_LOG_LEVEL_INIT_WARNING)
#define CMN_LOG_CLASS_INSTANCE_INIT_VERBOSE(objectPointer) CMN_LOG_CLASS_INSTANCE(objectPointer, CMN_LOG_LEVEL_INIT_VERBOSE)
#define CMN_LOG_CLASS_INSTANCE_INIT_DEBUG(objectPointer)   CMN_LOG_CLASS_INSTANCE(objectPointer, CMN_LOG_LEVEL_INIT_DEBUG)
#define CMN_LOG_CLASS_INSTANCE_RUN_ERROR(objectPointer)    CMN_LOG_CLASS_INSTANCE(objectPointer, CMN_LOG_LEVEL_RUN_ERROR) << CMN_LOG_DETAILS << " "
#define CMN_LOG_CLASS_INSTANCE_RUN_WARNING(objectPointer)  CMN_LOG_CLASS_INSTANCE(objectPointer, CMN_LOG_LEVEL_RUN_WARNING)
#define CMN_LOG_CLASS_INSTANCE_RUN_VERBOSE(objectPointer)  CMN_LOG_CLASS_INSTANCE(objectPointer, CMN_LOG_LEVEL_RUN_VERBOSE)
#define CMN_LOG_CLASS_INSTANCE_RUN_DEBUG(objectPointer)    CMN_LOG_CLASS_INSTANCE(objectPointer, CMN_LOG_LEVEL_RUN_DEBUG)
 

#define CMN_LOG_CLASS_INIT_ERROR   CMN_LOG_CLASS(CMN_LOG_LEVEL_INIT_ERROR) << CMN_LOG_DETAILS << " "
#define CMN_LOG_CLASS_INIT_WARNING CMN_LOG_CLASS(CMN_LOG_LEVEL_INIT_WARNING)
#define CMN_LOG_CLASS_INIT_VERBOSE CMN_LOG_CLASS(CMN_LOG_LEVEL_INIT_VERBOSE)
#define CMN_LOG_CLASS_INIT_DEBUG   CMN_LOG_CLASS(CMN_LOG_LEVEL_INIT_DEBUG)
#define CMN_LOG_CLASS_RUN_ERROR    CMN_LOG_CLASS(CMN_LOG_LEVEL_RUN_ERROR) << CMN_LOG_DETAILS << " "
#define CMN_LOG_CLASS_RUN_WARNING  CMN_LOG_CLASS(CMN_LOG_LEVEL_RUN_WARNING)
#define CMN_LOG_CLASS_RUN_VERBOSE  CMN_LOG_CLASS(CMN_LOG_LEVEL_RUN_VERBOSE)
#define CMN_LOG_CLASS_RUN_DEBUG    CMN_LOG_CLASS(CMN_LOG_LEVEL_RUN_DEBUG)
 

#ifdef BYPASS_CMN_LOG
 
  #undef CMN_LOG
  #define CMN_LOG(lod) std::cout
 
#else
 
  #define CMN_LOG(lod) \
  if (!(cmnLogger::GetMask() & cmnLogger::GetMaskFunction() & lod)) ; else \
    ((cmnLODOutputMultiplexer(cmnLogger::GetMultiplexer(), lod).Ref()) << cmnLogLevelToString(lod) << " ")
 
#endif

#define CMN_LOG_INIT_ERROR   CMN_LOG(CMN_LOG_LEVEL_INIT_ERROR) << CMN_LOG_DETAILS << " "
#define CMN_LOG_INIT_WARNING CMN_LOG(CMN_LOG_LEVEL_INIT_WARNING)
#define CMN_LOG_INIT_VERBOSE CMN_LOG(CMN_LOG_LEVEL_INIT_VERBOSE)
#define CMN_LOG_INIT_DEBUG   CMN_LOG(CMN_LOG_LEVEL_INIT_DEBUG)
#define CMN_LOG_RUN_ERROR    CMN_LOG(CMN_LOG_LEVEL_RUN_ERROR) << CMN_LOG_DETAILS << " "
#define CMN_LOG_RUN_WARNING  CMN_LOG(CMN_LOG_LEVEL_RUN_WARNING)
#define CMN_LOG_RUN_VERBOSE  CMN_LOG(CMN_LOG_LEVEL_RUN_VERBOSE)
#define CMN_LOG_RUN_DEBUG    CMN_LOG(CMN_LOG_LEVEL_RUN_DEBUG)
 

#define CMN_LOG_DETAILS \
    "File: " << cmnLogger::ExtractFileName(__FILE__) << " Line: " << __LINE__ << " - "
 
 

class CISST_EXPORT cmnLogger {
 
 public:
    typedef cmnLODMultiplexerStreambuf<char> StreamBufType;
 
 private:
    cmnLogMask Mask;

    cmnLogMask FunctionMask;

    StreamBufType LoDMultiplexerStreambuf;

    static std::string DefaultLogFileName;

    static bool InstanceCreated;

    void SetMaskInstance(cmnLogMask mask);

    cmnLogMask GetMaskInstance(void);

    void SetMaskFunctionInstance(cmnLogMask mask);

    cmnLogMask GetMaskFunctionInstance(void);

    StreamBufType * GetMultiplexerInstance(void);

    std::ofstream * DefaultLogFile(const std::string & defaultLogFileName = DefaultLogFileName);

    void HaltDefaultLogInstance(void);

    void ResumeDefaultLogInstance(cmnLogMask newMask);

    void AddChannelInstance(std::ostream & outputStream, cmnLogMask mask);

    void RemoveChannelInstance(std::ostream & outputStream);

    void KillInstance(void);
 
 protected:
    cmnLogger(const std::string & defaultLogFileName = DefaultLogFileName);
 
 public:
    static cmnLogger * Instance(void);
 

    static void SetMask(cmnLogMask mask) {
        Instance()->SetMaskInstance(mask);
    }
 
    static void CISST_DEPRECATED SetLoD(cmnLogMask mask) {
        Instance()->SetMaskInstance(mask);
    }

    static cmnLogMask GetMask(void) {
        return Instance()->GetMaskInstance();
    }
 
    static cmnLogMask CISST_DEPRECATED GetLoD(void) {
        return Instance()->GetMaskInstance();
    }
 

    static void SetMaskFunction(cmnLogMask mask) {
        Instance()->SetMaskFunctionInstance(mask);
    }
 

    static cmnLogMask GetMaskFunction(void) {
        return Instance()->GetMaskFunctionInstance();
    }
 

    static bool SetMaskClass(const std::string & className, cmnLogMask mask);
 

    static bool SetMaskClassAll(cmnLogMask mask);
 

    static bool SetMaskClassMatching(const std::string & stringToMatch, cmnLogMask mask);
 

    static StreamBufType * GetMultiplexer(void) {
        return Instance()->GetMultiplexerInstance();
    }
 

    static void HaltDefaultLog(void) {
        Instance()->HaltDefaultLogInstance();
    }
 

    static void ResumeDefaultLog(cmnLogMask newLoD = CMN_LOG_ALLOW_DEFAULT) {
        Instance()->ResumeDefaultLogInstance(newLoD);
    }
 

    static void SetMaskDefaultLog(cmnLogMask newLoD = CMN_LOG_ALLOW_DEFAULT) {
        Instance()->HaltDefaultLogInstance();
        Instance()->ResumeDefaultLogInstance(newLoD);
    }
 

    static inline void AddChannel(std::ostream & outputStream,
                                  cmnLogMask mask = CMN_LOG_ALLOW_ALL) {
        Instance()->AddChannelInstance(outputStream, mask);
    }
 

    static inline void AddChannelToStdOut(cmnLogMask mask = CMN_LOG_ALLOW_ERRORS_AND_WARNINGS) {
        Instance()->AddChannelInstance(std::cout, mask);
    }

    static inline void AddChannelToStdErr(cmnLogMask mask = CMN_LOG_ALLOW_ERRORS_AND_WARNINGS) {
        Instance()->AddChannelInstance(std::cerr, mask);
    }
 
    static inline void RemoveChannel(std::ostream & outputStream) {
        Instance()->RemoveChannelInstance(outputStream);
    }
 
    static const char * ExtractFileName(const char * file);

    static inline void Kill(void) {
        Instance()->KillInstance();
    }

    static bool SetDefaultLogFileName(const std::string &defaultLogFileName);

    static std::string GetDefaultLogFileName(void) { return DefaultLogFileName; }

    static bool IsCreated() { return InstanceCreated; }
};
 
 
#endif // _cmnLogger_h