mbilog.h

Go to the documentation of this file.

/*============================================================================

The Medical Imaging Interaction Toolkit (MITK)

Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.

Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.

============================================================================*/

#ifndef _MBILOG_H
#define _MBILOG_H

#include <sstream>

#include "mbilogBackendBase.h"
#include "mbilogBackendCout.h"
#include "mbilogConfig.h"
#include "mbilogExports.h"
#include "mbilogLogMessage.h"
#include "mbilogLoggingTypes.h"

namespace mbilog
{
  void MBILOG_EXPORT RegisterBackend(BackendBase *backend);

  void MBILOG_EXPORT UnregisterBackend(BackendBase *backend);

  void MBILOG_EXPORT DistributeToBackends(LogMessage &l);

  void MBILOG_EXPORT EnableBackends(OutputType type);
  void MBILOG_EXPORT DisableBackends(OutputType type);
  bool MBILOG_EXPORT IsBackendEnabled(OutputType type);

  class MBILOG_EXPORT PseudoStream
  {
  protected:
    bool disabled;
    LogMessage msg;
    std::stringstream ss;

  public:
    inline PseudoStream(int level, const char *filePath, int lineNumber, const char *functionName)
      : disabled(false), msg(LogMessage(level, filePath, lineNumber, functionName)), ss(std::stringstream::out)
    {
    }

    inline ~PseudoStream()
    {
      if (!disabled)
      {
        msg.message = ss.str();
        msg.moduleName = MBILOG_MODULENAME;
        DistributeToBackends(msg);
      }
    }

    template <class T>
    inline PseudoStream &operator<<(const T &data)
    {
      if (!disabled)
      {
        std::locale C("C");
        std::locale originalLocale = ss.getloc();
        ss.imbue(C);

        ss << data;

        ss.imbue(originalLocale);
      }
      return *this;
    }

    template <class T>
    inline PseudoStream &operator<<(T &data)
    {
      if (!disabled)
      {
        std::locale C("C");
        std::locale originalLocale = ss.getloc();
        ss.imbue(C);

        ss << data;

        ss.imbue(originalLocale);
      }
      return *this;
    }

    inline PseudoStream &operator<<(std::ostream &(*func)(std::ostream &))
    {
      if (!disabled)
      {
        std::locale C("C");
        std::locale originalLocale = ss.getloc();
        ss.imbue(C);

        ss << func;

        ss.imbue(originalLocale);
      }
      return *this;
    }

    inline PseudoStream &operator()(const char *category)
    {
      if (!disabled)
      {
        if (msg.category.length())
          msg.category += ".";
        msg.category += category;
      }
      return *this;
    }

    inline PseudoStream &operator()(bool enabled)
    {
      disabled |= !enabled;
      return *this;
    }
  };

  class MBILOG_EXPORT NullStream
  {
  public:
    template <class T>
    inline NullStream &operator<<(const T & /*data*/)
    {
      return *this;
    }
    template <class T>
    inline NullStream &operator<<(T & /*data*/)
    {
      return *this;
    }
    inline NullStream &operator<<(std::ostream &(*)(std::ostream &)) { return *this; }
    inline NullStream &operator()(const char *) { return *this; }
    inline NullStream &operator()(bool) { return *this; }
  };

  //  /** \brief templated backend: one can define a class and a method to create a new backend. */
  //  template<typename T>
  //  struct DelegateBackend : public BackendBase
  //  {
  //
  //    typedef void(T::*Callback)(const mbilog::LogMessage&);
  //
  //    DelegateBackend(T* obj, Callback callback) : m_Obj(obj), m_Callback(callback)
  //    {
  //    }
  //
  //    void ProcessMessage(const mbilog::LogMessage& msg)
  //    {
  //      m_Obj->*m_Callback(msg);
  //    }
  //
  //  private:
  //
  //    T* m_Obj;
  //    Callback m_Callback;
  //  };
}

#define MBI_INFO mbilog::PseudoStream(mbilog::Info, __FILE__, __LINE__, __FUNCTION__)
#define MBI_WARN mbilog::PseudoStream(mbilog::Warn, __FILE__, __LINE__, __FUNCTION__)
#define MBI_ERROR mbilog::PseudoStream(mbilog::Error, __FILE__, __LINE__, __FUNCTION__)
#define MBI_FATAL mbilog::PseudoStream(mbilog::Fatal, __FILE__, __LINE__, __FUNCTION__)

#ifdef MBILOG_ENABLE_DEBUG
#define MBI_DEBUG mbilog::PseudoStream(mbilog::Debug, __FILE__, __LINE__, __FUNCTION__)
#else
#define MBI_DEBUG true ? mbilog::NullStream() : mbilog::NullStream() // this is magic by markus
#endif

#endif