print.hh

#pragma once
 
#include <algorithm>
#include <cassert>
#include <charconv>
#include <cstring>
#include <ostream>
#include <span>
#include <streambuf>
#include <string>
#include <string_view>
#include <vector>
 
namespace CppClingo::Util {
 
 
class OutputBuffer {
  public:
    using value_type = char;
 
    OutputBuffer(FILE *out = nullptr) : out_{out} {}
 
    void flush() {
        if (out_ != nullptr) {
            fwrite(buf_.data(), sizeof(char), size_, out_);
            fflush(out_);
            size_ = 0;
        }
    }
 
    void endl() {
        constexpr auto n = 8192;
        if (out_ != nullptr && size_ > n) {
            fwrite(buf_.data(), sizeof(char), size_, out_);
            size_ = 0;
        }
    }
 
    [[nodiscard]] auto size() const -> size_t { return static_cast<size_t>(size_); }
 
    [[nodiscard]] auto empty() const -> bool { return size_ == 0; }
 
    [[nodiscard]] auto view() const -> std::string_view {
        return std::string_view{buf_.data(), static_cast<size_t>(size_)};
    }
 
    [[nodiscard]] auto span() -> std::span<char> { return std::span{buf_.data(), static_cast<size_t>(size_)}; }
 
    [[nodiscard]] auto str() const -> std::string { return std::string{buf_.data(), static_cast<size_t>(size_)}; }
 
    [[nodiscard]] auto c_str() -> char const * {
        *ensure_(1) = '\0';
        return buf_.data();
    }
 
    auto reset() -> OutputBuffer & {
        size_ = 0;
        return *this;
    }
 
    auto release() -> std::vector<char> {
        buf_.resize(size_);
        buf_.emplace_back('\0');
        auto ret = std::move(buf_);
        buf_.clear();
        size_ = 0;
        return ret;
    }
 
    void append(char const *str) {
        auto n = static_cast<std::ptrdiff_t>(std::strlen(str));
        std::copy(str, std::next(str, n), ensure_(n));
        size_ += n;
    }
 
    void append(std::string_view str) {
        auto n = static_cast<std::ptrdiff_t>(str.length());
        std::ranges::copy(str, ensure_(n));
        size_ += n;
    }
 
    void append(char c) {
        *ensure_(1) = c;
        ++size_;
    }
 
    void push_back(char c) { append(c); }
 
    void pop() { --size_; }
 
    template <std::integral T> void append(T num, int base = 10) { // NOLINT
        constexpr auto n = 256;
        auto *end = ensure_(n);
        auto res = std::to_chars(end, limit_(), num, base);
        size_ += res.ptr - end;
    }
 
    auto reserve(std::ptrdiff_t n) -> std::span<char> {
        auto *begin = ensure_(n);
        size_ += n;
        return {begin, std::next(begin, n)};
    }
 
    void trim_zero(std::ptrdiff_t len) {
        auto sp = std::span{buf_.data(), static_cast<size_t>(size_)};
        auto ie = sp.end();
        auto ib = sp.begin() + (size_ - len);
        auto it = std::find(ib, ie, '\0');
        size_ -= ie - it;
    }
 
    template <std::integral T> friend auto operator<<(OutputBuffer &out, T num) -> OutputBuffer & {
        out.append(num);
        return out;
    }
 
    friend auto operator<<(OutputBuffer &out, char c) -> OutputBuffer & {
        out.append(c);
        return out;
    }
 
    friend auto operator<<(OutputBuffer &out, std::string_view str) -> OutputBuffer & {
        out.append(str);
        return out;
    }
 
    friend auto operator<<(OutputBuffer &out, double value) -> OutputBuffer & {
        static constexpr std::ptrdiff_t n = 32;
        auto *begin = out.ensure_(n);
        auto *end = std::next(begin, n);
        auto [res, ec] = std::to_chars(begin, end, value);
        out.size_ += std::distance(begin, res);
        return out;
    }
 
    friend auto operator<<(OutputBuffer &out, char const *str) -> OutputBuffer & {
        out.append(str);
        return out;
    }
 
  private:
    auto limit_() -> char * { return std::next(buf_.data(), static_cast<std::ptrdiff_t>(buf_.size())); }
 
    auto ensure_(std::ptrdiff_t n) -> char * {
        auto m = size_ + n;
        assert(n >= 0 && m >= 0);
        if (buf_.size() < static_cast<size_t>(m)) {
            buf_.reserve(2 * static_cast<size_t>(m));
            buf_.resize(buf_.capacity());
        }
        return std::next(buf_.data(), size_);
    }
 
    std::vector<char> buf_;
    std::ptrdiff_t size_ = 0;
    FILE *out_;
};
 
class OutputStream : public std::ostream {
  public:
    OutputStream(FILE *out) : std::ostream{nullptr}, buf_{out} { rdbuf(&buf_); }
 
    auto buffer() -> OutputBuffer & { return buf_.buffer(); }
 
  private:
    class Streambuf : public std::streambuf {
      public:
        Streambuf(FILE *out) : buf_{out} {}
        auto buffer() -> OutputBuffer & { return buf_; }
 
      protected:
        auto overflow(int ch) -> int override {
            if (ch != traits_type::eof()) {
                buf_.push_back(static_cast<char>(ch));
                return traits_type::not_eof(ch);
            }
            return traits_type::eof();
        }
 
        auto xsputn(char const *s, std::streamsize n) -> std::streamsize override {
            buf_.append(std::string_view{s, static_cast<size_t>(n)});
            return n;
        }
 
        auto sync() -> int override {
            buf_.flush();
            return 0;
        }
 
      private:
        OutputBuffer buf_;
    };
 
    Streambuf buf_;
};
 
namespace Detail {
 
struct PrintSelf {
    template <class Out> void operator()(Out &out, auto const &x) { out << x; }
};
 
template <class It, class F> class PrintRange {
  public:
    template <class A>
    PrintRange(It first, It last, char const *sep, A &&fun)
        : first_{first}, last_{last}, sep_{sep}, fun_{std::forward<A>(fun)} {}
    template <class Out> friend auto operator<<(Out &out, PrintRange rng) -> Out & {
        if (rng.first_ != rng.last_) {
            rng.fun_(out, *rng.first_);
            for (++rng.first_; rng.first_ != rng.last_; ++rng.first_) {
                out << rng.sep_;
                rng.fun_(out, *rng.first_);
            }
        }
        return out;
    }
 
  private:
    It first_;
    It last_;
    char const *sep_;
    [[no_unique_address]] F fun_;
};
 
template <class It, class F> PrintRange(It, It, char const *, F &&) -> PrintRange<It, std::unwrap_ref_decay_t<F>>;
 
template <class F> class PrintFun {
  public:
    template <class A> PrintFun([[maybe_unused]] int tag, A &&fun) : fun_{std::forward<A>(fun)} {}
    template <class Out> friend auto operator<<(Out &out, PrintFun x) -> Out & {
        x.fun_(out);
        return out;
    }
 
  private:
    F fun_;
};
 
template <class F> PrintFun(int, F &&) -> PrintFun<std::unwrap_ref_decay_t<F>>;
 
class PrintQuoted {
  public:
    PrintQuoted(std::string_view str, bool fstring) : str_{str}, fstring_{fstring} {}
    template <class Out> friend auto operator<<(Out &out, PrintQuoted x) -> Out & {
        if (!x.fstring_) {
            out << '"';
        }
        for (auto c : x.str_) {
            if (c == '\\') {
                out << "\\\\";
            } else if (x.fstring_ && c == '{') {
                out << "{{";
            } else if (x.fstring_ && c == '}') {
                out << "}}";
            } else if (c == '\n') {
                out << "\\n";
            } else if (c == '\t') {
                out << "\\t";
            } else if (c == '"') {
                out << "\\\"";
            } else {
                out << c;
            }
        }
        if (!x.fstring_) {
            out << '"';
        }
        return out;
    }
 
  private:
    std::string_view str_;
    bool fstring_ = false;
};
 
} // namespace Detail
 
class fill {
  public:
    fill(size_t n, char c = ' ') : n_{n}, c_{c} {}
    friend auto operator<<(CppClingo::Util::OutputBuffer &out, fill const &x) -> CppClingo::Util::OutputBuffer & {
        std::ranges::fill(out.reserve(static_cast<std::ptrdiff_t>(x.n_)), x.c_);
        return out;
    }
 
  private:
    size_t n_;
    char c_;
};
 
template <class F> auto p_fun(F &&fun) {
    return Detail::PrintFun(0, std::forward<F>(fun));
}
 
template <class T, class F> auto p_range(T const &rng, char const *sep, F &&fun) {
    using std::begin, std::end;
    return Detail::PrintRange{begin(rng), end(rng), sep, std::forward<F>(fun)};
}
 
template <class T> auto p_range(T const &rng) {
    return p_range(rng, ",", Detail::PrintSelf{});
}
 
template <class T, class F> auto p_range(T const &rng, F &&fun) {
    return p_range(rng, ",", std::forward<F>(fun));
}
 
template <class T> auto p_range(T const &rng, char const *sep) {
    return p_range(rng, sep, Detail::PrintSelf{});
}
 
inline auto p_quoted(std::string_view str, bool fstring = false) {
    return Detail::PrintQuoted{str, fstring};
}
 
 
} // namespace CppClingo::Util