debug_stream_type.hpp

Go to the documentation of this file.

// -----------------------------------------------------------------------------------------------------
// Copyright (c) 2006-2020, Knut Reinert & Freie Universität Berlin
// Copyright (c) 2016-2020, 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 <iosfwd>
 
#include <seqan3/core/add_enum_bitwise_operators.hpp>
 
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
// ------------------------------------------------------------------
 
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}
    {}
 
    void set_underlying_stream(std::basic_ostream<char_t> & out)
    {
        stream = &out;
    }
 
    template <typename other_char_t, typename t>
    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<<(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;
    }
 
    using fmtflags = decltype(std::declval<std::basic_ostream<char_t>>().flags());
 
    fmtflags flags() const
    {
        return stream->flags();
    }
 
    fmtflags flags(fmtflags const flgs)
    {
        return stream->flags(flgs);
    }
 
    void setf(fmtflags const flag)
    {
        stream->setf(flag);
    }
 
    void unsetf(fmtflags const flag)
    {
        stream->unsetf(flag);
    }
 
    debug_stream_type & operator<<(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::basic_ostream<char_t> *stream/* = &std::cerr*/;
 
    fmtflags2 flgs2{fmtflags2::default_};
};
 
template <typename char_t, typename t>
debug_stream_type<char_t> & operator<<(debug_stream_type<char_t> & s, t && v)
{
    (*s.stream) << v;
    return s;
}
 
} // namespace seqan3