log.hpp

Go to the documentation of this file.

#ifndef VIENNASHE_LOG_LOG_HPP
#define VIENNASHE_LOG_LOG_HPP
 
/* ============================================================================
   Copyright (c) 2011-2022, Institute for Microelectronics,
                            Institute for Analysis and Scientific Computing,
                            TU Wien.
 
                            -----------------
     ViennaSHE - The Vienna Spherical Harmonics Expansion Boltzmann Solver
                            -----------------
 
                    http://viennashe.sourceforge.net/
 
   License:         MIT (X11), see file LICENSE in the base directory
=============================================================================== */
 
#include <iosfwd>
 
#include <sstream>
#include <iostream>
#include <iomanip>
#include <string>
#include <stdio.h>
 
#include "viennashe/log/nullstream.hpp"
 
// Use this to enable fancy output for BASH
//#define VIENNASHE_LOG_ENABLE_FANCY_BASH
 
namespace viennashe
{
  namespace log
  {
 
    enum log_levels
    {
      logERROR = 0,       
      logWARNING,         
      logINFO,            
      logDEBUG,           
 
      logNEVER 
    };
 
    namespace detail
    {
      static log_levels modify_log_level(log_levels new_level, bool setter = false)
      {
        static log_levels current_level = logDEBUG; // DEFAULT LOG LEVEL IS DEBUG
        if (setter) current_level = new_level;
        return current_level;
      }
    }
 
    inline void set_log_level(log_levels new_level) { viennashe::log::detail::modify_log_level(new_level, true); }
    inline log_levels log_level() { return viennashe::log::detail::modify_log_level(viennashe::log::logDEBUG, false); }
 
    template < bool enabled >
    class logger
    {
      private:
        typedef std::ostringstream CollectorStreamType;
        CollectorStreamType local_out;
 
        logger & operator=(const logger &) { return *this; }
 
        log_levels _messageLevel;
 
      public:
 
        explicit logger() : _messageLevel(log_level()) {    }
 
        logger(log_levels level) : _messageLevel(level) {   }
 
        logger(const std::string & component_name) : _messageLevel(log_level())
        {
          this->get() << "[" << component_name << "] ";
        }
 
        logger(log_levels level, const std::string & component_name) : _messageLevel(level)
        {
          this->get() << "[" << component_name << "] ";
        }
 
        logger(const logger & r) : _messageLevel(r._messageLevel){
           if ( do_log() ){local_out.str(r.local_out.str());} // _messageLevel must have been copied already! C++7 change of policy
//         if ( do_log() ){ get() << r.get()}; // _messageLevel must have been copied already!
        }
 
        ~logger()
        {
#ifndef VIENNASHE_LOG_DISABLE
          if (this->do_log())
          {
  #ifdef VIENNASHE_LOG_ENABLE_FANCY_BASH
            switch(_messageLevel)
            {
              case log::logERROR:
              #ifdef VIENNASHE_LOG_ATOMIC
                fprintf(stderr, "\033[1;31m %s \033[0m", get().str().c_str());
                fflush(stderr);
              #else
                std::cout << get().str();
              #endif
                break;
              case log::logWARNING:
              #ifdef VIENNASHE_LOG_ATOMIC
                fprintf(stdout, "\033[1;33m %s \033[0m", get().str().c_str());
                fflush(stdout);
              #else
                std::cout << get().str();
              #endif
                break;
              case log::logDEBUG:
              #ifdef VIENNASHE_LOG_ATOMIC
                fprintf(stdout, "\033[1;32m %s \033[0m", get().str().c_str());
                fflush(stdout);
              #else
                std::cout << get().str();
              #endif
                break;
              default:
              #ifdef VIENNASHE_LOG_ATOMIC
                fprintf(stdout, "%s", get().str().c_str());
                fflush(stdout);
              #else
                std::cout << get().str();
              #endif
                break;
            }
  #else
            #ifdef VIENNASHE_LOG_ATOMIC
              fprintf(stdout, "%s", get().str().c_str());
              fflush(stdout);
            #else
              std::cout << get().str();
            #endif
  #endif
          }
#endif
        }
 
        bool do_log() const { return (this->_messageLevel <= log_level()); }
 
        CollectorStreamType       & get()       {  return local_out;   }
        CollectorStreamType const & get() const {  return local_out;   }
 
        template <typename T>
        CollectorStreamType & operator<<(const T & x )
        {
          if( do_log() ) { get() << x; }
          return get();
        }
 
        typedef std::ostream& (*ostream_manipulator)(std::ostream&);
        CollectorStreamType & operator<<(ostream_manipulator pf)
        {
          if( do_log() ) { get() << pf ; }
          return get();
        }
 
        CollectorStreamType & operator<<(std::string & x )
        {
          if( do_log() ) { get() << x; }
          return get();
        }
 
        CollectorStreamType & operator<<(const std::string & x )
        {
          if( do_log() ) { get() << x; }
          return get();
        }
 
        CollectorStreamType & operator<<(const char * x )
        {
          if( do_log() && x != 0) { get() << x; }
          return get();
        }
 
        CollectorStreamType & operator<<(logger & r )
        {
          if( do_log() ) { get() << r.get(); }
          return get();
        }
    };
 
    template < >
    class logger<false>
    {
      private:
 
        logger & operator=(const logger &) { return *this; }
 
        log_levels _messageLevel;
 
      public:
 
        explicit logger() : _messageLevel(log_level()) {    }
 
        logger(log_levels level) : _messageLevel(level) {   }
 
        logger(const std::string &) : _messageLevel(log_level()) {  }
 
        logger(log_levels level, const std::string &) : _messageLevel(level) {  }
 
        logger(const logger & r) : _messageLevel(r._messageLevel) { }
 
        ~logger() {  }
 
        bool do_log() const { return false; }
 
        nullstream & get() {  return get_nullstream();   }
        nullstream const& get() const {  return get_nullstream();   }
 
        template <typename T>
        nullstream & operator<<(const T &) { return get_nullstream(); }
 
        typedef std::ostream& (*ostream_manipulator)(std::ostream&);
        nullstream & operator<<(ostream_manipulator) { return get_nullstream(); }
 
        nullstream & operator<<(std::string &) { return get_nullstream(); }
        nullstream & operator<<(const std::string &) { return get_nullstream(); }
        nullstream & operator<<(const char *) { return get_nullstream(); }
        nullstream & operator<<(logger &) { return get_nullstream(); }
    };
 
    namespace detail
    {
 
#ifndef VIENNASHE_LOG_DISABLE
 
    template < typename KeyTypeT >
    logger<KeyTypeT::enabled> vlogT()
    {
      return logger<KeyTypeT::enabled>();
    }
 
    template < log_levels level, typename KeyTypeT >
    logger<KeyTypeT::enabled> vlogTL()
    {
      return logger<KeyTypeT::enabled>(level);
    }
 
    template < log_levels level >
    logger<true> vlogL( )
    {
      return logger<true>(level); // using the given level
    }
 
#else
    template < typename KeyTypeT >
    nullstream & vlogT()
    {
      return get_nullstream();
    }
 
    template < log_levels level, typename KeyTypeT >
    nullstream & vlogTL()
    {
      return get_nullstream();
    }
 
    template < log_levels level >
    nullstream & vlogL( )
    {
      return get_nullstream();
    }
#endif
 
    } // namespace detail
 
#ifndef VIENNASHE_LOG_DISABLE
 
    inline logger<true>  error() { return detail::vlogL<logERROR>();   }
    inline logger<true>  warn()  { return detail::vlogL<logWARNING>(); }
    inline logger<true>  warning()  { return detail::vlogL<logWARNING>(); }
    inline logger<true>  info()  { return detail::vlogL<logINFO>();    }
    inline logger<true>  debug() { return detail::vlogL<logDEBUG>();   }
 
 
 
    template < typename KeyTypeT >
    logger<KeyTypeT::enabled>  error() { return detail::vlogTL<logERROR, KeyTypeT>();   }
 
    template < typename KeyTypeT >
    logger<KeyTypeT::enabled>  warn()  { return detail::vlogTL<logWARNING, KeyTypeT>(); }
 
    template < typename KeyTypeT >
    logger<KeyTypeT::enabled>  warning()  { return detail::vlogTL<logWARNING, KeyTypeT>(); }
 
    template < typename KeyTypeT >
    logger<KeyTypeT::enabled>  info()  { return detail::vlogTL<logINFO, KeyTypeT>();    }
 
    template < typename KeyTypeT >
    logger<KeyTypeT::enabled>  debug() { return detail::vlogTL<logDEBUG, KeyTypeT>();   }
 
#else
 
    inline nullstream & error() { return detail::vlogL<logERROR>();   }
    inline nullstream & warn()  { return detail::vlogL<logWARNING>(); }
    inline nullstream & warning()  { return detail::vlogL<logWARNING>(); }
    inline nullstream & info()  { return detail::vlogL<logINFO>();    }
    inline nullstream & debug() { return detail::vlogL<logDEBUG>();   }
 
    template < typename KeyTypeT >
    nullstream & error() { return detail::vlogTL<logERROR, KeyTypeT>();   }
 
    template < typename KeyTypeT >
    nullstream & warn()  { return detail::vlogTL<logWARNING, KeyTypeT>(); }
 
    template < typename KeyTypeT >
    nullstream & warning()  { return detail::vlogTL<logWARNING, KeyTypeT>(); }
 
    template < typename KeyTypeT >
    nullstream & info()  { return detail::vlogTL<logINFO, KeyTypeT>();    }
 
    template < typename KeyTypeT >
    nullstream & debug() { return detail::vlogTL<logDEBUG, KeyTypeT>();   }
 
#endif
 
  } // log
} // viennashe
 
 
#endif