#pragma once
#include <iostream>
#include <mutex>

struct nonesuch {
    nonesuch() = delete;
    ~nonesuch() = delete;
    nonesuch(nonesuch const&) = delete;
    void operator=(nonesuch const&) = delete;
};

namespace detail {
    template <class Default, class AlwaysVoid,
        template<class...> class Op, class... Args>
    struct detector {
        using value_t = std::false_type;
        using type = Default;
    };

    template <class Default, template<class...> class Op, class... Args>
    struct detector<Default, std::void_t<Op<Args...>>, Op, Args...> {
        // Note that std::void_t is a C++17 feature
        using value_t = std::true_type;
        using type = Op<Args...>;
    };

} // namespace detail

template <template<class...> class Op, class... Args>
using is_detected = typename detail::detector<nonesuch, void, Op, Args...>::value_t;

template <template<class...> class Op, class... Args>
using detected_t = typename detail::detector<nonesuch, void, Op, Args...>::type;

template <class Default, template<class...> class Op, class... Args>
using detected_or = detail::detector<Default, void, Op, Args...>;

template<typename T>
using to_string_expression = decltype(std::declval<T>().toString());

template<typename T>
constexpr bool has_to_string = is_detected<to_string_expression, T>::value;

template<class T, typename std::enable_if<has_to_string<T>, int>::type = 0>
std::ostream& operator<<(std::ostream& out, T t) {
    return out << t.toString();
}

std::ostream& print_one(std::ostream& os);

template <class A0, class ...Args>
std::ostream& print_one(std::ostream& os, const A0& a0, const Args& ...args) {
    os << a0;
    return print_one(os, args...);
}

template <class ...Args>
std::ostream& print(std::ostream& os, const Args& ...args) {
    return print_one(os, args...);
}

std::mutex& get_cout_mutex();

template <class ...Args>
std::ostream& print(const Args& ...args) {
    std::lock_guard<std::mutex> _(get_cout_mutex());
    return print(std::cout, args...) << std::endl;
}