OutputUtils.hpp

#pragma once

#include <ostream>


namespace LSLOpt {

enum class OutputLevel {
    Nothing, 
    Error,   
    Warning, 
    Status,  
    Debug,   
};

inline std::ostream& operator<< (std::ostream& os, const OutputLevel& level)
{
  switch (level) {
    case OutputLevel::Error:
      os << "[ERROR   ] ";
      break;
    case OutputLevel::Warning:
      os << "[WARNING ] ";
      break;
    case OutputLevel::Status:
      os << "[STATUS  ] ";
      break;
    case OutputLevel::Debug:
      os << "[DEBUG   ] ";
      break;
    default:
      os << "[????????] ";
  }

  return os;
}

struct NoOutput {
    template<typename T>
    NoOutput& operator<<(const T& t)
    {
      return *this;
    }

    const OutputLevel output_level = OutputLevel::Nothing;
};

struct OstreamOutput {
    OstreamOutput(OutputLevel output_level, std::ostream& os)
    : output_level(output_level)
    , current_level(OutputLevel::Nothing)
    , os(os)
    {

    }

    OstreamOutput& operator<<(const OutputLevel& level)
    {
      current_level = level;
      output(level);
      return *this;
    }

    template<typename T>
    OstreamOutput& operator<<(const T& t)
    {
      output(t);
      return *this;
    }

    OutputLevel output_level;

  private:
    template<typename T>
    void output(const T& t)
    {
      if (current_level != OutputLevel::Nothing &&
          static_cast<unsigned>(current_level) <= static_cast<unsigned>(output_level)) {
        os << t;
      }
    }

    OutputLevel current_level;
    std::ostream& os;
};

template<typename OutputFunction>
bool is_output_enabled(
    OutputFunction& output_function,
    OutputLevel curr_level,
    decltype(output_function.output_level)* = nullptr)
{
  OutputLevel level = output_function.output_level;

  if (std::is_same<OutputFunction, NoOutput>::value) {
    return false;
  }

  return curr_level != OutputLevel::Nothing
      && static_cast<unsigned>(curr_level) <= static_cast<unsigned>(level);
}

inline bool is_output_enabled(...)
{
  return true;
}

}