streamable.h

Go to the documentation of this file.

// Copyright (c) 2025 Clarisma / GeoDesk contributors
// SPDX-License-Identifier: LGPL-3.0-only
 
#pragma once
#include <iosfwd>      // forward declares std::ostream
#include <concepts>    // std::same_as
 
namespace clarisma
{
 
template<typename T>
concept OstreamFormattable =
    requires (const T& t, std::ostream& os)
{
    { t.template format<std::ostream>(os) } -> std::same_as<void>;
};
 
template<typename T>
    requires OstreamFormattable<T>
std::ostream& operator<<(std::ostream& os, const T& value)
{
    value.template format<std::ostream>(os);
    return os;
}
 
} // namespace clarisma
 
/*
 
#pragma once
#include <concepts>
#include <cstddef>
#include <type_traits>
 
namespace clarisma {
 
class Buffer;
 
template<typename S>
concept NotBufferLike =
    !std::is_base_of_v<Buffer, std::remove_reference_t<S>>;
 
template<typename S>
concept StreamLike =
    requires (S& s)
{
    // std::ostream-like: write(const char*, streamsize)
    s.write(static_cast<const char*>(nullptr), 0);
} ||
requires (S& s)
{
    // byte-sink-like: write(const void*, size_t)
    s.write(static_cast<const void*>(nullptr), std::size_t{});
};
 
template<typename T, typename S>
concept FormatsWith =
    requires (const T& t, S& s)
{
    { t.template format<S>(s) } -> std::same_as<void>;
};
 
template<typename Stream, typename T>
    requires NotBufferLike<Stream> && StreamLike<Stream> &&
             FormatsWith<T, Stream>
Stream& operator<<(Stream& s, const T& value)
{
    value.template format<Stream>(s);
    return s;
}
 
} // namespace clarisma
 
*/