loggers.h

Go to the documentation of this file.

/* This file is part of the Tomographer project, which is distributed under the
 * terms of the MIT license.
 *
 * The MIT License (MIT)
 *
 * Copyright (c) 2015 ETH Zurich, Institute for Theoretical Physics, Philippe Faist
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

#ifndef TOMOGRAPHER_TOOLS_LOGGERS_H
#define TOMOGRAPHER_TOOLS_LOGGERS_H

#include <cstdio>
#include <cstdarg>

#include <string>
#include <sstream> // std::stringstream
#include <iostream>
#include <functional> // std::function
#include <type_traits> // std::enable_if
#include <map>

#include <boost/algorithm/string.hpp> // to_upper()

#include <tomographer2/tools/fmt.h>
#include <tomographer2/tools/conststr.h>


#ifndef TOMOGRAPHER_PARSED_BY_DOXYGEN

#define ENABLE_IF_Fn_CALLABLE_OSTREAM                                      \
  typename std::enable_if<std::is_convertible<Fn,std::function<void(std::ostream&)> >::value, void>::type

#endif


namespace Tomographer
{

namespace Logger
{

enum LogLevelCode
{
  ERROR = 0,

  WARNING,

  INFO,

  DEBUG,

  LONGDEBUG,


  HIGHEST_SEVERITY_LEVEL = 0,

  LOWEST_SEVERITY_LEVEL = 0x7fffffff
};



class LogLevel
{
  int _level;
public:
  LogLevel(int level_ = INFO) { setLevel(level_); }
  LogLevel(const char * s) { setLevel(s); }
  LogLevel(const std::string& s) { setLevel(s); }

  inline int level() const { return _level; }

  inline operator int() const { return _level; }

  inline std::string levelName() const
  {
    switch (_level) {
    case LONGDEBUG: return std::string("LONGDEBUG");
    case DEBUG:     return std::string("DEBUG");
    case INFO:      return std::string("INFO");
    case WARNING:   return std::string("WARNING");
    case ERROR:     return std::string("ERROR");
    default: return std::string("<INVALID LEVEL>");
    };
  }

  inline void setLevel(int level)
  {
    if (level != LONGDEBUG &&
        level != DEBUG &&
        level != INFO &&
        level != WARNING &&
        level != ERROR) {
      throw std::invalid_argument("Invalid level code: "+std::to_string(level));
    }
    _level = level;
  }

  inline void setLevel(std::string s)
  {
    // NOT const string `s`! we need our copy for to_upper():
    boost::to_upper(s);
    if (s == "LONGDEBUG") {
      _level = LONGDEBUG;
    } else if (s == "DEBUG") {
      _level = DEBUG;
    } else if (s == "INFO") {
      _level = INFO;
    } else if (s == "WARNING") {
      _level = WARNING;
    } else if (s == "ERROR") {
      _level = ERROR;
    } else {
      throw std::invalid_argument("Invalid log level: '"+s+"'");
    }
  }
};

inline std::istream & operator>>(std::istream & str, LogLevel &l)
{
  std::string s;
  str >> s;
  l.setLevel(s);
  return str;
}
inline std::ostream & operator<<(std::ostream & str, const LogLevel &l)
{
  return str << l.levelName();
}



inline bool isAtLeastOfSeverity(int level, int baselevel)
{
  return (level <= baselevel);
}

template<int Level, int BaseLevel>
struct StaticIsAtLeastOfSeverity {
  enum {
    value = (Level <= BaseLevel)
  };
};


struct DefaultLoggerTraits
{
  enum {
    IsThreadSafe = 0,

    StaticMinimumSeverityLevel = LOWEST_SEVERITY_LEVEL,

    HasOwnGetLevel = 0,

    HasFilterByOrigin = 0
  };
};

template<typename LoggerType>
struct LoggerTraits
{
  // by default, contains nothing and will produce errors if used unspecialized.
};



namespace tomo_internal {
template<bool hasOwnGetLevel>
class LoggerRuntimeLevel {
public:
  LoggerRuntimeLevel(int level)
    : _level(level)
  {
  }

  inline int level() const
  {
    return _level;
  }

protected:
  inline void setLogLevel(int level)
  {
    _level = level;
  }
  
private:
  int _level;
};
//
// Specialization for those classes which provide their own level() method. Do nothing.
//
template<>
class LoggerRuntimeLevel<true> {
public:
  LoggerRuntimeLevel(int /*level*/)
  {
  }

  inline void setLogLevel(int) {
    tomographer_assert(0 && "Call to LoggerRuntimeLevel::setLogLevel() for Logger which defines HasOwnGetLevel=1!");
  }
};
}


template<typename Derived>
class LoggerBase
#ifndef TOMOGRAPHER_PARSED_BY_DOXYGEN
  : public tomo_internal::LoggerRuntimeLevel<LoggerTraits<Derived>::HasOwnGetLevel>
#endif
{
public:
  enum {
    IsThreadSafe = LoggerTraits<Derived>::IsThreadSafe,
    StaticMinimumSeverityLevel = LoggerTraits<Derived>::StaticMinimumSeverityLevel,
    HasOwnGetLevel = LoggerTraits<Derived>::HasOwnGetLevel,
    HasFilterByOrigin = LoggerTraits<Derived>::HasFilterByOrigin
  };

  LoggerBase(int level_ = INFO)
    : tomo_internal::LoggerRuntimeLevel<HasOwnGetLevel>(level_)
  {
  }

  PRINTF3_ARGS_SAFE
  inline void error(const char * origin, const char * fmt, ...);
  inline void error(const char * origin, const std::string & msg);
  template<typename Fn>
  inline ENABLE_IF_Fn_CALLABLE_OSTREAM
  error(const char * origin, Fn f);

  PRINTF3_ARGS_SAFE
  inline void warning(const char * origin, const char * fmt, ...);
  inline void warning(const char * origin, const std::string & msg);
  template<typename Fn>
  inline ENABLE_IF_Fn_CALLABLE_OSTREAM
  warning(const char * origin, Fn f);

  PRINTF3_ARGS_SAFE
  inline void info(const char * origin, const char * fmt, ...);
  inline void info(const char * origin, const std::string & msg);
  template<typename Fn>
  inline ENABLE_IF_Fn_CALLABLE_OSTREAM
  info(const char * origin, Fn f);

  PRINTF3_ARGS_SAFE
  inline void debug(const char * origin, const char * fmt, ...);

  inline void debug(const char * origin, const std::string & msg);
  template<typename Fn>
  inline ENABLE_IF_Fn_CALLABLE_OSTREAM
  debug(const char * origin, Fn f);

  PRINTF3_ARGS_SAFE
  inline void longdebug(const char * origin, const char * fmt, ...);
  inline void longdebug(const char * origin, const std::string & msg);
  template<typename Fn>
  inline ENABLE_IF_Fn_CALLABLE_OSTREAM
  longdebug(const char * origin, Fn f);


  PRINTF4_ARGS_SAFE
  inline void log(int level, const char * origin, const char * fmt, ...);
  inline void log(int level, const char * origin, const std::string & msg);
  template<typename Fn>
  inline ENABLE_IF_Fn_CALLABLE_OSTREAM
  log(int level, const char * origin, Fn f);



  template<int Level>
  PRINTF3_ARGS_SAFE
  inline void log(const char * origin, const char * fmt, ...);
  template<int Level>
  inline void log(const char * origin, const char * fmt, va_list ap);
  template<int Level>
  inline void log(const char * origin, const std::string & msg);
  template<int Level, typename Fn>
  inline ENABLE_IF_Fn_CALLABLE_OSTREAM
  log(const char * origin, Fn f);


  static inline bool staticallyEnabledFor(int level)
  {
    return ( isAtLeastOfSeverity(level, StaticMinimumSeverityLevel) );
  }

  template<int Level>
  static inline bool staticallyEnabledFor()
  {
    return ( StaticIsAtLeastOfSeverity<
                  Level,
                  StaticMinimumSeverityLevel
                  >::value ) ;
  }

  inline bool enabledFor(int level_) const
  {
    return derived()->staticallyEnabledFor(level_) &&
      isAtLeastOfSeverity(level_, getLevel());
  };

#ifdef TOMOGRAPHER_PARSED_BY_DOXYGEN
  // this method is actually implemented by the base class LoggerRuntimeLevel, and is only
  // exposed in the case where the logger doesn't define its own method. This is important
  // to avoid "ambiguous calls to `level()`".

  inline int level() const
  {
  }
#endif
  

protected:

  // version in case we store our own level
  TOMOGRAPHER_ENABLED_IF(!HasOwnGetLevel)
  inline int getLevel() const
  {
    // use base class' implementation
    return tomo_internal::LoggerRuntimeLevel<HasOwnGetLevel>::level();
  }
  // version in case we delegate to derived class' level()
  TOMOGRAPHER_ENABLED_IF(HasOwnGetLevel)
  inline int getLevel() const
  {
    return derived()->level();
  }


  inline Derived * derived()
  {
    return static_cast<Derived*>(this);
  }
  inline const Derived * derived() const
  {
    return static_cast<const Derived*>(this);
  }

#ifdef TOMOGRAPHER_PARSED_BY_DOXYGEN
  // this method is actually implemented by the base class LoggerRuntimeLevel, and is only
  // exposed in the case where the logger can actually set a new level.

  inline void setLogLevel(int level)
  {
  }
#endif

private:
};


namespace tomo_internal {
  template<typename Derived, bool derivedHasFilterByOrigin>
  struct LoggerBaseHelperFilterByOrigin {
    static inline bool test_logger_filter(LoggerBase<Derived> * /*loggerbase*/, int /*level*/,
                                          const char * /*origin*/)
    {
      // do nothing by default
      return true;
    }
  };
  //
  // specialization for loggers with filtering by origin
  //
  template<typename Derived>
  struct LoggerBaseHelperFilterByOrigin<Derived, true> {
    static inline bool test_logger_filter(LoggerBase<Derived> * loggerbase, int level,
                                          const char * origin)
    {
      return static_cast<const Derived*>(loggerbase)->filterByOrigin(level, origin);
    }
  };
  template<typename Derived>
  struct LoggerBaseHelperDynamic {
    static inline void call_emit_log(LoggerBase<Derived> * loggerbase, int level, const char * origin,
                                     const std::string & msg) throw()
    {
      try {
        //printf("Calling emit_log(%d,\"%s\",\"%s\") on object %p\n", level, origin, msg.c_str(), loggerbase);
        static_cast<Derived*>(loggerbase)->emitLog(level, origin, msg);
      } catch (const std::exception & e) {
        std::fprintf(stderr,
                     "Warning in LoggerBaseHelperDynamic::call_emit_log(%d, \"%s\", msg):"
                     " Exception caught: %s\n",
                     level, origin, e.what());
      }
    }
    static inline bool test_should_emit(LoggerBase<Derived> * loggerbase, int level, const char * origin)
    {
      if ( ! static_cast<const Derived*>(loggerbase)->enabledFor(level) ) {
        return false;
      }
      if ( ! LoggerBaseHelperFilterByOrigin<Derived, LoggerTraits<Derived>::HasFilterByOrigin>
           ::test_logger_filter(loggerbase, level, origin) ) {
        return false;
      }
      return true;
    }

    static inline void test_and_call_emit_log(LoggerBase<Derived> * loggerbase, int level, const char * origin,
                                              const std::string & msg) throw()
    {
      if ( ! test_should_emit(loggerbase, level, origin) ) {
        return;
      }

      call_emit_log(loggerbase, level, origin, msg);
    }
    static inline void test_and_call_emit_log(LoggerBase<Derived> * loggerbase, int level, const char * origin,
                                              const char * fmt, va_list ap) throw()
    {
      if ( ! test_should_emit(loggerbase, level, origin) ) {
        return;
      }

      try {
        const std::string msg = Tools::vfmts(fmt, ap);
        call_emit_log(loggerbase, level, origin, msg);
      } catch (const std::exception & e) {
        std::fprintf(stderr,
                     "Warning in LoggerBase::test_and_call_emit_log(%d, \"%s\", \"%s\", ...):"
                     " Exception caught for vfmts(): %s\n",
                     level, origin, fmt, e.what());
      }
    }
    template<typename Fn>
    static inline
    ENABLE_IF_Fn_CALLABLE_OSTREAM
    test_and_call_emit_log(LoggerBase<Derived> * loggerbase, int level, const char * origin, Fn f) throw()
    {
      if ( ! test_should_emit(loggerbase, level, origin) ) {
        return;
      }

      try {
        std::ostringstream sstr;
        f(sstr);
        call_emit_log(loggerbase, level, origin, sstr.str());
      } catch (const std::exception & e) {
        std::fprintf(stderr, "Warning in LoggerBase::test_and_call_emit_log(%d, \"%s\", f(ostream)):"
                     " Exception caught: %s\n",
                     level, origin, e.what());
      }
    }
  };

  template<typename Derived, int Level, bool isStaticallyDiscarded = false>
  struct LoggerBaseHelperStatic2 {
    template<typename... Args>
    static inline void test_and_call_emit_log(LoggerBase<Derived> * loggerbase, const char * origin,
                                              Args... args) throw()
    {
      LoggerBaseHelperDynamic<Derived>::test_and_call_emit_log(loggerbase, Level, origin, args...);
    }
  };
  // specialization for calls where the message should be statically discarded
  template<typename Derived, int Level>
  struct LoggerBaseHelperStatic2<Derived, Level, true> {
    template<typename... Args>
    static inline void test_and_call_emit_log(LoggerBase<Derived> *, const char *, Args...) throw()
    {
      // discard logging message.
    }
  };

  template<typename Derived, int Level>
  struct LoggerBaseHelperStatic {
    template<typename... Args>
    static inline void test_and_call_emit_log(LoggerBase<Derived> * loggerbase, const char * origin,
                                              Args... args) throw()
    {
      // call the default or specialized version of our second helper, which will either
      // relay the call the dynamic version or discard the message.
      //std::fprintf(stderr,
      //        "LoggerBaseHelperStatic<Derived,Level=%d>::test_and_call_emit_log(...). StaticMinimumSeverityLevel=%d\n",
      //        (int)Level, (int)(LoggerTraits<Derived>::StaticMinimumSeverityLevel));
      LoggerBaseHelperStatic2<
        Derived, Level,
        ! StaticIsAtLeastOfSeverity<Level, LoggerTraits<Derived>::StaticMinimumSeverityLevel>::value
        >::test_and_call_emit_log(
            loggerbase, origin, args...
            );
    }
  };
  

} // namespace tomo_internal


template<typename Derived>
inline void LoggerBase<Derived>::error(const char * origin, const char * fmt, ...)
{
  va_list ap;
  va_start(ap, fmt);
  derived()->template log<ERROR>(origin, fmt, ap);
  va_end(ap);
}

template<typename Derived>
inline void LoggerBase<Derived>::error(const char * origin, const std::string & msg)
{
  derived()->template log<ERROR>(origin, msg);
}

template<typename Derived>
template<typename Fn>
inline ENABLE_IF_Fn_CALLABLE_OSTREAM
LoggerBase<Derived>::error(const char * origin, Fn f)
{
  derived()->template log<ERROR>(origin, f);
}


template<typename Derived>
inline void LoggerBase<Derived>::warning(const char * origin, const char * fmt, ...)
{
  va_list ap;
  va_start(ap, fmt);
  derived()->template log<WARNING>(origin, fmt, ap);
  va_end(ap);
}

template<typename Derived>
inline void LoggerBase<Derived>::warning(const char * origin, const std::string & msg)
{
  derived()->template log<WARNING>(origin, msg);
}

template<typename Derived>
template<typename Fn>
inline ENABLE_IF_Fn_CALLABLE_OSTREAM
LoggerBase<Derived>::warning(const char * origin, Fn f)
{
  derived()->template log<WARNING>(origin, f);
}

template<typename Derived>
inline void LoggerBase<Derived>::info(const char * origin, const char * fmt, ...)
{
  va_list ap;
  va_start(ap, fmt);
  derived()->template log<INFO>(origin, fmt, ap);
  va_end(ap);
}

template<typename Derived>
inline void LoggerBase<Derived>::info(const char * origin, const std::string & msg)
{
  derived()->template log<INFO>(origin, msg);
}

template<typename Derived>
template<typename Fn>
inline ENABLE_IF_Fn_CALLABLE_OSTREAM
LoggerBase<Derived>::info(const char * origin, Fn f)
{
  derived()->template log<INFO>(origin, f);
}

template<typename Derived>
inline void LoggerBase<Derived>::debug(const char * origin, const char * fmt, ...)
{
  va_list ap;
  va_start(ap, fmt);
  derived()->template log<DEBUG>(origin, fmt, ap);
  va_end(ap);
}

template<typename Derived>
inline void LoggerBase<Derived>::debug(const char * origin, const std::string & msg)
{
  derived()->template log<DEBUG>(origin, msg);
}

template<typename Derived>
template<typename Fn>
inline ENABLE_IF_Fn_CALLABLE_OSTREAM
LoggerBase<Derived>::debug(const char * origin, Fn f)
{
  derived()->template log<DEBUG>(origin, f);
}

template<typename Derived>
inline void LoggerBase<Derived>::longdebug(const char * origin, const char * fmt, ...)
{
  va_list ap;
  va_start(ap, fmt);
  derived()->template log<LONGDEBUG>(origin, fmt, ap);
  va_end(ap);
}

template<typename Derived>
inline void LoggerBase<Derived>::longdebug(const char * origin, const std::string & msg)
{
  derived()->template log<LONGDEBUG>(origin, msg);
}

template<typename Derived>
template<typename Fn>
inline ENABLE_IF_Fn_CALLABLE_OSTREAM
LoggerBase<Derived>::longdebug(const char * origin, Fn f)
{
  derived()->template log<LONGDEBUG>(origin, f);
}


template<typename Derived>
inline void LoggerBase<Derived>::log(int level, const char * origin, const char * fmt, ...)
{
  va_list ap;
  va_start(ap, fmt);
  tomo_internal::LoggerBaseHelperDynamic<Derived>::test_and_call_emit_log(this, level, origin, fmt, ap);
  va_end(ap);
}

template<typename Derived>
inline void LoggerBase<Derived>::log(int level, const char * origin, const std::string & msg)
{
  tomo_internal::LoggerBaseHelperDynamic<Derived>::test_and_call_emit_log(this, level, origin, msg);
}

template<typename Derived>
template<typename Fn>
inline ENABLE_IF_Fn_CALLABLE_OSTREAM
LoggerBase<Derived>::log(int level, const char * origin, Fn f)
{
  tomo_internal::LoggerBaseHelperDynamic<Derived>::test_and_call_emit_log(this, level, origin, f);
}


template<typename Derived>
template<int Level>
inline void LoggerBase<Derived>::log(const char * origin, const char * fmt, ...)
{
  va_list ap;
  va_start(ap, fmt);
  tomo_internal::LoggerBaseHelperStatic<Derived, Level>::test_and_call_emit_log(this, origin, fmt, ap);
  va_end(ap);
}

template<typename Derived>
template<int Level>
inline void LoggerBase<Derived>::log(const char * origin, const char * fmt, va_list ap)
{
  tomo_internal::LoggerBaseHelperStatic<Derived, Level>::test_and_call_emit_log(this, origin, fmt, ap);
}

template<typename Derived>
template<int Level>
inline void LoggerBase<Derived>::log(const char * origin, const std::string & msg)
{
  tomo_internal::LoggerBaseHelperStatic<Derived, Level>::test_and_call_emit_log(this, origin, msg);
}

template<typename Derived>
template<int Level, typename Fn>
inline ENABLE_IF_Fn_CALLABLE_OSTREAM
LoggerBase<Derived>::log(const char * origin, Fn f)
{
  tomo_internal::LoggerBaseHelperStatic<Derived, Level>::test_and_call_emit_log(this, origin, f);
}




class FileLogger;
template<>
struct LoggerTraits<FileLogger> : public DefaultLoggerTraits
{
  enum {
    IsThreadSafe = 1 
  };
};

class FileLogger : public LoggerBase<FileLogger>
{
public:
  FileLogger(FILE * fp_, int level = INFO, bool display_origin_ = true)
    : LoggerBase<FileLogger>(level), fp(fp_), display_origin(display_origin_)
  {
  }

  inline void setFp(FILE * fp_)
  {
    fp = fp_;
  }

  inline void setLevel(int level)
  {
    setLogLevel(level);
  }

  inline void setDisplayOrigin(bool display_origin_)
  {
    display_origin = display_origin_;
  }

  inline void emitLog(int level, const char * origin, const std::string & msg)
  {
    static const std::string level_prefixes[] = {
      std::string("\n\n*** ERROR -- "),
      std::string("\n*** Warning: ")
    };

    std::string finalmsg = (
        ( (level >= 0 && level < (int)std::extent<decltype(level_prefixes)>::value)
          ? level_prefixes[level] : std::string() )
        + ((display_origin && origin && origin[0]) ? "["+std::string(origin)+"] " : std::string())
        + msg
        );

    // display the log message
    std::fprintf(fp, "%s\n", finalmsg.c_str());

    if (isAtLeastOfSeverity(level, WARNING)) {
      // force output also on stderr for warnings and errors if we are being redirected to a
      // file, or at least flush the buffer.
      std::fflush(fp);
      if (fp != stdout && fp != stderr) {
        std::fprintf(stderr, "%s\n", finalmsg.c_str());
      }
    }
  }

private:
  std::FILE * fp;
  bool display_origin;
};





class VacuumLogger;
template<>
struct LoggerTraits<VacuumLogger> : public DefaultLoggerTraits
{
  enum {
    IsThreadSafe = 1, 
    StaticMinimumSeverityLevel = -1 
  };
};

class VacuumLogger : public LoggerBase<VacuumLogger>
{
public:
  inline void emitLog(int /*level*/, const char * /*origin*/, const std::string & /*msg*/)
  {
  }

};

static VacuumLogger vacuum_logger;




class BufferLogger;
template<>
struct LoggerTraits<BufferLogger> : public DefaultLoggerTraits
{
  enum {
    IsThreadSafe = 0 
  };
};

class BufferLogger : public LoggerBase<BufferLogger>
{
  std::ostringstream buffer;
public:
  BufferLogger(int level)
    : LoggerBase<BufferLogger>(level)
  {
  }

  inline void emitLog(int /*level*/, const char * origin, const std::string& msg)
  {
    buffer << (origin&&origin[0] ? "["+std::string(origin)+"] " : std::string())
           << msg.c_str() << "\n";
  }

  inline void setLevel(int level)
  {
    setLogLevel(level);
  }

  inline void clear()
  {
    buffer.clear();
    buffer.str(std::string());
  }

  inline std::string getContents() const
  {
    return buffer.str();
  }
};




template<typename, int> class MinimumSeverityLogger;
template<typename BaseLogger, int Level>
struct LoggerTraits<MinimumSeverityLogger<BaseLogger,Level> > : public LoggerTraits<BaseLogger>
{
  enum {

    StaticMinimumSeverityLevel = Level,

    HasOwnGetLevel = 1

    // Note: filter by origin flag is inherited from base logger.
  };
};

template<typename BaseLogger, int Level>
class MinimumSeverityLogger : public LoggerBase<MinimumSeverityLogger<BaseLogger,Level> >
{
  BaseLogger & baselogger;
public:
  MinimumSeverityLogger(BaseLogger & baselogger_)
    : LoggerBase<MinimumSeverityLogger<BaseLogger,Level> >(), baselogger(baselogger_)
  {
  }

  inline void emitLog(int level, const char * origin, const std::string& msg)
  {
    baselogger.emitLog(level, origin, msg);
  }

  inline int level() const
  {
    return baselogger.level();
  }

  template<bool dummy = true>
  inline std::enable_if<dummy && LoggerTraits<BaseLogger>::HasFilterByOrigin, bool>
  filterByOrigin(int level, const char * origin)
  {
    return baselogger.filterByOrigin(level, origin);
  }
};


namespace tomo_internal {

inline int matched_length(const std::string & s, const std::string & pattern)
{
  std::size_t k = 0;
  while (s[k] == pattern[k]) {
    ++k;
  }
  return k;
}

} // namespace tomo_internal

template<typename BaseLogger> class OriginFilteredLogger;
template<typename BaseLogger>
struct LoggerTraits<OriginFilteredLogger<BaseLogger> > : public LoggerTraits<BaseLogger>
{
  enum {
    HasOwnGetLevel = 1, 
    HasFilterByOrigin = 1 
  };
};

template<typename BaseLogger>
class OriginFilteredLogger : public Tomographer::Logger::LoggerBase<OriginFilteredLogger<BaseLogger> >
{
  BaseLogger & baselogger;

  std::map<std::string,int> levels_set;
public:

  OriginFilteredLogger(BaseLogger & baselogger_)
    : Tomographer::Logger::LoggerBase<OriginFilteredLogger<BaseLogger> >(),
      baselogger(baselogger_),
      levels_set()
  {
  }

  inline void setDomainLevel(const std::string& origin_pattern, int level)
  {
    levels_set[origin_pattern] = level;
  }

  inline void removeDomainSetting(const std::string& s)
  {
    auto it = levels_set.find(s);
    if (it == levels_set.end()) {
      this->warning("OriginFilteredLogger<BaseLogger>::removeDomainSetting", "domain not set: `%s'", s.c_str());
      return;
    }
    levels_set.erase(it);
  }

  inline int level() const
  {
    return LOWEST_SEVERITY_LEVEL;
  }

  inline void emitLog(int level, const char * origin, const std::string& msg)
  {
    baselogger.emitLog(level, origin, msg);
  }

  inline bool filterByOrigin(int level, const char * origin) const
  {
    typedef std::map<std::string, int>::const_iterator ConstIterator;

    std::string s(origin);

    int loglevel = -1;
    int last_matched_length = 0;
    for (ConstIterator it = levels_set.begin(); it != levels_set.end(); ++it) {
      const int mlen = tomo_internal::matched_length((*it).first, s);
      if (mlen > last_matched_length) {
        loglevel = (*it).second;
        last_matched_length = mlen;
      }
    }
    if (loglevel == -1) {
      // default logger level
      loglevel = baselogger.level();
    }
    return isAtLeastOfSeverity(level, loglevel);
  }

};





// --------------------------------------------------





struct LocalLoggerOriginSpec {
  const Tools::conststr origin_prefix;
  const Tools::conststr origin_prefix_add;
  const Tools::conststr glue;

  constexpr LocalLoggerOriginSpec(const Tools::conststr& s, const Tools::conststr& gl)
    : origin_prefix(s), origin_prefix_add(""), glue(gl) { }
  constexpr LocalLoggerOriginSpec(const Tools::conststr& s, const Tools::conststr& s2, const Tools::conststr& gl)
    : origin_prefix(s), origin_prefix_add(s2), glue(gl) { }
};

namespace tomo_internal {
struct extractTomoOrigin_helper {
  static inline constexpr LocalLoggerOriginSpec step2(const Tools::conststr fn, std::size_t last_doublecolons,
                                                         std::size_t after_prelast_doublecolons)
  {
    return ( fn.substr_e(after_prelast_doublecolons, last_doublecolons) == fn.substr(last_doublecolons+2)
             // fn is a constructor, so keep class name and use "::" as glue
             ? LocalLoggerOriginSpec(fn.substr(last_doublecolons+2), "::")
             // looks like a method name. Strip off the class name. Also use an internal
             // glue to indicate a logical level.
             : LocalLoggerOriginSpec(fn.substr(last_doublecolons+2), "()", "/")
        );
  }
  static inline constexpr std::size_t afterprelast_doublecolons(std::size_t prelast_doublecolons_found)
  {
    return (prelast_doublecolons_found == std::string::npos) ? 0 : prelast_doublecolons_found+2;
  }
  static inline constexpr LocalLoggerOriginSpec step1(const Tools::conststr fn, std::size_t last_doublecolons)
  {
    return last_doublecolons == std::string::npos || last_doublecolons == 0
      ? LocalLoggerOriginSpec(fn, "()", "/") // looks like simple function name with no parent scope
      : step2(fn, last_doublecolons, afterprelast_doublecolons(fn.rfind("::", last_doublecolons-1)));
  }

  static inline constexpr LocalLoggerOriginSpec extract_from_func_name(const Tools::conststr fn)
  {
    return step1(fn, fn.rfind("::"));
  }
};

constexpr const LocalLoggerOriginSpec extractTomoOrigin(const Tools::conststr fn)
{
  return extractTomoOrigin_helper::extract_from_func_name(Tomographer::Tools::extractFuncName(fn));
}

} // namespace tomo_internal


#define TOMO_ORIGIN Tomographer::Logger::tomo_internal::extractTomoOrigin(TOMO_FUNCTION)




template<typename BaseLoggerType_>  class LocalLogger;


namespace tomo_internal {
template<typename BaseLoggerType>
struct is_local_logger {
  enum { value = 0 };
};
template<typename BaseLoggerType>
struct is_local_logger<LocalLogger<BaseLoggerType> > {
  enum { value = 1 };
};
template<typename BaseLoggerType>
struct local_logger_parent {
  typedef BaseLoggerType ParentType;
};
template<typename BaseLoggerType>
struct local_logger_parent<LocalLogger<BaseLoggerType> > {
  typedef typename local_logger_parent<BaseLoggerType>::ParentType ParentType;
};
} // namespace tomo_internal

template<typename BaseLoggerType_>
struct LoggerTraits<LocalLogger<BaseLoggerType_> > : public LoggerTraits<BaseLoggerType_>
{
  enum {
    HasOwnGetLevel = 1
  };
};


template<typename BaseLoggerType_>
class LocalLogger : public Tomographer::Logger::LoggerBase<LocalLogger<BaseLoggerType_> >
{
public:
  typedef BaseLoggerType_ BaseLoggerType;

private:
  typedef Tomographer::Logger::LoggerBase<LocalLogger> Base_;

  const std::string _origin_prefix;
  const std::string _glue;

  BaseLoggerType & _baselogger;

public:
  LocalLogger(const std::string & origin_fn_name, BaseLoggerType & logger_)
    : _origin_prefix(origin_fn_name), _glue("::"), _baselogger(logger_)
  {
  }
  LocalLogger(const std::string & origin_prefix, const std::string & glue, BaseLoggerType & logger_)
    : _origin_prefix(origin_prefix), _glue(glue), _baselogger(logger_)
  {
  }
  LocalLogger(const LocalLoggerOriginSpec & spec, BaseLoggerType & logger_)
    : _origin_prefix(spec.origin_prefix.to_string()+spec.origin_prefix_add.to_string()),
      _glue(spec.glue.to_string()), _baselogger(logger_)
  {
  }

  LocalLogger(LocalLogger && movecopy)
    : _origin_prefix(movecopy._origin_prefix), _glue(movecopy._glue),
      _baselogger(movecopy._baselogger)
  {
  }
  LocalLogger(const LocalLogger & other) = delete;

  inline std::string originPrefix() const { return _origin_prefix; }

  inline std::string glue() const { return _glue; }

  inline BaseLoggerType & baseLogger() { return _baselogger; }

#ifdef TOMOGRAPHER_PARSED_BY_DOXYGEN

  typedef _PARENT_LOGGER_TYPE  ParentLoggerType;

  ParentLoggerType & parentLogger() { }
#else

  typedef typename tomo_internal::local_logger_parent<BaseLoggerType>::ParentType  ParentLoggerType;

  TOMOGRAPHER_ENABLED_IF(!tomo_internal::is_local_logger<BaseLoggerType>::value)
  inline ParentLoggerType & parentLogger()
  {
    return baseLogger();
  }
  TOMOGRAPHER_ENABLED_IF(tomo_internal::is_local_logger<BaseLoggerType>::value)
  inline ParentLoggerType & parentLogger() {
    return baseLogger().parentLogger();
  }
#endif

  inline LocalLogger<LocalLogger<BaseLoggerType> > subLogger(const std::string & new_prefix)
  {
    return LocalLogger<LocalLogger<BaseLoggerType> >(new_prefix, *this);
  }
  inline LocalLogger<LocalLogger<BaseLoggerType> > subLogger(const std::string & new_prefix,
                                                             const std::string & new_glue)
  {
    return LocalLogger<LocalLogger<BaseLoggerType> >(new_prefix, new_glue, *this);
  }
  inline LocalLogger<LocalLogger<BaseLoggerType> > subLogger(const LocalLoggerOriginSpec & spec)
  {
    return LocalLogger<LocalLogger<BaseLoggerType> >(spec, *this);
  }

  PRINTF2_ARGS_SAFE inline void longdebug(const char * fmt, ...)
  { va_list ap; va_start(ap, fmt);  log<LONGDEBUG>(fmt, ap); va_end(ap); }
  PRINTF2_ARGS_SAFE inline void debug(const char * fmt, ...)
  { va_list ap; va_start(ap, fmt);  log<DEBUG>(fmt, ap); va_end(ap); }
  PRINTF2_ARGS_SAFE inline void info(const char * fmt, ...)
  { va_list ap; va_start(ap, fmt);  log<INFO>(fmt, ap); va_end(ap); }
  PRINTF2_ARGS_SAFE inline void warning(const char * fmt, ...)
  { va_list ap; va_start(ap, fmt);  log<WARNING>(fmt, ap); va_end(ap); }
  PRINTF2_ARGS_SAFE inline void error(const char * fmt, ...)
  { va_list ap; va_start(ap, fmt);  log<ERROR>(fmt, ap); va_end(ap); }

  template<typename... Args>
  inline void longdebug(Args &&... a) { log<Tomographer::Logger::LONGDEBUG>(std::forward<Args>(a)...); }
  template<typename... Args>
  inline void debug(Args &&... a) { log<Tomographer::Logger::DEBUG>(std::forward<Args>(a)...); }
  template<typename... Args>
  inline void info(Args &&... a) { log<Tomographer::Logger::INFO>(std::forward<Args>(a)...); }
  template<typename... Args>
  inline void warning(Args &&... a) { log<Tomographer::Logger::WARNING>(std::forward<Args>(a)...); }
  template<typename... Args>
  inline void error(Args &&... a) { log<Tomographer::Logger::ERROR>(std::forward<Args>(a)...); }

  template<int Level, typename... Args>
  inline void log(Args... args)
  {
    Base_::template log<Level>("", args...);
  }


  // relay calls to base logger

  inline std::string getSubOrigin(const char * origin) const
  {
    return ( origin == NULL || origin[0] == 0
             ? _origin_prefix
             : _origin_prefix + _glue + origin );
  }

  inline void emitLog(int level, const char * origin, const std::string& msg)
  {
    // this might also be called if we have a sublogger. In that case, if we have a
    // sublogger, then use their prefix.
    _baselogger.emitLog(level, getSubOrigin(origin).c_str(), msg);
  }

  inline int level() const
  {
    return _baselogger.level();
  }

  TOMOGRAPHER_ENABLED_IF(Tomographer::Logger::LoggerTraits<BaseLoggerType>::HasFilterByOrigin)
  inline bool filterByOrigin(int level, const char * origin)
  {
    return _baselogger.filterByOrigin(level, getSubOrigin(origin).c_str());
  }
};



template<typename BaseLoggerType>
LocalLogger<BaseLoggerType> makeLocalLogger(const std::string & origin_fn_name, BaseLoggerType & baselogger)
{
  return LocalLogger<BaseLoggerType>(origin_fn_name, baselogger);
}

template<typename BaseLoggerType>
LocalLogger<BaseLoggerType> makeLocalLogger(const std::string & origin_prefix, const std::string & glue,
                                            BaseLoggerType & baselogger)
{
  return LocalLogger<BaseLoggerType>(origin_prefix, glue, baselogger);
}

template<typename BaseLoggerType>
LocalLogger<BaseLoggerType> makeLocalLogger(const LocalLoggerOriginSpec & spec, BaseLoggerType & baselogger)
{
  return LocalLogger<BaseLoggerType>(spec, baselogger);
}





} // namespace Logger
} // namespace Tomographer



#endif