Log.h

Go to the documentation of this file.

#ifndef INCLUDE_SCINE_UTILS_LOG_H
#define INCLUDE_SCINE_UTILS_LOG_H

#include "Core/ExportControl.h"
#include <fstream>
#include <iostream>
#include <memory>
#include <string>
#include <unordered_map>

namespace Scine {
namespace Core {
namespace Traits {

template<typename>
struct sfinae_true : std::true_type {};

template<typename T>
static auto testIsStreamWriter(int) -> sfinae_true<decltype(std::declval<T>()(std::declval<std::ostream&>()))>;

template<typename T>
static auto testIsStreamWriter(long) -> std::false_type;

template<typename T>
struct isStreamWriter : decltype(testIsStreamWriter<T>(0)) {};

} // namespace Traits

struct CORE_EXPORT Log {

  using SinkPtr = std::shared_ptr<std::ostream>;

  class CORE_EXPORT Domain {
   public:
    inline Domain() = default;
    inline Domain(std::string n, SinkPtr s) {
      sinks_.emplace(std::move(n), std::move(s));
    }

    inline void add(std::string n, SinkPtr s) {
      sinks_.emplace(std::move(n), std::move(s));
    }

    inline void clear() {
      sinks_.clear();
    }

    inline void remove(const std::string& name) {
      sinks_.erase(expectantFind(name));
    }

    inline SinkPtr extract(const std::string& name) {
      auto findIter = expectantFind(name);
      auto ptr = std::move(findIter->second);
      sinks_.erase(findIter);
      return ptr;
    }

    inline explicit operator bool() const {
      return !sinks_.empty();
    }

    template<typename... Args>
    inline void printf(Args&&... args) {
      const int sz = snprintf(NULL, 0, std::forward<Args>(args)...);
      char* buf = new char[sz + 1];
      snprintf(buf, sz + 1, std::forward<Args>(args)...);
      (*this) << std::string(buf);
      delete[] buf;
    }

    template<typename T>
    std::enable_if_t<Traits::isStreamWriter<T>::value, Domain&> operator<<(T&& f) {
      for (auto& nameSinkPair : sinks_) {
        f(*nameSinkPair.second);
      }

      return *this;
    }

    template<typename T>
    std::enable_if_t<!Traits::isStreamWriter<T>::value, Domain&> operator<<(T&& t) {
      for (auto& nameSinkPair : sinks_) {
        *nameSinkPair.second << t;
      }
      return *this;
    }

    template<typename... Args>
    inline void lazy(Args&&... args) {
      if (*this) {
        sink(std::forward<Args>(args)...);
      }
    }

    inline void line(const std::string& s) {
      if (*this) {
        *this << s << Log::nl;
      }
    }

   private:
    inline void sink() {
    }

    template<typename F, typename... Args>
    inline void sink(F&& f, Args&&... args) {
      *this << f();
      return sink(args...);
    }

    using MapType = std::unordered_map<std::string, SinkPtr>;
    using iterator = typename MapType::iterator;

    inline iterator expectantFind(const std::string& sinkName) {
      const auto findIter = sinks_.find(sinkName);
      if (findIter == std::end(sinks_)) {
        throw std::out_of_range("Sink name not found");
      }
      return findIter;
    }

    std::unordered_map<std::string, SinkPtr> sinks_;
  };

  using iterator = Domain*;
  using const_iterator = const Domain*;
  using value_type = Domain;
  using reference = Domain&;
  using pointer = Domain*;

  static inline SinkPtr fileSink(const std::string& filename) {
    return std::make_shared<std::ofstream>(filename, std::ios_base::out | std::ios_base::app);
  }

  static inline SinkPtr coutSink() {
    return std::make_shared<std::ostream>(std::cout.rdbuf());
  }

  static inline SinkPtr cerrSink() {
    return std::make_shared<std::ostream>(std::cerr.rdbuf());
  }

  static inline Log silent() {
    return Log{Domain(), Domain(), Domain(), Domain()};
  }

  static inline std::ostream& nl(std::ostream& os) {
    os << "\n";
    return os;
  }

  static inline std::ostream& flush(std::ostream& os) {
    os << std::flush;
    return os;
  }

  static inline std::ostream& endl(std::ostream& os) {
    os << std::endl;
    return os;
  }

  inline void clear() {
    for (Domain& domain : *this) {
      domain.clear();
    }
  }

  inline void sinkAllToFile(const std::string& file, std::string sinkName = "") {
    if (sinkName.empty()) {
      sinkName = std::to_string(std::hash<std::string>{}(file));
    }

    auto sink = fileSink(file);
    for (Domain& domain : *this) {
      domain.add(sinkName, sink);
    }
  }

  // NOTE: Standard guarantees in-order sequential member memory layout
  inline iterator begin() {
    return std::addressof(debug);
  }
  inline iterator end() {
    return std::addressof(output) + 1;
  }
  inline const_iterator begin() const {
    return std::addressof(debug);
  }
  inline const_iterator end() const {
    return std::addressof(output) + 1;
  }


  Domain debug;
  Domain warning = Domain("cerr", cerrSink());
  Domain error = Domain("cerr", cerrSink());
  Domain output = Domain("cout", coutSink());
};

} // namespace Core
} // namespace Scine

#endif