From 1e1d30d70143d6f79f699e47a222d5efef6e2654 Mon Sep 17 00:00:00 2001
From: skynowa <skynowa@gmail.com>
Date: Wed, 29 Apr 2026 00:31:46 +0300
Subject: [PATCH] AI-review: StdStream.inl (+5) [237+/101-] - review

---
 Print.h            |  13 ++++
 Print.inl          |  23 ++++++-
 StdStream.h        | 107 ++++++++++++++++++++++----------
 StdStream.inl      | 150 +++++++++++++++++++++++++--------------------
 StdStream_Test.cpp |  45 ++++++++++++++
 5 files changed, 237 insertions(+), 101 deletions(-)

diff --git a/Print.h b/Print.h
index fe5e4fd..cd7dc21 100644
--- a/Print.h
+++ b/Print.h
@@ -6,6 +6,13 @@
 
 #pragma once
 
+//-------------------------------------------------------------------------------------------------
+#include <cstdlib>
+#include <iterator>
+#include <ostream>
+#include <string>
+#include <typeinfo>
+#include <utility>
 //-------------------------------------------------------------------------------------------------
 namespace stdstream
 {
@@ -49,6 +56,12 @@ class Print final
 	template<typename IteratorT>
 	void _title(IteratorT first, IteratorT last);
 			///< contatiner title (name)
+	template<typename ValueT>
+	void _item(const ValueT &value);
+			///< container item
+	template<typename T1, typename T2>
+	void _item(const std::pair<T1, T2> &value);
+			///< std::pair item
 };
 
 } // ns stdstream
diff --git a/Print.inl b/Print.inl
index 594461b..e1dcd06 100644
--- a/Print.inl
+++ b/Print.inl
@@ -44,11 +44,11 @@ Print::range(
     }
 
     _os << "{";
-	_os << *a_first;
+	_item(*a_first);
 
     for (++ a_first; a_first != a_last; ++ a_first) {
         _os << _delimiter;
-        _os << *a_first;
+        _item(*a_first);
     }
 
     _os << "}";
@@ -87,6 +87,25 @@ Print::_title(
 	_os << _contName << " (size=" << valueSize << "): ";
 }
 //-------------------------------------------------------------------------------------------------
+template<typename ValueT>
+inline void
+Print::_item(
+	const ValueT &a_value ///< value
+)
+{
+	_os << a_value;
+}
+//-------------------------------------------------------------------------------------------------
+template<typename T1, typename T2>
+inline void
+Print::_item(
+	const std::pair<T1, T2> &a_value ///< value
+)
+{
+	_os << typeNameDemangle(a_value) << ": ";
+	_os << "{" << a_value.first << "," << a_value.second << "}";
+}
+//-------------------------------------------------------------------------------------------------
 template<typename T>
 inline std::string
 Print::typeNameDemangle(
diff --git a/StdStream.h b/StdStream.h
index 4aed3c2..7d546af 100644
--- a/StdStream.h
+++ b/StdStream.h
@@ -7,6 +7,8 @@
 #pragma once
 
 //-------------------------------------------------------------------------------------------------
+#include <cerrno>
+#include <cstring>
 #include <iostream>
 #include <sstream>
 #include <typeinfo>
@@ -25,6 +27,49 @@
 #include <unordered_map>
 #include <unordered_set>
 //-------------------------------------------------------------------------------------------------
+namespace stdstream
+{
+
+template<typename T>
+class TracePtrValue final
+{
+public:
+	explicit TracePtrValue(const T *ptr) :
+		_ptr {ptr}
+	{
+	}
+
+	std::ostream & print(std::ostream &os) const
+	{
+		if (_ptr == nullptr) {
+			os << "nullptr";
+		} else {
+			os << *_ptr;
+		}
+
+		return os;
+	}
+
+private:
+	const T *_ptr {};
+};
+
+template<typename T>
+TracePtrValue<T>
+tracePtrValue(const T *ptr)
+{
+	return TracePtrValue<T>(ptr);
+}
+
+template<typename T>
+std::ostream &
+operator << (std::ostream &os, const TracePtrValue<T> &value)
+{
+	return value.print(os);
+}
+
+} // namespace stdstream
+//-------------------------------------------------------------------------------------------------
 ///\name Trace variables (variable with value)
 ///\{
 #define STD_TRACE_VAR(v1) \
@@ -61,7 +106,7 @@
 #define STD_INVALID_VAR(v) \
 	"Invalid " << STD_TRACE_VAR(v)
 #define STD_TRACE_PTR(p) \
-	#p ": " << "{" << (p) << ", " << ((p) ? *(p) : 0) << "}"
+	#p ": " << "{" << static_cast<const void *>(p) << ", " << stdstream::tracePtrValue(p) << "}"
 #define STD_TITLE_VAR(v) \
 	"::::: " << (v) << " :::::"
 	///< trace variable as titlebar
@@ -121,53 +166,53 @@ auto operator << (std::ostream &os, const T &value) -> decltype(value.print(os),
 template<typename T1, typename T2>
 std::ostream & operator << (std::ostream &os, const std::pair<T1, T2> &value);
 
-template<typename T>
-std::ostream & operator << (std::ostream &os, const std::vector<T> &value);
+template<typename T, typename AllocT>
+std::ostream & operator << (std::ostream &os, const std::vector<T, AllocT> &value);
 
-template<typename T>
-std::ostream & operator << (std::ostream &os, const std::list<T> &value);
+template<typename T, typename AllocT>
+std::ostream & operator << (std::ostream &os, const std::list<T, AllocT> &value);
 
-template<typename T>
-std::ostream & operator << (std::ostream &os, const std::set<T> &value);
+template<typename T, typename CompareT, typename AllocT>
+std::ostream & operator << (std::ostream &os, const std::set<T, CompareT, AllocT> &value);
 
-template<typename T>
-std::ostream & operator << (std::ostream &os, const std::multiset<T> &value);
+template<typename T, typename CompareT, typename AllocT>
+std::ostream & operator << (std::ostream &os, const std::multiset<T, CompareT, AllocT> &value);
 
-template<typename T>
-std::ostream & operator << (std::ostream &os, const std::deque<T> &value);
+template<typename T, typename AllocT>
+std::ostream & operator << (std::ostream &os, const std::deque<T, AllocT> &value);
 
-template<typename T>
-std::ostream & operator << (std::ostream &os, const std::queue<T> &value);
+template<typename T, typename ContT>
+std::ostream & operator << (std::ostream &os, const std::queue<T, ContT> &value);
 
-template<typename T>
-std::ostream & operator << (std::ostream &os, const std::priority_queue<T> &value);
+template<typename T, typename ContT, typename CompareT>
+std::ostream & operator << (std::ostream &os, const std::priority_queue<T, ContT, CompareT> &value);
 
-template<typename T>
-std::ostream & operator << (std::ostream &os, const std::stack<T> &value);
+template<typename T, typename ContT>
+std::ostream & operator << (std::ostream &os, const std::stack<T, ContT> &value);
 
-template<typename T1, typename T2, class CompareT>
-std::ostream & operator << (std::ostream &os, const std::map<T1, T2, CompareT> &value);
+template<typename T1, typename T2, class CompareT, typename AllocT>
+std::ostream & operator << (std::ostream &os, const std::map<T1, T2, CompareT, AllocT> &value);
 
-template<typename T1, typename T2, class CompareT>
-std::ostream & operator << (std::ostream &os, const std::multimap<T1, T2> &value);
+template<typename T1, typename T2, class CompareT, typename AllocT>
+std::ostream & operator << (std::ostream &os, const std::multimap<T1, T2, CompareT, AllocT> &value);
 
 template<typename T, std::size_t N>
 std::ostream & operator << (std::ostream &os, const std::array<T, N> &value);
 
-template<typename T>
-std::ostream & operator << (std::ostream &os, const std::forward_list<T> &value);
+template<typename T, typename AllocT>
+std::ostream & operator << (std::ostream &os, const std::forward_list<T, AllocT> &value);
 
-template<typename T1, typename T2>
-std::ostream & operator << (std::ostream &os, const std::unordered_map<T1, T2> &value);
+template<typename T1, typename T2, typename HashT, typename KeyEqualT, typename AllocT>
+std::ostream & operator << (std::ostream &os, const std::unordered_map<T1, T2, HashT, KeyEqualT, AllocT> &value);
 
-template<typename T1, typename T2>
-std::ostream & operator << (std::ostream &os, const std::unordered_multimap<T1, T2> &value);
+template<typename T1, typename T2, typename HashT, typename KeyEqualT, typename AllocT>
+std::ostream & operator << (std::ostream &os, const std::unordered_multimap<T1, T2, HashT, KeyEqualT, AllocT> &value);
 
-template<typename T>
-std::ostream & operator << (std::ostream &os, const std::unordered_set<T> &value);
+template<typename T, typename HashT, typename KeyEqualT, typename AllocT>
+std::ostream & operator << (std::ostream &os, const std::unordered_set<T, HashT, KeyEqualT, AllocT> &value);
 
-template<typename T>
-std::ostream & operator << (std::ostream &os, const std::unordered_multiset<T> &value);
+template<typename T, typename HashT, typename KeyEqualT, typename AllocT>
+std::ostream & operator << (std::ostream &os, const std::unordered_multiset<T, HashT, KeyEqualT, AllocT> &value);
 
 template<typename... Args>
 std::ostream & operator << (std::ostream &os, const std::tuple<Args...> &value);
diff --git a/StdStream.inl b/StdStream.inl
index 1dd04f0..b2d77a8 100644
--- a/StdStream.inl
+++ b/StdStream.inl
@@ -39,11 +39,11 @@ operator << (
 	return a_os;
 }
 //-------------------------------------------------------------------------------------------------
-template<typename T>
+template<typename T, typename AllocT>
 inline std::ostream &
 operator << (
-	std::ostream         &a_os,
-	const std::vector<T> &a_value
+	std::ostream                 &a_os,
+	const std::vector<T, AllocT> &a_value
 )
 {
 	/// stdstream::Print print("std::vector", ",", a_os);
@@ -53,11 +53,11 @@ operator << (
 	return a_os;
 }
 //-------------------------------------------------------------------------------------------------
-template<typename T>
+template<typename T, typename AllocT>
 inline std::ostream &
 operator << (
-	std::ostream       &a_os,
-	const std::list<T> &a_value
+	std::ostream               &a_os,
+	const std::list<T, AllocT> &a_value
 )
 {
 	/// stdstream::Print print("std::list", ",", a_os);
@@ -67,11 +67,11 @@ operator << (
 	return a_os;
 }
 //-------------------------------------------------------------------------------------------------
-template<typename T>
+template<typename T, typename CompareT, typename AllocT>
 inline std::ostream &
 operator << (
-	std::ostream      &a_os,
-	const std::set<T> &a_value
+	std::ostream                         &a_os,
+	const std::set<T, CompareT, AllocT> &a_value
 )
 {
 	/// stdstream::Print print("std::set", ",", a_os);
@@ -81,11 +81,11 @@ operator << (
 	return a_os;
 }
 //-------------------------------------------------------------------------------------------------
-template<typename T>
+template<typename T, typename CompareT, typename AllocT>
 inline std::ostream &
 operator << (
-	std::ostream           &a_os,
-	const std::multiset<T> &a_value
+	std::ostream                              &a_os,
+	const std::multiset<T, CompareT, AllocT> &a_value
 )
 {
 	/// stdstream::Print print("std::multiset", ",", a_os);
@@ -95,11 +95,11 @@ operator << (
 	return a_os;
 }
 //-------------------------------------------------------------------------------------------------
-template<typename T>
+template<typename T, typename AllocT>
 inline std::ostream &
 operator << (
-	std::ostream        &a_os,
-	const std::deque<T> &a_value
+	std::ostream                &a_os,
+	const std::deque<T, AllocT> &a_value
 )
 {
 	/// stdstream::Print print("std::deque", ",", a_os);
@@ -109,68 +109,82 @@ operator << (
 	return a_os;
 }
 //-------------------------------------------------------------------------------------------------
-template<typename T>
+template<typename T, typename ContT>
 inline std::ostream &
 operator << (
-	std::ostream        &a_os,
-	const std::queue<T> &a_value
+	std::ostream               &a_os,
+	const std::queue<T, ContT> &a_value
 )
 {
-	using const_iterator = const T *;
+	std::vector<T> values;
+	values.reserve(a_value.size());
 
-    const_iterator it_cbegin = &a_value.front();
-    const_iterator it_cend   = &a_value.front() + a_value.size();
+	auto copy = a_value;
+	while ( !copy.empty() ) {
+		values.push_back(copy.front());
+		copy.pop();
+	}
 
-    /// stdstream::Print print("std::queue", ",", a_os);
-    stdstream::Print print(stdstream::Print::typeNameDemangle(a_value), ",", a_os);
-    print.range(it_cbegin, it_cend);
+	/// stdstream::Print print("std::queue", ",", a_os);
+	stdstream::Print print(stdstream::Print::typeNameDemangle(a_value), ",", a_os);
+	print.container(values);
 
 	return a_os;
 }
 //-------------------------------------------------------------------------------------------------
-template<typename T>
+template<typename T, typename ContT, typename CompareT>
 inline std::ostream &
 operator << (
-	std::ostream                 &a_os,
-	const std::priority_queue<T> &a_value
+	std::ostream                                &a_os,
+	const std::priority_queue<T, ContT, CompareT> &a_value
 )
 {
-    using const_iterator = const T *;
+	std::vector<T> values;
+	values.reserve(a_value.size());
 
-    const_iterator it_cbegin = &a_value.top();
-    const_iterator it_cend   = &a_value.top() + a_value.size();
+	auto copy = a_value;
+	while ( !copy.empty() ) {
+		values.push_back(copy.top());
+		copy.pop();
+	}
 
-    /// stdstream::Print print("std::priority_queue", ",", a_os);
-    stdstream::Print print(stdstream::Print::typeNameDemangle(a_value), ",", a_os);
-    print.range(it_cbegin, it_cend);
+	/// stdstream::Print print("std::priority_queue", ",", a_os);
+	stdstream::Print print(stdstream::Print::typeNameDemangle(a_value), ",", a_os);
+	print.container(values);
 
 	return a_os;
 }
 //-------------------------------------------------------------------------------------------------
-template<typename T>
+template<typename T, typename ContT>
 inline std::ostream &
 operator << (
-	std::ostream        &a_os,
-	const std::stack<T> &a_value
+	std::ostream               &a_os,
+	const std::stack<T, ContT> &a_value
 )
 {
-	using const_iterator = const T *;
+	std::vector<T> values;
+	values.reserve(a_value.size());
 
-    const_iterator it_cbegin = &a_value.top() - a_value.size() + 1;
-    const_iterator it_cend   = &a_value.top() + 1;
+	auto copy = a_value;
+	while ( !copy.empty() ) {
+		values.push_back(copy.top());
+		copy.pop();
+	}
 
-    /// stdstream::Print print("std::stack", ",", a_os);
-    stdstream::Print print(stdstream::Print::typeNameDemangle(a_value), ",", a_os);
-    print.range(it_cbegin, it_cend);
+	std::reverse(values.begin(), values.end());
+
+	/// stdstream::Print print("std::stack", ",", a_os);
+	stdstream::Print print(stdstream::Print::typeNameDemangle(a_value), ",", a_os);
+	print.container(values);
 
 	return a_os;
 }
 //-------------------------------------------------------------------------------------------------
-template<typename T1, typename T2, class CompareT>
+template<typename T1, typename T2, class CompareT, typename AllocT>
 inline std::ostream &
 operator << (
-	std::ostream                     &a_os,
-	const std::map<T1, T2, CompareT> &a_value
+	std::ostream                             &a_os,
+	const std::map<T1, T2, CompareT, AllocT> &a_value
 )
 {
 	/// stdstream::Print print("std::map", "\n", a_os);
@@ -180,11 +194,11 @@ operator << (
 	return a_os;
 }
 //-------------------------------------------------------------------------------------------------
-template<typename T1, typename T2, class CompareT>
+template<typename T1, typename T2, class CompareT, typename AllocT>
 inline std::ostream &
 operator << (
-	std::ostream                          &a_os,
-	const std::multimap<T1, T2, CompareT> &a_value
+	std::ostream                                  &a_os,
+	const std::multimap<T1, T2, CompareT, AllocT> &a_value
 )
 {
 	/// stdstream::Print print("std::multimap", "\n", a_os);
@@ -208,11 +222,11 @@ operator << (
 	return a_os;
 }
 //-------------------------------------------------------------------------------------------------
-template<typename T>
+template<typename T, typename AllocT>
 inline std::ostream &
 operator << (
-	std::ostream               &a_os,
-	const std::forward_list<T> &a_value
+	std::ostream                       &a_os,
+	const std::forward_list<T, AllocT> &a_value
 )
 {
 	/// stdstream::Print print("std::forward_list", ",", a_os);
@@ -222,11 +236,11 @@ operator << (
 	return a_os;
 }
 //-------------------------------------------------------------------------------------------------
-template<typename T1, typename T2>
+template<typename T1, typename T2, typename HashT, typename KeyEqualT, typename AllocT>
 inline std::ostream &
 operator << (
-	std::ostream                     &a_os,
-	const std::unordered_map<T1, T2> &a_value
+	std::ostream                                                   &a_os,
+	const std::unordered_map<T1, T2, HashT, KeyEqualT, AllocT> &a_value
 )
 {
 	/// stdstream::Print print("std::unordered_map", "\n", a_os);
@@ -236,11 +250,11 @@ operator << (
 	return a_os;
 }
 //-------------------------------------------------------------------------------------------------
-template<typename T1, typename T2>
+template<typename T1, typename T2, typename HashT, typename KeyEqualT, typename AllocT>
 inline std::ostream &
 operator << (
-	std::ostream                          &a_os,
-	const std::unordered_multimap<T1, T2> &a_value
+	std::ostream                                                        &a_os,
+	const std::unordered_multimap<T1, T2, HashT, KeyEqualT, AllocT> &a_value
 )
 {
 	/// stdstream::Print print("std::unordered_multimap", "\n", a_os);
@@ -250,11 +264,11 @@ operator << (
 	return a_os;
 }
 //-------------------------------------------------------------------------------------------------
-template<typename T>
+template<typename T, typename HashT, typename KeyEqualT, typename AllocT>
 inline std::ostream &
 operator << (
-	std::ostream                &a_os,
-	const std::unordered_set<T> &a_value
+	std::ostream                                             &a_os,
+	const std::unordered_set<T, HashT, KeyEqualT, AllocT> &a_value
 )
 {
 	/// stdstream::Print print("std::unordered_set", ",", a_os);
@@ -264,11 +278,11 @@ operator << (
 	return a_os;
 }
 //-------------------------------------------------------------------------------------------------
-template<typename T>
+template<typename T, typename HashT, typename KeyEqualT, typename AllocT>
 inline std::ostream &
 operator << (
-	std::ostream                     &a_os,
-	const std::unordered_multiset<T> &a_value
+	std::ostream                                                  &a_os,
+	const std::unordered_multiset<T, HashT, KeyEqualT, AllocT> &a_value
 )
 {
 	/// stdstream::Print print("std::unordered_multiset", ",", a_os);
@@ -312,15 +326,15 @@ operator << (
 	a_os << stdstream::Print::typeNameDemangle(a_value) << " (size=" << valueSize << "): ";
 
 	// body
-	if (valueSize == 0) {
+	if constexpr (valueSize == 0) {
         a_os << "{}";
 		return a_os;
+	} else {
+		a_os << "{";
+		TuplePrinter<decltype(a_value), sizeof...(ArgsT)>::print(a_os, a_value);
+		a_os << "}";
 	}
 
-	a_os << "{";
-	TuplePrinter<decltype(a_value), sizeof...(ArgsT)>::print(a_os, a_value);
-	a_os << "}";
-
 	return a_os;
 }
 //-------------------------------------------------------------------------------------------------
diff --git a/StdStream_Test.cpp b/StdStream_Test.cpp
index 8250296..9b076b1 100644
--- a/StdStream_Test.cpp
+++ b/StdStream_Test.cpp
@@ -22,6 +22,15 @@ int main(int, char **)
 		std::cout << value << std::endl << std::endl;
 	}
 
+	// std::queue with non-default container
+	{
+		std::queue<std::string, std::list<std::string>> value;
+		value.push("aaa");
+		value.push("bbb");
+		value.push("ccc");
+		std::cout << value << std::endl << std::endl;
+	}
+
 	// std::vector
 	{
 		std::vector<std::string> value;
@@ -31,6 +40,15 @@ int main(int, char **)
 		std::cout << value << std::endl << std::endl;
 	}
 
+	// std::stack with non-default container
+	{
+		std::stack<std::string, std::vector<std::string>> value;
+		value.push("aaa");
+		value.push("bbb");
+		value.push("ccc");
+		std::cout << value << std::endl << std::endl;
+	}
+
 	// std::list
 	{
 		std::list<std::string> value;
@@ -109,6 +127,21 @@ int main(int, char **)
 		std::cout << value << std::endl << std::endl;
 	}
 
+	// std::unordered_map with custom hash
+	{
+		struct StringHash
+		{
+			std::size_t operator () (const std::string &value) const
+			{
+				return std::hash<std::string>()(value);
+			}
+		};
+
+		std::unordered_map<std::string, std::string, StringHash> value;
+		value = {{"aaa", "000"}, {"bbb", "111"}};
+		std::cout << value << std::endl << std::endl;
+	}
+
 	// std::map
 	{
 		std::map<std::string, std::string, std::greater<std::string>> value;
@@ -190,6 +223,18 @@ int main(int, char **)
 		std::cout << value << std::endl << std::endl;
 	}
 
+	// std::tuple - empty
+	{
+		std::tuple<> value;
+		std::cout << value << std::endl << std::endl;
+	}
+
+	// STD_TRACE_PTR - null non-arithmetic pointer
+	{
+		std::string *value {};
+		std::cout << STD_TRACE_PTR(value) << std::endl << std::endl;
+	}
+
     return EXIT_SUCCESS;
 }
 //-------------------------------------------------------------------------------------------------