Removing a bunch of no-longer-useful code from stream.h/cpp in preparation for a greater purge

7 files changed, 41 insertions, 613 deletions

diff --git a/zencore/include/zencore/stream.h b/zencore/include/zencore/stream.h
index a0e165bdc..bab349068 100644
--- a/zencore/include/zencore/stream.h
+++ b/zencore/include/zencore/stream.h
@@ -14,42 +14,16 @@
 namespace zen {
 
 /**
- * Basic byte stream interface
- *
- * This is intended as a minimal base class offering only the absolute minimum of functionality.
- *
- * IMPORTANT: To better support concurrency, this abstraction offers no "file pointer". Thus
- * every read or write operation needs to specify the offset from which they wish to read.
- *
- * Most client code will likely want to use reader/writer classes like BinaryWriter/BinaryReader
- *
- */
-class OutStream : public RefCounted
-{
-public:
-	virtual void Write(const void* Data, size_t ByteCount, uint64_t Offset) = 0;
-	virtual void Flush()													= 0;
-};
-
-class InStream : public RefCounted
-{
-public:
-	virtual void	 Read(void* DataPtr, size_t ByteCount, uint64_t Offset) = 0;
-	virtual uint64_t Size() const											= 0;
-	uint64_t		 GetSize() const { return Size(); }
-};
-
-/**
  * Stream which writes into a growing memory buffer
  */
-class MemoryOutStream : public OutStream
+class MemoryOutStream : public RefCounted
 {
 public:
 	MemoryOutStream()  = default;
 	~MemoryOutStream() = default;
 
-	virtual void		  Write(const void* DataPtr, size_t ByteCount, uint64_t Offset) override;
-	virtual void		  Flush() override;
+	void				  Write(const void* DataPtr, size_t ByteCount, uint64_t Offset);
+	void				  Flush();
 	inline const uint8_t* Data() const { return m_Buffer.data(); }
 	inline const uint8_t* GetData() const { return m_Buffer.data(); }
 	inline uint64_t		  Size() const { return m_Buffer.size(); }
@@ -67,33 +41,13 @@ MakeMemoryView(const MemoryOutStream& Stream)
 }
 
 /**
- * Stream which reads from a memory buffer
- */
-class MemoryInStream : public InStream
-{
-public:
-	MemoryInStream(const void* Buffer, size_t Size);
-	MemoryInStream(MemoryView View) : MemoryInStream(View.GetData(), View.GetSize()) {}
-	~MemoryInStream() = default;
-
-	virtual void		  Read(void* DataPtr, size_t ByteCount, uint64_t ReadOffset) override;
-	virtual uint64_t	  Size() const override { return m_Buffer.size(); }
-	inline const uint8_t* Data() const { return m_Buffer.data(); }
-	inline const uint8_t* GetData() const { return m_Buffer.data(); }
-
-private:
-	RwLock				 m_Lock;
-	std::vector<uint8_t> m_Buffer;
-};
-
-/**
  * Binary stream writer
  */
 
 class BinaryWriter
 {
 public:
-	inline BinaryWriter(OutStream& Stream) : m_Stream(&Stream) {}
+	inline BinaryWriter(MemoryOutStream& Stream) : m_Stream(&Stream) {}
 	~BinaryWriter() = default;
 
 	inline void Write(const void* DataPtr, size_t ByteCount)
@@ -102,67 +56,33 @@ public:
 		m_Offset += ByteCount;
 	}
 
-	uint64_t CurrentOffset() const { return m_Offset; }
+	inline uint64_t CurrentOffset() const { return m_Offset; }
 
 private:
-	RefPtr<OutStream> m_Stream;
-	uint64_t		  m_Offset = 0;
+	RefPtr<MemoryOutStream> m_Stream;
+	uint64_t				m_Offset = 0;
 };
 
-inline BinaryWriter&
-operator<<(BinaryWriter& Writer, bool Value)
-{
-	Writer.Write(&Value, sizeof Value);
-	return Writer;
-}
-inline BinaryWriter&
-operator<<(BinaryWriter& Writer, int8_t Value)
-{
-	Writer.Write(&Value, sizeof Value);
-	return Writer;
-}
-inline BinaryWriter&
-operator<<(BinaryWriter& Writer, int16_t Value)
-{
-	Writer.Write(&Value, sizeof Value);
-	return Writer;
-}
-inline BinaryWriter&
-operator<<(BinaryWriter& Writer, int32_t Value)
-{
-	Writer.Write(&Value, sizeof Value);
-	return Writer;
-}
-inline BinaryWriter&
-operator<<(BinaryWriter& Writer, int64_t Value)
-{
-	Writer.Write(&Value, sizeof Value);
-	return Writer;
-}
-inline BinaryWriter&
-operator<<(BinaryWriter& Writer, uint8_t Value)
-{
-	Writer.Write(&Value, sizeof Value);
-	return Writer;
-}
-inline BinaryWriter&
-operator<<(BinaryWriter& Writer, uint16_t Value)
-{
-	Writer.Write(&Value, sizeof Value);
-	return Writer;
-}
-inline BinaryWriter&
-operator<<(BinaryWriter& Writer, uint32_t Value)
-{
-	Writer.Write(&Value, sizeof Value);
-	return Writer;
-}
-inline BinaryWriter&
-operator<<(BinaryWriter& Writer, uint64_t Value)
+/**
+ * Stream which reads from a memory buffer
+ */
+class MemoryInStream : public RefCounted
 {
-	Writer.Write(&Value, sizeof Value);
-	return Writer;
-}
+public:
+	MemoryInStream(const void* Buffer, size_t Size);
+	MemoryInStream(MemoryView View) : MemoryInStream(View.GetData(), View.GetSize()) {}
+	~MemoryInStream() = default;
+
+	void				  Read(void* DataPtr, size_t ByteCount, uint64_t ReadOffset);
+	uint64_t			  Size() const { return m_Buffer.size(); }
+	uint64_t			  GetSize() const { return Size(); }
+	inline const uint8_t* Data() const { return m_Buffer.data(); }
+	inline const uint8_t* GetData() const { return m_Buffer.data(); }
+
+private:
+	RwLock				 m_Lock;
+	std::vector<uint8_t> m_Buffer;
+};
 
 /**
  * Binary stream reader
@@ -171,7 +91,7 @@ operator<<(BinaryWriter& Writer, uint64_t Value)
 class BinaryReader
 {
 public:
-	inline BinaryReader(InStream& Stream) : m_Stream(&Stream) {}
+	inline BinaryReader(MemoryInStream& Stream) : m_Stream(&Stream) {}
 	~BinaryReader() = default;
 
 	inline void Read(void* DataPtr, size_t ByteCount)
@@ -196,8 +116,8 @@ public:
 	inline uint64_t AvailableBytes() const { return m_Stream->Size() - m_Offset; }
 
 private:
-	RefPtr<InStream> m_Stream;
-	uint64_t		 m_Offset = 0;
+	RefPtr<MemoryInStream> m_Stream;
+	uint64_t			   m_Offset = 0;
 };
 
 inline BinaryReader&
@@ -255,68 +175,6 @@ operator>>(BinaryReader& Reader, uint64_t& Value)
 	return Reader;
 }
 
-/**
- * Text stream writer
- */
-
-class TextWriter
-{
-public:
-	ZENCORE_API TextWriter(OutStream& Stream);
-	ZENCORE_API ~TextWriter();
-
-	ZENCORE_API virtual void Write(const void* DataPtr, size_t ByteCount);
-	ZENCORE_API void		 Writef(const char* FormatString, ...);
-
-	inline uint64_t CurrentOffset() const { return m_CurrentOffset; }
-
-private:
-	RefPtr<OutStream> m_Stream;
-	uint64_t		  m_CurrentOffset = 0;
-};
-
-ZENCORE_API TextWriter& operator<<(TextWriter& Writer, const char* Value);
-ZENCORE_API TextWriter& operator<<(TextWriter& Writer, const std::string_view& Value);
-ZENCORE_API TextWriter& operator<<(TextWriter& Writer, bool Value);
-ZENCORE_API TextWriter& operator<<(TextWriter& Writer, int8_t Value);
-ZENCORE_API TextWriter& operator<<(TextWriter& Writer, int16_t Value);
-ZENCORE_API TextWriter& operator<<(TextWriter& Writer, int32_t Value);
-ZENCORE_API TextWriter& operator<<(TextWriter& Writer, int64_t Value);
-ZENCORE_API TextWriter& operator<<(TextWriter& Writer, uint8_t Value);
-ZENCORE_API TextWriter& operator<<(TextWriter& Writer, uint16_t Value);
-ZENCORE_API TextWriter& operator<<(TextWriter& Writer, uint32_t Value);
-ZENCORE_API TextWriter& operator<<(TextWriter& Writer, uint64_t Value);
-
-class IndentTextWriter : public TextWriter
-{
-public:
-	ZENCORE_API IndentTextWriter(OutStream& stream);
-	ZENCORE_API ~IndentTextWriter();
-
-	ZENCORE_API virtual void Write(const void* DataPtr, size_t ByteCount) override;
-
-	inline void Indent(int Amount) { m_IndentAmount += Amount; }
-
-	struct Scope
-	{
-		Scope(IndentTextWriter& Outer, int IndentAmount = 2) : m_Outer(Outer), m_IndentAmount(IndentAmount)
-		{
-			m_Outer.Indent(IndentAmount);
-		}
-
-		~Scope() { m_Outer.Indent(-m_IndentAmount); }
-
-	private:
-		IndentTextWriter& m_Outer;
-		int				  m_IndentAmount;
-	};
-
-private:
-	int	 m_IndentAmount = 0;
-	int	 m_LineCursor	= 0;
-	char m_LineBuffer[2048];
-};
-
 void stream_forcelink();  // internal
 
 }  // namespace zen
diff --git a/zencore/include/zencore/streamutil.h b/zencore/include/zencore/streamutil.h
index 190cd18eb..d9b6b5167 100644
--- a/zencore/include/zencore/streamutil.h
+++ b/zencore/include/zencore/streamutil.h
@@ -14,55 +14,6 @@
 
 namespace zen {
 
-ZENCORE_API BinaryWriter& operator<<(BinaryWriter& writer, const std::string_view& value);
-ZENCORE_API BinaryReader& operator>>(BinaryReader& reader, std::string& value);
-
-ZENCORE_API BinaryWriter& operator<<(BinaryWriter& writer, const std::wstring_view& value);
-ZENCORE_API BinaryReader& operator>>(BinaryReader& reader, std::wstring& value);
-ZENCORE_API TextWriter& operator<<(TextWriter& writer, const std::wstring_view& value);
-
-inline BinaryWriter&
-operator<<(BinaryWriter& writer, const SHA1& value)
-{
-	writer.Write(value.Hash, sizeof value.Hash);
-	return writer;
-}
-inline BinaryReader&
-operator>>(BinaryReader& reader, SHA1& value)
-{
-	reader.Read(value.Hash, sizeof value.Hash);
-	return reader;
-}
-ZENCORE_API TextWriter& operator<<(TextWriter& writer, const zen::SHA1& value);
-
-inline BinaryWriter&
-operator<<(BinaryWriter& writer, const BLAKE3& value)
-{
-	writer.Write(value.Hash, sizeof value.Hash);
-	return writer;
-}
-inline BinaryReader&
-operator>>(BinaryReader& reader, BLAKE3& value)
-{
-	reader.Read(value.Hash, sizeof value.Hash);
-	return reader;
-}
-ZENCORE_API TextWriter& operator<<(TextWriter& writer, const BLAKE3& value);
-
-inline BinaryWriter&
-operator<<(BinaryWriter& writer, const IoHash& value)
-{
-	writer.Write(value.Hash, sizeof value.Hash);
-	return writer;
-}
-inline BinaryReader&
-operator>>(BinaryReader& reader, IoHash& value)
-{
-	reader.Read(value.Hash, sizeof value.Hash);
-	return reader;
-}
-ZENCORE_API TextWriter& operator<<(TextWriter& writer, const IoHash& value);
-
 }  // namespace zen
 
 //////////////////////////////////////////////////////////////////////////
diff --git a/zencore/stream.cpp b/zencore/stream.cpp
index ead0b014b..b9a88de66 100644
--- a/zencore/stream.cpp
+++ b/zencore/stream.cpp
@@ -48,234 +48,6 @@ MemoryOutStream::Flush()
 }
 
 //////////////////////////////////////////////////////////////////////////
-
-TextWriter::TextWriter(OutStream& stream) : m_Stream(&stream)
-{
-}
-
-TextWriter::~TextWriter() = default;
-
-void
-TextWriter::Write(const void* data, size_t byteCount)
-{
-	m_Stream->Write(data, byteCount, m_CurrentOffset);
-	m_CurrentOffset += byteCount;
-}
-
-TextWriter&
-operator<<(TextWriter& Writer, const char* value)
-{
-	if (value)
-		Writer.Write(value, strlen(value));
-	else
-		Writer.Write("(null)", 6);
-
-	return Writer;
-}
-
-TextWriter&
-operator<<(TextWriter& writer, const std::string_view& value)
-{
-	writer.Write(value.data(), value.size());
-
-	return writer;
-}
-
-TextWriter&
-operator<<(TextWriter& writer, bool value)
-{
-	if (value)
-		writer.Write("true", 4);
-	else
-		writer.Write("false", 5);
-
-	return writer;
-}
-
-TextWriter&
-operator<<(TextWriter& writer, int8_t value)
-{
-	char buffer[16];
-#if ZEN_PLATFORM_WINDOWS
-	_itoa_s(value, buffer, 10);
-#else
-	sprintf(buffer, "%d", value);
-#endif
-	writer << buffer;
-	return writer;
-}
-
-TextWriter&
-operator<<(TextWriter& writer, int16_t value)
-{
-	char buffer[16];
-#if ZEN_PLATFORM_WINDOWS
-	_itoa_s(value, buffer, 10);
-#else
-	sprintf(buffer, "%d", value);
-#endif
-	writer << buffer;
-	return writer;
-}
-
-TextWriter&
-operator<<(TextWriter& writer, int32_t value)
-{
-	char buffer[16];
-#if ZEN_PLATFORM_WINDOWS
-	_itoa_s(value, buffer, 10);
-#else
-	sprintf(buffer, "%d", value);
-#endif
-	writer << buffer;
-	return writer;
-}
-
-TextWriter&
-operator<<(TextWriter& writer, int64_t value)
-{
-	char buffer[32];
-#if ZEN_PLATFORM_WINDOWS
-	_i64toa_s(value, buffer, sizeof buffer, 10);
-#else
-	sprintf(buffer, "%" PRId64, value);
-#endif
-	writer << buffer;
-	return writer;
-}
-
-TextWriter&
-operator<<(TextWriter& writer, uint8_t value)
-{
-	char buffer[16];
-#if ZEN_PLATFORM_WINDOWS
-	_ultoa_s(value, buffer, 10);
-#else
-	sprintf(buffer, "%u", value);
-#endif
-	writer << buffer;
-	return writer;
-}
-
-TextWriter&
-operator<<(TextWriter& writer, uint16_t value)
-{
-	char buffer[16];
-#if ZEN_PLATFORM_WINDOWS
-	_ultoa_s(value, buffer, 10);
-#else
-	sprintf(buffer, "%u", value);
-#endif
-	writer << buffer;
-	return writer;
-}
-
-TextWriter&
-operator<<(TextWriter& writer, uint32_t value)
-{
-	char buffer[16];
-#if ZEN_PLATFORM_WINDOWS
-	_ultoa_s(value, buffer, 10);
-#else
-	sprintf(buffer, "%u", value);
-#endif
-	writer << buffer;
-	return writer;
-}
-
-TextWriter&
-operator<<(TextWriter& writer, uint64_t value)
-{
-	char buffer[32];
-#if ZEN_PLATFORM_WINDOWS
-	_ui64toa_s(value, buffer, sizeof buffer, 10);
-#else
-	sprintf(buffer, "%" PRIu64, value);
-#endif
-	writer << buffer;
-	return writer;
-}
-
-void
-TextWriter::Writef(const char* formatString, ...)
-{
-	va_list args;
-	va_start(args, formatString);
-
-	char* tempBuffer = nullptr;
-	char  buffer[4096];
-	int	  rv = vsnprintf(buffer, sizeof buffer, formatString, args);
-
-	ZEN_ASSERT(rv >= 0);
-
-	if (uint32_t(rv) > sizeof buffer)
-	{
-		// Need more room -- allocate temporary buffer
-
-		tempBuffer = (char*)Memory::Alloc(rv + 1, 8);
-
-		int rv2 = vsnprintf(tempBuffer, rv + 1, formatString, args);
-
-		ZEN_ASSERT(rv >= 0);
-		ZEN_ASSERT(rv2 <= rv);
-
-		rv = rv2;
-	}
-
-	m_Stream->Write(tempBuffer ? tempBuffer : buffer, rv, m_CurrentOffset);
-	m_CurrentOffset += rv;
-
-	if (tempBuffer)
-		Memory::Free(tempBuffer);
-
-	va_end(args);
-}
-
-//////////////////////////////////////////////////////////////////////////
-
-IndentTextWriter::IndentTextWriter(OutStream& stream) : TextWriter(stream)
-{
-}
-
-IndentTextWriter::~IndentTextWriter()
-{
-}
-
-void
-IndentTextWriter::Write(const void* data, size_t byteCount)
-{
-	const uint8_t* src = reinterpret_cast<const uint8_t*>(data);
-	int			   cur = m_LineCursor;
-
-	while (byteCount)
-	{
-		char c = *src++;
-
-		if (cur == 0)
-		{
-			const char indentSpaces[] =
-				"                                                                                                                          "
-				"                                                                              ";
-
-			cur = std::min<int>(m_IndentAmount, sizeof indentSpaces - 1);
-			memcpy(m_LineBuffer, indentSpaces, cur);
-		}
-
-		m_LineBuffer[cur++] = c;
-		--byteCount;
-
-		if (c == '\n' || cur == sizeof m_LineBuffer)
-		{
-			TextWriter::Write(m_LineBuffer, cur);
-
-			cur = 0;
-		}
-	}
-
-	m_LineCursor = cur;
-}
-
-//////////////////////////////////////////////////////////////////////////
 //
 // Testing related code follows...
 //
@@ -287,58 +59,6 @@ stream_forcelink()
 {
 }
 
-TEST_CASE("BinaryWriter and BinaryWriter")
-{
-	MemoryOutStream stream;
-	BinaryWriter	writer(stream);
-
-	CHECK(writer.CurrentOffset() == 0);
-
-	writer.Write("foo!", 4);
-	CHECK(writer.CurrentOffset() == 4);
-
-	writer << uint8_t(42) << uint16_t(42) << uint32_t(42) << uint64_t(42);
-	writer << int8_t(42) << int16_t(42) << int32_t(42) << int64_t(42);
-
-	CHECK(writer.CurrentOffset() == (4 + 15 * 2));
-
-	// Read the data back
-
-	MemoryInStream instream(stream.Data(), stream.Size());
-	BinaryReader   reader(instream);
-	CHECK(reader.CurrentOffset() == 0);
-
-	char buffer[4];
-	reader.Read(buffer, 4);
-	CHECK(reader.CurrentOffset() == 4);
-
-	CHECK(memcmp(buffer, "foo!", 4) == 0);
-
-	uint8_t	 ui8  = 0;
-	uint16_t ui16 = 0;
-	uint32_t ui32 = 0;
-	uint64_t ui64 = 0;
-	int8_t	 i8	  = 0;
-	int16_t	 i16  = 0;
-	int32_t	 i32  = 0;
-	int64_t	 i64  = 0;
-
-	reader >> ui8 >> ui16 >> ui32 >> ui64;
-	reader >> i8 >> i16 >> i32 >> i64;
-
-	CHECK(reader.CurrentOffset() == (4 + 15 * 2));
-
-	CHECK(ui8 == 42);
-	CHECK(ui16 == 42);
-	CHECK(ui32 == 42);
-	CHECK(ui64 == 42);
-
-	CHECK(i8 == 42);
-	CHECK(i16 == 42);
-	CHECK(i32 == 42);
-	CHECK(i64 == 42);
-}
-
 #endif
 
 }  // namespace zen
diff --git a/zencore/streamutil.cpp b/zencore/streamutil.cpp
deleted file mode 100644
index d3ed5ceaa..000000000
--- a/zencore/streamutil.cpp
+++ /dev/null
@@ -1,104 +0,0 @@
-// Copyright Epic Games, Inc. All Rights Reserved.
-
-#include <zencore/streamutil.h>
-#include <zencore/string.h>
-
-namespace zen {
-
-BinaryWriter&
-operator<<(BinaryWriter& writer, const std::string_view& value)
-{
-	writer.Write(value.data(), value.size());
-	writer << uint8_t(0);
-
-	return writer;
-}
-
-BinaryReader&
-operator>>(BinaryReader& reader, std::string& value)
-{
-	for (;;)
-	{
-		uint8_t x;
-		reader.Read(&x, 1);
-
-		if (x == 0)
-			return reader;
-
-		value.push_back(char(x));
-	}
-}
-
-BinaryWriter&
-operator<<(BinaryWriter& writer, const std::wstring_view& value)
-{
-	// write as utf8
-
-	ExtendableStringBuilder<128> utf8;
-	WideToUtf8(value, utf8);
-
-	writer.Write(utf8.c_str(), utf8.Size() + 1);
-
-	return writer;
-}
-
-BinaryReader&
-operator>>(BinaryReader& reader, std::wstring& value)
-{
-	// read as utf8
-
-	std::string v8;
-	reader >> v8;
-
-	ExtendableWideStringBuilder<128> wstr;
-	Utf8ToWide(v8, wstr);
-
-	value = wstr.c_str();
-
-	return reader;
-}
-
-TextWriter&
-operator<<(TextWriter& writer, const zen::SHA1& value)
-{
-	zen::SHA1::String_t buffer;
-	value.ToHexString(buffer);
-
-	writer.Write(buffer, zen::SHA1::StringLength);
-
-	return writer;
-}
-
-TextWriter&
-operator<<(TextWriter& writer, const zen::BLAKE3& value)
-{
-	zen::BLAKE3::String_t buffer;
-	value.ToHexString(buffer);
-
-	writer.Write(buffer, zen::BLAKE3::StringLength);
-
-	return writer;
-}
-
-TextWriter&
-operator<<(TextWriter& writer, const zen::IoHash& value)
-{
-	zen::IoHash::String_t buffer;
-	value.ToHexString(buffer);
-
-	writer.Write(buffer, zen::IoHash::StringLength);
-
-	return writer;
-}
-
-TextWriter&
-operator<<(TextWriter& writer, const std::wstring_view& value)
-{
-	ExtendableStringBuilder<128> v8;
-	WideToUtf8(value, v8);
-
-	writer.Write(v8.c_str(), v8.Size());
-	return writer;
-}
-
-}  // namespace zen
diff --git a/zencore/zencore.cpp b/zencore/zencore.cpp
index 0b94f3bea..f6abc2ee7 100644
--- a/zencore/zencore.cpp
+++ b/zencore/zencore.cpp
@@ -34,27 +34,30 @@ namespace zen {
 
 //////////////////////////////////////////////////////////////////////////
 
+// NOTE: This should just be removed
 bool
 IsPointerToStack(const void* ptr)
 {
 #if ZEN_PLATFORM_WINDOWS
-	ULONG_PTR low, high;
-	GetCurrentThreadStackLimits(&low, &high);
+	ULONG_PTR StackLow, StackHigh;
+	GetCurrentThreadStackLimits(&StackLow, &StackHigh);
 
 	const uintptr_t intPtr = reinterpret_cast<uintptr_t>(ptr);
 
-	return (intPtr - low) < (high - low);
+	const bool IsOnStack = (intPtr - StackLow) < (StackHigh - StackLow);
+	//ZEN_ASSERT(!IsOnStack);
+	return IsOnStack;
 #elif ZEN_PLATFORM_LINUX
 	pthread_t self = pthread_self();
 
 	pthread_attr_t attr;
 	pthread_getattr_np(self, &attr);
 
-	void*  low;
+	void*  StackLow;
 	size_t size;
-	pthread_attr_getstack(&attr, &low, &size);
+	pthread_attr_getstack(&attr, &StackLow, &size);
 
-	return (uintptr_t(ptr) - uintptr_t(low)) < uintptr_t(size);
+	return (uintptr_t(ptr) - uintptr_t(StackLow)) < uintptr_t(size);
 #elif 0
 #endif
 }
@@ -71,7 +74,7 @@ IsDebuggerPresent()
 
 std::optional<bool> InteractiveSessionFlag;
 
-void 
+void
 SetIsInteractiveSession(bool Value)
 {
 	InteractiveSessionFlag = Value;
diff --git a/zencore/zencore.vcxproj b/zencore/zencore.vcxproj
index 3adf779ed..947ae9f10 100644
--- a/zencore/zencore.vcxproj
+++ b/zencore/zencore.vcxproj
@@ -115,6 +115,7 @@
     <ClInclude Include="include\zencore\atomic.h" />
     <ClInclude Include="include\zencore\base64.h" />
     <ClInclude Include="include\zencore\blake3.h" />
+    <ClInclude Include="include\zencore\compactbinaryvalue.h" />
     <ClInclude Include="include\zencore\compositebuffer.h" />
     <ClInclude Include="include\zencore\crc32.h" />
     <ClInclude Include="include\zencore\endian.h" />
@@ -183,7 +184,6 @@
     <ClCompile Include="sharedbuffer.cpp" />
     <ClCompile Include="stats.cpp" />
     <ClCompile Include="stream.cpp" />
-    <ClCompile Include="streamutil.cpp" />
     <ClCompile Include="string.cpp" />
     <ClCompile Include="testutils.cpp" />
     <ClCompile Include="thread.cpp" />
diff --git a/zencore/zencore.vcxproj.filters b/zencore/zencore.vcxproj.filters
index 92aa0db1d..e3d1f6c67 100644
--- a/zencore/zencore.vcxproj.filters
+++ b/zencore/zencore.vcxproj.filters
@@ -45,6 +45,7 @@
     <ClInclude Include="include\zencore\testing.h" />
     <ClInclude Include="include\zencore\mpscqueue.h" />
     <ClInclude Include="include\zencore\base64.h" />
+    <ClInclude Include="include\zencore\compactbinaryvalue.h" />
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="sha1.cpp" />
@@ -57,7 +58,6 @@
     <ClCompile Include="refcount.cpp" />
     <ClCompile Include="stats.cpp" />
     <ClCompile Include="stream.cpp" />
-    <ClCompile Include="streamutil.cpp" />
     <ClCompile Include="string.cpp" />
     <ClCompile Include="thread.cpp" />
     <ClCompile Include="timer.cpp" />