debug_stream_type.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2006-2025 Knut Reinert & Freie Universität Berlin
// SPDX-FileCopyrightText: 2016-2025 Knut Reinert & MPI für molekulare Genetik
// SPDX-License-Identifier: BSD-3-Clause
 
#pragma once
 
#include <cassert>
#include <iosfwd>
#include <stdexcept>
 
#include <seqan3/core/add_enum_bitwise_operators.hpp>
#include <seqan3/core/debug_stream/default_printer.hpp>
#include <seqan3/utility/detail/type_name_as_string.hpp>
 
namespace seqan3
{
 
// ------------------------------------------------------------------
// seqan3::fmtflags2
// ------------------------------------------------------------------
 
enum class fmtflags2 : int8_t
{
    none = 0,                     
    utf8 = 1,                     
    small_int_as_number = 1 << 1, 
    default_ = small_int_as_number
};
enum class fmtflags2 : int8_t {…};
 
template <>
inline constexpr bool add_enum_bitwise_operators<fmtflags2> = true;
 
// ------------------------------------------------------------------
// seqan3::debug_stream_type
// ------------------------------------------------------------------
 
template <typename char_t = char>
class debug_stream_type
{
public:
    debug_stream_type() = default;                                      
    debug_stream_type(debug_stream_type const &) = default;             
    debug_stream_type(debug_stream_type &&) = default;                  
    debug_stream_type & operator=(debug_stream_type const &) = default; 
    debug_stream_type & operator=(debug_stream_type &&) = default;      
    ~debug_stream_type() = default;                                     
 
    constexpr explicit debug_stream_type(std::basic_ostream<char_t> & out) : stream{&out}
    {}
    constexpr explicit debug_stream_type(std::basic_ostream<char_t> & out) : stream{&out} {…}
 
    void set_underlying_stream(std::basic_ostream<char_t> & out)
    {
        stream = &out;
    }
    void set_underlying_stream(std::basic_ostream<char_t> & out) {…}
 
    std::basic_ostream<char_t> & get_underlying_stream() const noexcept
    {
        assert(stream != nullptr);
        return *stream;
    }
    std::basic_ostream<char_t> & get_underlying_stream() const noexcept {…}
 
    template <typename other_char_t, typename t>
    friend debug_stream_type<other_char_t> & operator<<(debug_stream_type<other_char_t> & s, t && v)
    {
        if constexpr (printable_with<default_printer, decltype(s), t>)
        {
            std::invoke(default_printer{}, s, std::forward<t>(v));
        }
        else
        {
            std::string const msg = "debug_stream has no print overload for type: " + detail::type_name_as_string<t>;
            throw std::runtime_error{msg};
        }
        return s;
    }
    friend debug_stream_type<other_char_t> & operator<<(debug_stream_type<other_char_t> & s, t && v) {…};
 
    debug_stream_type & operator<<(std::ostream & (*fp)(std::ostream &))
    {
        *stream << fp;
        return *this;
    }
    debug_stream_type & operator<<(std::ostream & (*fp)(std::ostream &)) {…}
 
 
    template <typename T>
    friend struct debug_stream_printer;
 
    template <typename T>
    friend struct std_printer;
 
    using fmtflags = typename std::basic_ostream<char_t>::fmtflags;
 
    fmtflags flags() const
    {
        return stream->flags();
    }
    fmtflags flags() const {…}
 
    fmtflags flags(fmtflags const flgs)
    {
        return stream->flags(flgs);
    }
    fmtflags flags(fmtflags const flgs) {…}
 
    void setf(fmtflags const flag)
    {
        stream->setf(flag);
    }
    void setf(fmtflags const flag) {…}
 
    void unsetf(fmtflags const flag)
    {
        stream->unsetf(flag);
    }
    void unsetf(fmtflags const flag) {…}
 
 
    fmtflags2 flags2() const
    {
        return flgs2;
    }
    fmtflags2 flags2() const {…}
 
    fmtflags2 flags2(fmtflags2 flgs)
    {
        flgs2 = flgs;
        return flgs2;
    }
    fmtflags2 flags2(fmtflags2 flgs) {…}
 
    void setf(fmtflags2 const flag)
    {
        flgs2 |= flag;
    }
    void setf(fmtflags2 const flag) {…}
 
    void unsetf(fmtflags2 const flag)
    {
        flgs2 &= ~flag;
    }
    void unsetf(fmtflags2 const flag) {…}
 
 
private:
    std::basic_ostream<char_t> * stream /* = &std::cerr*/;
 
    fmtflags2 flgs2{fmtflags2::default_};
};
class debug_stream_type {…};
 
template <typename value_t>
    requires (std::is_same_v<std::remove_cvref_t<value_t>, int8_t>
              || std::is_same_v<std::remove_cvref_t<value_t>, uint8_t>
              || std::is_same_v<std::remove_cvref_t<value_t>, fmtflags2>)
struct debug_stream_printer<value_t>
{
    template <typename char_t>
    constexpr void operator()(debug_stream_type<char_t> & stream, int8_t const v) const
    {
        if ((stream.flags2() & fmtflags2::small_int_as_number) == fmtflags2::small_int_as_number)
            *stream.stream << static_cast<int>(v);
        else
            *stream.stream << v;
    }
    constexpr void operator()(debug_stream_type<char_t> & stream, int8_t const v) const {…}
 
    template <typename char_t>
    constexpr void operator()(debug_stream_type<char_t> & stream, uint8_t const v) const
    {
        if ((stream.flags2() & fmtflags2::small_int_as_number) == fmtflags2::small_int_as_number)
            *stream.stream << static_cast<unsigned>(v);
        else
            *stream.stream << v;
    }
    constexpr void operator()(debug_stream_type<char_t> & stream, uint8_t const v) const {…}
 
    template <typename char_t>
    constexpr void operator()(debug_stream_type<char_t> & stream, fmtflags2 const flag) const
    {
        stream.setf(flag);
    }
    constexpr void operator()(debug_stream_type<char_t> & stream, fmtflags2 const flag) const {…}
};
struct debug_stream_printer<value_t> {…};
 
} // namespace seqan3