print.h

Go to the documentation of this file.

// SPDX-License-Identifier: BSD-3-Clause
#ifndef TTG_PRINT_H
#define TTG_PRINT_H
 
#include <iostream>
#include <mutex>
#include <complex>
#include <vector>
#include <array>
#include <utility>
 
namespace ttg {
  constexpr char print_separator = ' ';
  constexpr char print_seq_separator = ',';
  constexpr char print_seq_begin = '{';
  constexpr char print_seq_end = '}';
 
  namespace iostream {
 
 
 
    template <typename T>
    std::ostream &operator<<(std::ostream &s, const std::complex<T> &c) {
      s << c.real() << (c.imag() >= 0 ? "+" : "") << c.imag() << "j";
      return s;
    }
 
 
    template <typename T, typename U>
    std::ostream &operator<<(std::ostream &s, const std::pair<T, U> &p) {
      s << print_seq_begin << p.first << print_seq_separator << p.second << print_seq_end;
      return s;
    }
 
 
    template <typename T>
    std::ostream &operator<<(std::ostream &s, const std::vector<T> &c) {
      s << print_seq_begin;
      typename std::vector<T>::const_iterator it = c.begin();
      while (it != c.end()) {
        s << *it;
        ++it;
        if (it != c.end())
          s << print_seq_separator;
      };
      s << print_seq_end;
      return s;
    }
 
 
    template <typename T, std::size_t N>
    typename std::enable_if<!std::is_same<T, char>::value, std::ostream &>::type
    operator<<(std::ostream &s, const std::array<T,N>& v) {
      s << print_seq_begin;
      for (std::size_t i = 0; i < N; ++i) {
        s << v[i];
        if (i != (N - 1))
          s << print_seq_separator;
      }
      s << print_seq_end;
      return s;
    }
 
 
    template <typename T, std::size_t N>
    typename std::enable_if<!std::is_same<T, char>::value, std::ostream &>::type
    operator<<(std::ostream &s, const T (&v)[N]) {
      s << print_seq_begin;
      for (std::size_t i = 0; i < N; ++i) {
        s << v[i];
        if (i != (N - 1))
          s << print_seq_separator;
      }
      s << print_seq_end;
      return s;
    }
 
  }  // namespace operators
 
  namespace detail {
    inline std::ostream &print_helper(std::ostream &out) { return out; }
    template <typename T, typename... Ts>
    inline std::ostream &print_helper(std::ostream &out, const T &t, const Ts &... ts) {
      using ttg::iostream::operator<<;
      out << print_separator << t;
      return print_helper(out, ts...);
    }
    //
    enum class StdOstreamTag { Cout, Cerr };
    template <StdOstreamTag>
    inline std::mutex &print_mutex_accessor() {
      static std::mutex mutex;
      return mutex;
    }
  }  // namespace detail
 
  template <typename T, typename... Ts>
  void print(const T &t, const Ts &... ts) {
    std::lock_guard<std::mutex> lock(detail::print_mutex_accessor<detail::StdOstreamTag::Cout>());
    std::cout << t;
    detail::print_helper(std::cout, ts...) << std::endl;
  }
 
  template <typename T, typename... Ts>
  void print_error(const T &t, const Ts &... ts) {
    std::lock_guard<std::mutex> lock(detail::print_mutex_accessor<detail::StdOstreamTag::Cout>());
    std::cerr << t;
    detail::print_helper(std::cerr, ts...) << std::endl;
  }
 
  template <typename T, typename... Ts>
  void log(const T &t, const Ts &... ts) {
    std::lock_guard<std::mutex> lock(detail::print_mutex_accessor<detail::StdOstreamTag::Cout>());
    std::clog << t;
    detail::print_helper(std::clog, ts...) << std::endl;
  }
} // namespace ttg
 
#endif // TTG_PRINT_H