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) 2016 ETH Zurich, Institute for Theoretical Physics, Philippe Faist
 * Copyright (c) 2017 Caltech, Institute for Quantum Information and Matter, 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::true_type
#include <map>

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

#include <tomographer/tools/cxxdefs.h>
#include <tomographer/tools/fmt.h>
#include <tomographer/tools/conststr.h>


#ifdef ERROR
#error "The macro ERROR is defined. You may be on a Windows system. Make sure that <tomographer/tools/logger.h> is included BEFORE any windows-related header."
#endif


namespace Tomographer
{

namespace Logger
{

enum LogLevelCode
{
  ERROR = 0,

  WARNING,

  INFO,

  DEBUG,

  LONGDEBUG,


  HIGHEST_SEVERITY_LEVEL = 0,

  LOWEST_SEVERITY_LEVEL = 0x7fffffff
};



class TOMOGRAPHER_EXPORT LogLevel
{
  int _level;
public:
  LogLevel(int level_ = INFO) { setLevel(level_); }
  LogLevel(const char * s) { setLevel(s); }
  LogLevel(std::string s) { setLevel(std::move(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(std::move(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 TOMOGRAPHER_EXPORT StaticIsAtLeastOfSeverity {
  enum {
    value = (Level <= BaseLevel)
  };
};


struct TOMOGRAPHER_EXPORT DefaultLoggerTraits
{
  enum {
    IsThreadSafe = 0,

    StaticMinimumSeverityLevel = LOWEST_SEVERITY_LEVEL,

    HasOwnGetLevel = 0,

    HasFilterByOrigin = 0
  };
};

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



namespace tomo_internal {
template<bool hasOwnGetLevel>
class
TOMOGRAPHER_EXPORT  // export might be needed because this is used as base class of LoggerBase
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 TOMOGRAPHER_EXPORT 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 Fn>
struct IsOstreamArgCallable
{
  enum {
    value = std::is_convertible<
      typename std::remove_reference<Fn>::type,
      std::function<void(std::ostream&)>
    >::value
  };
};

} // namespace tomo_internal


template<typename Derived>
class TOMOGRAPHER_EXPORT 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_)
  {
  }


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

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

  inline bool enabledFor(int level_) const
  {
    return 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
  



  TOMOGRAPHER_ENABLED_IF(staticallyEnabledFor<ERROR>())
  PRINTF3_ARGS_SAFE
  inline void error(const char * origin, const char * fmt, ...)
  {
    va_list ap;
    va_start(ap, fmt);
    log<ERROR>(origin, fmt, ap);
    va_end(ap);
  }

  TOMOGRAPHER_ENABLED_IF(staticallyEnabledFor<ERROR>())
  inline void error(const char * origin, std::string msg)
  {
    log<ERROR>(origin, std::move(msg));
  }

  template<typename Fn,
           TOMOGRAPHER_ENABLED_IF_TMPL(staticallyEnabledFor<ERROR>() &&
                                       tomo_internal::IsOstreamArgCallable<Fn>::value)>
  inline void error(const char * origin, Fn && f)
  {
    log<ERROR>(origin, std::forward<Fn>(f));
  }

  template<TOMOGRAPHER_ENABLED_IF_TMPL(!staticallyEnabledFor<ERROR>()), typename... Args>
  inline void error(Args && ... ) { }

  TOMOGRAPHER_ENABLED_IF(staticallyEnabledFor<WARNING>())
  PRINTF3_ARGS_SAFE
  inline void warning(const char * origin, const char * fmt, ...)
  {
    va_list ap;
    va_start(ap, fmt);
    log<WARNING>(origin, fmt, ap);
    va_end(ap);
  }

  TOMOGRAPHER_ENABLED_IF(staticallyEnabledFor<WARNING>())
  inline void warning(const char * origin, std::string msg)
  {
    log<WARNING>(origin, std::move(msg));
  }

  template<typename Fn,
           TOMOGRAPHER_ENABLED_IF_TMPL(staticallyEnabledFor<WARNING>() &&
                                       tomo_internal::IsOstreamArgCallable<Fn>::value)>
  inline void warning(const char * origin, Fn && f)
  {
    log<WARNING>(origin, std::forward<Fn>(f));
  }

  template<TOMOGRAPHER_ENABLED_IF_TMPL(!staticallyEnabledFor<WARNING>()), typename... Args>
  inline void warning(Args && ... ) { }

  TOMOGRAPHER_ENABLED_IF(staticallyEnabledFor<INFO>())
  PRINTF3_ARGS_SAFE
  inline void info(const char * origin, const char * fmt, ...)
  {
    va_list ap;
    va_start(ap, fmt);
    log<INFO>(origin, fmt, ap);
    va_end(ap);
  }
  
  TOMOGRAPHER_ENABLED_IF(staticallyEnabledFor<INFO>())
  inline void info(const char * origin, std::string msg)
  {
    log<INFO>(origin, std::move(msg));
  }
  template<typename Fn,
           TOMOGRAPHER_ENABLED_IF_TMPL(staticallyEnabledFor<INFO>() &&
                                       tomo_internal::IsOstreamArgCallable<Fn>::value)>
  inline void info(const char * origin, Fn && f)
  {
    log<INFO>(origin, std::forward<Fn>(f));
  }

  template<TOMOGRAPHER_ENABLED_IF_TMPL(!staticallyEnabledFor<INFO>()), typename... Args>
  inline void info(Args && ... ) { }


  TOMOGRAPHER_ENABLED_IF(staticallyEnabledFor<DEBUG>())
  PRINTF3_ARGS_SAFE
  inline void debug(const char * origin, const char * fmt, ...)
  {
    va_list ap;
    va_start(ap, fmt);
    log<DEBUG>(origin, fmt, ap);
    va_end(ap);
  }

  TOMOGRAPHER_ENABLED_IF(staticallyEnabledFor<DEBUG>())
  inline void debug(const char * origin, std::string msg)
  {
    log<DEBUG>(origin, std::move(msg));
  }

  template<typename Fn,
           TOMOGRAPHER_ENABLED_IF_TMPL(staticallyEnabledFor<DEBUG>() &&
                                       tomo_internal::IsOstreamArgCallable<Fn>::value)>
  inline void debug(const char * origin, Fn && f)
  {
    log<DEBUG>(origin, std::forward<Fn>(f));
  }

  template<TOMOGRAPHER_ENABLED_IF_TMPL(!staticallyEnabledFor<DEBUG>()), typename... Args>
  inline void debug(Args && ... ) { }

  TOMOGRAPHER_ENABLED_IF(staticallyEnabledFor<LONGDEBUG>())
  PRINTF3_ARGS_SAFE
  inline void longdebug(const char * origin, const char * fmt, ...)
  {
    va_list ap;
    va_start(ap, fmt);
    log<LONGDEBUG>(origin, fmt, ap);
    va_end(ap);
  }

  TOMOGRAPHER_ENABLED_IF(staticallyEnabledFor<LONGDEBUG>())
  inline void longdebug(const char * origin, std::string msg)
  {
    log<LONGDEBUG>(origin, std::move(msg));
  }
  template<typename Fn,
           TOMOGRAPHER_ENABLED_IF_TMPL(staticallyEnabledFor<LONGDEBUG>() &&
                                       tomo_internal::IsOstreamArgCallable<Fn>::value)>
  inline void longdebug(const char * origin, Fn && f)
  {
    log<LONGDEBUG>(origin, std::forward<Fn>(f));
  }

  template<TOMOGRAPHER_ENABLED_IF_TMPL(!staticallyEnabledFor<LONGDEBUG>()), typename... Args>
  inline void longdebug(Args && ... ) { }


  PRINTF4_ARGS_SAFE
  inline void log(int level, const char * origin, const char * fmt, ...)
  {
    va_list ap;
    va_start(ap, fmt);
    _do_log(level, origin, fmt, ap);
    va_end(ap);
  }

  inline void log(int level, const char * origin, std::string msg)
  {
    _do_log(level, origin, std::move(msg));
  }

  template<typename Fn, TOMOGRAPHER_ENABLED_IF_TMPL(tomo_internal::IsOstreamArgCallable<Fn>::value)>
  inline void log(int level, const char * origin, Fn && f)
  {
    _do_log(level, origin, std::forward<Fn>(f));
  }


  template<int Level, TOMOGRAPHER_ENABLED_IF_TMPL(staticallyEnabledFor<Level>())>
  PRINTF3_ARGS_SAFE
  inline void log(const char * origin, const char * fmt, ...)
  {
    va_list ap;
    va_start(ap, fmt);
    _do_log(Level, origin, fmt, ap);
    va_end(ap);
  }

  template<int Level, TOMOGRAPHER_ENABLED_IF_TMPL(staticallyEnabledFor<Level>())>
  inline void log(const char * origin, const char * fmt, va_list ap)
  {
    _do_log(Level, origin, fmt, ap);
  }

  template<int Level, TOMOGRAPHER_ENABLED_IF_TMPL(staticallyEnabledFor<Level>())>
  inline void log(const char * origin, std::string msg)
  {
    _do_log(Level, origin, std::move(msg));
  }

  template<int Level, typename Fn,
           TOMOGRAPHER_ENABLED_IF_TMPL(staticallyEnabledFor<Level>() &&
                                       tomo_internal::IsOstreamArgCallable<Fn>::value)>
  inline void log(const char * origin, Fn f)
  {
    _do_log(Level, origin, f);
  }

  template<int Level, TOMOGRAPHER_ENABLED_IF_TMPL(!staticallyEnabledFor<Level>()), typename ... Args>
  inline void log(Args && ...) { }



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:

  TOMOGRAPHER_ENABLED_IF(!HasFilterByOrigin)
  inline bool _test_filter_by_origin(int , const char * ) const { return true; }
  TOMOGRAPHER_ENABLED_IF(HasFilterByOrigin)
  inline bool _test_filter_by_origin(int level, const char * origin)
  {
    return derived()->filterByOrigin(level, origin);
  }

  inline bool _test_should_emit(int level, const char * origin)
  {
    return enabledFor(level) && _test_filter_by_origin(level, origin) ;
  }

  inline void _do_log(int level, const char * origin, const char * fmt, va_list ap)
  {
    if (_test_should_emit(level, origin)) {
      std::string msg = Tools::vfmts(fmt, ap);
      derived()->emitLog(level, origin, std::move(msg));
    }
  }
  inline void _do_log(int level, const char * origin, std::string msg)
  {
    if (_test_should_emit(level, origin)) {
      derived()->emitLog(level, origin, std::move(msg));
    }
  }
  template<typename Fn, TOMOGRAPHER_ENABLED_IF_TMPL(tomo_internal::IsOstreamArgCallable<Fn>::value)>
  inline void _do_log(int level, const char * origin, Fn f)
  {
    if (_test_should_emit(level, origin)) {
      std::ostringstream sstr;
      f(sstr);
      derived()->emitLog(level, origin, sstr.str());
    }
  }

};






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

class TOMOGRAPHER_EXPORT 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, 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())
        + std::move(msg) // \a msg is moved here, don't use \a msg any more
        );

    // 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 TOMOGRAPHER_EXPORT 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 TOMOGRAPHER_EXPORT BufferLogger : public LoggerBase<BufferLogger>
{
  std::ostringstream buffer;
public:
  BufferLogger(int level)
    : LoggerBase<BufferLogger>(level)
  {
  }

  inline void emitLog(int /*level*/, const char * origin, std::string msg)
  {
    buffer << (origin&&origin[0] ? "["+std::string(origin)+"] " : std::string())
           << std::move(msg) << "\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 TOMOGRAPHER_EXPORT 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, std::string msg)
  {
    baselogger.emitLog(level, origin, std::move(msg));
  }

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

  TOMOGRAPHER_ENABLED_IF(LoggerTraits<BaseLogger>::HasFilterByOrigin)
  inline bool filterByOrigin(int level, const char * origin)
  {
    return baselogger.filterByOrigin(level, origin);
  }
};





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

template<typename BaseLogger>
class TOMOGRAPHER_EXPORT OriginPrefixedLogger : public LoggerBase<OriginPrefixedLogger<BaseLogger> >
{
  BaseLogger & baselogger;

  std::string prefix;

public:
  OriginPrefixedLogger(BaseLogger & baselogger_, std::string prefix_)
    : LoggerBase<OriginPrefixedLogger<BaseLogger> >(),
      baselogger(baselogger_),
      prefix(prefix_)
  {
  }

  inline void setPrefix(std::string prefix_)
  {
    prefix = prefix_;
  }


  inline void emitLog(int level, const char * origin, std::string msg)
  {
    std::string neworigin = prefix + origin;
    baselogger.emitLog(level, neworigin.c_str(), std::move(msg));
  }

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

  TOMOGRAPHER_ENABLED_IF(LoggerTraits<BaseLogger>::HasFilterByOrigin)
  inline bool filterByOrigin(int level, const char * origin)
  {
    return baselogger.filterByOrigin(level, origin); // unmodified origin here for by-origin filtering
  }
};




namespace tomo_internal {

inline std::size_t 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 TOMOGRAPHER_EXPORT 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, std::string msg)
  {
    baselogger.emitLog(level, origin, std::move(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;
    std::size_t last_matched_length = 0;
    for (ConstIterator it = levels_set.begin(); it != levels_set.end(); ++it) {
      const std::size_t 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 TOMOGRAPHER_EXPORT LocalLogger
  : public LoggerBase<LocalLogger<BaseLoggerType_> >
{
public:
  typedef BaseLoggerType_ BaseLoggerType;

private:
  typedef LoggerBase<LocalLogger> Base_;

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

  BaseLoggerType & _baselogger;

public:
  LocalLogger(std::string origin_fn_name, BaseLoggerType & logger_)
    : Base_(), _origin_prefix(std::move(origin_fn_name)), _glue("::"), _baselogger(logger_)
  {
    this->longdebug("[begin]");
  }
  LocalLogger(std::string origin_prefix, std::string glue, BaseLoggerType & logger_)
    : Base_(), _origin_prefix(std::move(origin_prefix)), _glue(std::move(glue)), _baselogger(logger_)
  {
    this->longdebug("[begin]");
  }
  LocalLogger(const LocalLoggerOriginSpec & spec, BaseLoggerType & logger_)
    : Base_(), _origin_prefix(spec.origin_prefix.to_string()+spec.origin_prefix_add.to_string()),
      _glue(spec.glue.to_string()), _baselogger(logger_)
  {
    this->longdebug("[begin]");
  }

  LocalLogger(LocalLogger && movecopy)
    : Base_(), _origin_prefix(std::move(movecopy._origin_prefix)), _glue(std::move(movecopy._glue)),
      _baselogger(movecopy._baselogger)
  {
    this->longdebug("[logger moved]");
  }
  LocalLogger(const LocalLogger & other)
    : Base_(), _origin_prefix(other._origin_prefix), _glue(other._glue),
      _baselogger(other._baselogger)
  {
    this->longdebug("[logger copied]");
  }

  ~LocalLogger()
  {
    this->longdebug("[done]");
  }

  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(std::string new_prefix)
  {
    return LocalLogger<LocalLogger<BaseLoggerType> >(std::move(new_prefix), *this);
  }
  inline LocalLogger<LocalLogger<BaseLoggerType> > subLogger(std::string new_prefix,
                                                             std::string new_glue)
  {
    return LocalLogger<LocalLogger<BaseLoggerType> >(std::move(new_prefix), std::move(new_glue), *this);
  }
  inline LocalLogger<LocalLogger<BaseLoggerType> > subLogger(const LocalLoggerOriginSpec & spec)
  {
    return LocalLogger<LocalLogger<BaseLoggerType> >(spec, *this);
  }

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

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

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


  template<TOMOGRAPHER_ENABLED_IF_TMPL(!Base_::template staticallyEnabledFor<LONGDEBUG>()),
           typename... Args>
  inline void longdebug(Args &&... ) { }
  template<TOMOGRAPHER_ENABLED_IF_TMPL(!Base_::template staticallyEnabledFor<DEBUG>()),
           typename... Args>
  inline void debug(Args &&... ) { }
  template<TOMOGRAPHER_ENABLED_IF_TMPL(!Base_::template staticallyEnabledFor<INFO>()),
           typename... Args>
  inline void info(Args &&... ) { }
  template<TOMOGRAPHER_ENABLED_IF_TMPL(!Base_::template staticallyEnabledFor<WARNING>()),
           typename... Args>
  inline void warning(Args &&... ) { }
  template<TOMOGRAPHER_ENABLED_IF_TMPL(!Base_::template staticallyEnabledFor<ERROR>()),
           typename... Args>
  inline void error(Args &&... ) { }
  template<int Level, TOMOGRAPHER_ENABLED_IF_TMPL(!Base_::template staticallyEnabledFor<Level>()),
           typename... Args>
  inline void log(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, 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(), std::move(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>
inline LocalLogger<BaseLoggerType> makeLocalLogger(std::string origin_fn_name,
                                                   BaseLoggerType & baselogger)
{
  return LocalLogger<BaseLoggerType>(std::move(origin_fn_name), baselogger);
}

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

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





} // namespace Logger
} // namespace Tomographer



#endif