flatten 20260225

tjp/core/log/LogOf.h

@@ -0,0 +1,192 @@
+// License: Modified MIT (NON-AI)
+// See the LICENSE file in the root directory for license information.
+// Copyright 2025 Timothy Prepscius
+
+#pragma once
+
+#include "../type_traits/is_iterable.hpp"
+#include <sstream>
+#include <string>
+#include "demangle.h"
+
+#include "../types/Types+IO.h"
+
+namespace tjp::core {
+
+template<typename T>
+struct LogOf
+{
+	const T &t;
+	explicit LogOf(const T &t_) : t(t_) {}
+	
+	std::ostream &operator()(std::ostream &o) const
+	{
+		return o << t;
+	}
+} ;
+
+template<typename T>
+struct LogOfV
+{
+	T t;
+	explicit LogOfV(T t_) : t(t_) {}
+	
+	std::ostream &operator()(std::ostream &o) const
+	{
+		return o << t;
+	}
+} ;
+
+template<typename T>
+auto logOfV(T t) { return LogOfV<T>(t); }
+
+template<typename T>
+std::ostream &operator <<(std::ostream &o, const LogOf<T> &v)
+{
+	return v(o);
+}
+
+template<typename T>
+std::ostream &operator <<(std::ostream &o, const LogOfV<T> &v)
+{
+	return v(o);
+}
+
+template<typename T, typename std::enable_if<!is_iterable<T>::value, T>::type* = nullptr>
+auto logOf(const T &t);
+
+template<typename T, typename std::enable_if<is_iterable<T>::value, T>::type* = nullptr>
+auto logOf(const T &t);
+
+
+inline
+auto logOf(const std::string &t) { return t; }
+
+inline
+auto logOf(bool v) { return v ? "true" : "false"; }
+
+template<typename A, typename B>
+auto logOf(const std::pair<A,B> &t) {
+	std::ostringstream o;
+	o << "(" << logOf(t.first) << "," << logOf(t.second) << ")";
+	return o.str();
+}
+
+template<typename T, typename std::enable_if<!is_iterable<T>::value, T>::type*>
+auto logOf(const T &t) { return LogOf<T>(t); }
+
+template<typename T, typename std::enable_if<is_iterable<T>::value, T>::type*>
+auto logOf(const T &t) {
+	std::ostringstream o;
+	o << "[";
+	auto first = true;
+	for (auto v : t)
+	{
+		if (!first)
+		{
+			o << ",";
+		}
+		
+		o << logOf(v);
+		first = false;
+	}
+	o << "]";
+	
+	return o.str();
+}
+
+inline
+auto logOf(const std::string_view &v)
+{
+	return v;
+}
+
+template<typename T>
+struct NullOrValue
+{
+	const T *t;
+	explicit NullOrValue(const T *t_) : t(t_) {}
+} ;
+
+template<typename T>
+std::ostream &operator <<(std::ostream &o, const NullOrValue<T> &v)
+{
+	if (v.t)
+		return o << logOf(*v.t);
+		
+	return o << "null";
+}
+
+template<typename T>
+auto logOfRef(T *t)
+{
+	return NullOrValue<T>(t);
+}
+
+template<typename T>
+struct NullOrPtrValue
+{
+	const T *t;
+	explicit NullOrPtrValue(const T *t_) : t(t_) {}
+} ;
+
+template<typename T>
+std::ostream &operator <<(std::ostream &o, const NullOrPtrValue<T> &v)
+{
+	if (v.t)
+		return o << "[" << v.t << "] " << logOf(*v.t);
+		
+	return o << "null";
+}
+
+template<typename T>
+auto logPtrValue(T *t)
+{
+	return NullOrPtrValue<T>(t);
+}
+
+template<typename T>
+auto logPtr(T *t)
+{
+	return t;
+}
+
+template<typename T>
+struct SpaceBefore
+{
+	const T &t;
+} ;
+
+template<typename T>
+std::ostream &operator <<(std::ostream &o, const SpaceBefore<T> &v)
+{
+	return o << " " << logOf(v.t);
+}
+
+template<typename T>
+SpaceBefore<T> _logOf(const T &t)
+{
+	return SpaceBefore<T> { t };
+}
+
+template<typename T>
+auto logOfDispatch(T &&t)
+{
+	return logOf(std::forward<T>(t));
+}
+
+template<typename T>
+auto logOfDispatchV(T t)
+{
+	return logOfV(t);
+}
+
+#define logOfThis(x) "[" << tjp::core::logPtr(x) << "] "
+#define logVar(x) #x << " " << tjp::core::logOfDispatch(x) << " "
+#define logVarV(x) #x << " " << tjp::core::logOfDispatchV(x) << " "
+#define logType(x) #x << " " << tjp::core::type_id<x>().name() << " "
+#define logLabel(l) l << " "
+#define logLabelVar(l, x) l << " " << tjp::core::logOfDispatch(x) << " "
+#define logLabelVarV(l, x) l << " " << tjp::core::logOfDispatchV(x) << " "
+
+} // namespace