samples_output.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: © 2026 Larry Chips <larry@larrychips.net>
 * SPDX-Licence-Identifier: MIT
 */
#ifndef UGMISC_SAMPLES_OUTPUT_HPP
#define UGMISC_SAMPLES_OUTPUT_HPP
 
#include <iostream>
#include <utility>
#include <type_traits>
 
 
enum SampleOutputTarget {
    SAMPLE_NORMAL_OUTPUT = 1,
    SAMPLE_TEST_OUTPUT = 2,
    SAMPLE_ALWAYS_OUTPUT = 3,
#ifdef UGMISC_SAMPLES_GENERATE_TEST_OUTPUT
    SAMPLE_ACTIVE_OUTPUT = SAMPLE_TEST_OUTPUT,
#else
    SAMPLE_ACTIVE_OUTPUT = SAMPLE_NORMAL_OUTPUT,
#endif
    SAMPLE_DEFAULT_OUTPUT = SAMPLE_NORMAL_OUTPUT
};
 
 
template<typename, SampleOutputTarget = SAMPLE_DEFAULT_OUTPUT>
class SampleOutput;

template<typename OS, SampleOutputTarget Target>
class SampleOutput {
    OS& stream;
 
    template<typename, SampleOutputTarget>
    friend class SampleOutput;
 
    static constexpr OS& autoStream() {
        constexpr bool is_cout_type = std::is_same_v< OS, std::ostream >;
        constexpr bool is_wcout_type = std::is_same_v< OS, std::wostream >;
 
        if constexpr ( is_cout_type ) {
            return std::cout;
        } else if constexpr ( is_wcout_type ) {
            return std::wcout;
        } else {
            static_assert(
                    false,
                    "Default init of ActiveOutput is only allowed for "
                    "ostream or wostream stream types."
                    );
        }
    }
 
    template<typename T> constexpr void ignoreType() {};
 
    constexpr bool doWrite(SampleOutputTarget tgt = Target) {
        return tgt == SAMPLE_ACTIVE_OUTPUT || tgt == SAMPLE_ALWAYS_OUTPUT;
    }
 
    template<typename T>
    constexpr void write(T&& v) {
        if constexpr ( doWrite() ) {
            stream << std::forward<T>(v);
        } else {
            // We still need this to fail if the actual write would not be
            // allowed to happen at compile time.
            // A compile error in the normal program is a compile error in the
            // test program and vice-versa.
            ignoreType<decltype(stream << std::forward<T>(v))>();
        }
    }
 
public:
    constexpr SampleOutput() : stream(autoStream()) { }
    SampleOutput(const SampleOutput&) = default;
    constexpr SampleOutput(OS& os) : stream(os) { }

    template<typename T, SampleOutputTarget Tgt>
    constexpr SampleOutput(const SampleOutput<T, Tgt>& other)
    : stream(other.stream)
    {
    }
 
    constexpr SampleOutput<OS, SAMPLE_NORMAL_OUTPUT> out() { return stream; }
    constexpr auto normal() { return out(); }
 
    constexpr SampleOutput<OS, SAMPLE_TEST_OUTPUT> expected() { return stream; }
    constexpr auto expect() { return expected(); }
 
    constexpr SampleOutput<OS, SAMPLE_ALWAYS_OUTPUT> always() { return stream; }
    constexpr auto both() { return always(); }
 
    template<typename T>
    constexpr SampleOutput& operator<< (T&& v) {
        write(std::forward<T>(v));
        return *this;
    }
};
 
template<typename T = std::ostream>
SampleOutput() -> SampleOutput<T>;
 
template<typename T>
SampleOutput(T&) -> SampleOutput<T>;
 
template<typename T, SampleOutputTarget Tgt>
SampleOutput(SampleOutput<T, Tgt>) -> SampleOutput<T>;
 
 
#endif /* UGMISC_SAMPLES_OUTPUT_HPP */