debug_stream.hpp

Go to the documentation of this file.

// -----------------------------------------------------------------------------------------------------
// Copyright (c) 2006-2019, Knut Reinert & Freie Universität Berlin
// Copyright (c) 2016-2019, Knut Reinert & MPI für molekulare Genetik
// This file may be used, modified and/or redistributed under the terms of the 3-clause BSD-License
// shipped with this file and also available at: https://github.com/seqan/seqan3/blob/master/LICENSE.md
// -----------------------------------------------------------------------------------------------------

#pragma once

#include <ios>
#include <ostream>
#include <variant>

#include <seqan3/alphabet/concept.hpp>
#include <seqan3/alphabet/adaptation/uint.hpp>
#include <seqan3/core/add_enum_bitwise_operators.hpp>
#include <seqan3/core/concept/tuple.hpp>
#include <seqan3/core/type_traits/range.hpp>
#include <seqan3/io/stream/concept.hpp>
#include <seqan3/range/shortcuts.hpp>
#include <seqan3/std/ranges>

namespace seqan3
{

// ------------------------------------------------------------------
// seqan3::fmtflags2
// ------------------------------------------------------------------

enum fmtflags2
{
    none                = 0,        
    utf8                = 1,        
    small_int_as_number = 1 << 1,   
    default_            = small_int_as_number
};

template <>
constexpr bool add_enum_bitwise_operators<fmtflags2> = true;

// ------------------------------------------------------------------
// seqan3::debug_stream_type
// ------------------------------------------------------------------

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::ostream & out) : stream{&out}
    {}

    void set_underlying_stream(std::ostream & out)
    {
        stream = &out;
    }

    template <typename t>
    debug_stream_type & operator<<(t && v)
    {
        *stream << v;
        return *this;
    }

    debug_stream_type & operator<<(std::ostream&(*fp)(std::ostream&))
    {
        *stream << fp;
        return *this;
    }

    debug_stream_type & operator<<(int8_t const v)
    {
        if ((flags2() & fmtflags2::small_int_as_number) == fmtflags2::small_int_as_number)
            *stream << static_cast<int>(v);
        else
            *stream << v;
        return *this;
    }

    debug_stream_type & operator<<(uint8_t const v)
    {
        if ((flags2() & fmtflags2::small_int_as_number) == fmtflags2::small_int_as_number)
            *stream << static_cast<unsigned>(v);
        else
            *stream << v;
        return *this;
    }

    std::ios_base::fmtflags flags() const
    {
        return stream->flags();
    }

    std::ios_base::fmtflags flags(std::ios_base::fmtflags const flgs)
    {
        return stream->flags(flgs);
    }

    void setf(std::ios_base::fmtflags const flag)
    {
        stream->setf(flag);
    }

    void unsetf(std::ios_base::fmtflags const flag)
    {
        stream->unsetf(flag);
    }

    debug_stream_type & operator<<(std::ios_base::fmtflags const flag)
    {
        setf(flag);
        return *this;
    }

    fmtflags2 flags2() const
    {
        return flgs2;
    }

    fmtflags2 flags2(fmtflags2 flgs)
    {
        flgs2 = flgs;
        return flgs2;
    }

    void setf(fmtflags2 const flag)
    {
        flgs2 |= flag;
    }

    void unsetf(fmtflags2 const flag)
    {
        flgs2 &= ~flag;
    }

    debug_stream_type & operator<<(fmtflags2 const flag)
    {
        setf(flag);
        return *this;
    }

private:
    std::ostream *stream = &std::cerr;

    fmtflags2 flgs2{fmtflags2::default_};
};

// ------------------------------------------------------------------
// seqan3::debug_stream
// ------------------------------------------------------------------

inline debug_stream_type debug_stream{};

// ------------------------------------------------------------------
// overloads
// ------------------------------------------------------------------

template <Alphabet alphabet_t>
inline debug_stream_type & operator<<(debug_stream_type & s, alphabet_t const l)
    requires !OStream<std::ostream, alphabet_t>
{
    return s << to_char(l);
}

}

namespace seqan3::detail
{

template<typename tuple_t, std::size_t ...I>
void print_tuple(debug_stream_type & s, tuple_t && t, std::index_sequence<I...> const &)
{
    s << '(';
    ((s << (I == 0 ? "" : ",") << std::get<I>(t)), ...);
    s << ')';
}

} // namespace seqan3::detail

namespace seqan3
{

template <typename tuple_t>
    requires !std::ranges::InputRange<tuple_t> &&
             !Alphabet<tuple_t> && // exclude alphabet_tuple_base
             TupleLike<remove_cvref_t<tuple_t>>
inline debug_stream_type & operator<<(debug_stream_type & s, tuple_t && t)
{
    detail::print_tuple(s, std::forward<tuple_t>(t),
                        std::make_index_sequence<std::tuple_size_v<remove_cvref_t<tuple_t>>>{});
    return s;
}

template <typename variant_type>
    requires detail::is_type_specialisation_of_v<remove_cvref_t<variant_type>, std::variant>
inline debug_stream_type & operator<<(debug_stream_type & s, variant_type && v)
{
    if (!v.valueless_by_exception())
        std::visit([&s] (auto && arg) {s << arg;}, v);
    else
        s << "<VALUELESS_VARIANT>";
    return s;
}

template <typename optional_type>
    requires detail::is_type_specialisation_of_v<remove_cvref_t<optional_type>, std::optional>
inline debug_stream_type & operator<<(debug_stream_type & s, optional_type && arg)
{
    if (arg.has_value())
        s << *arg;
    else
        s << "<VALUELESS_OPTIONAL>";
    return s;
}

template <std::ranges::InputRange rng_t>
inline debug_stream_type & operator<<(debug_stream_type & s, rng_t && r)
    requires !std::Same<remove_cvref_t<reference_t<rng_t>>, remove_cvref_t<rng_t>> && // prevent recursive instantiation
             requires (reference_t<rng_t> l) { { debug_stream << l }; } &&
             // exclude null-terminated strings:
             !(std::is_pointer_v<std::decay_t<rng_t>> &&
               std::Same<remove_cvref_t<reference_t<rng_t>>, char>)
{
    if constexpr (Alphabet<reference_t<rng_t>> &&
                  !detail::is_uint_adaptation_v<remove_cvref_t<reference_t<rng_t>>>)
    {
        for (auto && l : r)
            s << l;
    }
    else
    {
        s << '[';
        auto b = begin(r);
        auto e = end(r);
        if (b != e)
        {
            s << *b;
            ++b;
        }
        while (b != e)
        {
            s << ',';
            s << *b;
            ++b;
        }
        s << ']';
    }

    return s;
}


} // namespace seqan3