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-2015 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) \
    ((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) \
    ((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;

    void SetMaskInstance(cmnLogMask mask);

    cmnLogMask GetMaskInstance(void);

    void SetMaskFunctionInstance(cmnLogMask mask);

    cmnLogMask GetMaskFunctionInstance(void);

    StreamBufType * GetMultiplexerInstance(void);

    std::ofstream * DefaultLogFile(const std::string & defaultLogFileName = "cisstLog.txt");

    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 = "cisstLog.txt");

 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();
    }

};


#endif // _cmnLogger_h