Added functionality to SharedBuffer/UniqueBuffer to support CompositeBuffer implementation

Most importantly, UniqueBuffer may now be "null", whereas previously it would never be.

2 files changed, 51 insertions, 17 deletions

diff --git a/zencore/include/zencore/sharedbuffer.h b/zencore/include/zencore/sharedbuffer.h
index fcf4eec83..5b950ee38 100644
--- a/zencore/include/zencore/sharedbuffer.h
+++ b/zencore/include/zencore/sharedbuffer.h
@@ -20,20 +20,30 @@ namespace zen {
 class UniqueBuffer
 {
 public:
-	UniqueBuffer(const UniqueBuffer&) = delete;
+	UniqueBuffer()				 = default;
+	UniqueBuffer(UniqueBuffer&&) = default;
+	UniqueBuffer& operator=(UniqueBuffer&&) = default;
+	UniqueBuffer(const UniqueBuffer&)		= delete;
 	UniqueBuffer& operator=(const UniqueBuffer&) = delete;
-	UniqueBuffer()								 = delete;
 
 	ZENCORE_API explicit UniqueBuffer(IoBufferCore* Owner);
 
-	void*		GetData() { return m_Buffer->MutableDataPointer(); }
-	const void* GetData() const { return m_Buffer->DataPointer(); }
-	size_t		GetSize() const { return m_Buffer->DataBytes(); }
-				operator MutableMemoryView() { return GetMutableView(); }
-				operator MemoryView() const { return GetView(); }
+	void*		GetData() { return m_Buffer ? m_Buffer->MutableDataPointer() : nullptr; }
+	const void* GetData() const { return m_Buffer ? m_Buffer->DataPointer() : nullptr; }
+	size_t		GetSize() const { return m_Buffer ? m_Buffer->DataBytes() : 0; }
 
-	inline MutableMemoryView GetMutableView() { return MutableMemoryView(m_Buffer->MutableDataPointer(), m_Buffer->DataBytes()); }
-	inline MemoryView		 GetView() const { return MemoryView(m_Buffer->MutableDataPointer(), m_Buffer->DataBytes()); }
+	operator MutableMemoryView() { return GetMutableView(); }
+	operator MemoryView() const { return GetView(); }
+
+	/**
+	 * Returns true if this does not point to a buffer owner.
+	 *
+	 * A null buffer is always owned, materialized, and empty.
+	 */
+	[[nodiscard]] inline bool IsNull() const { return m_Buffer.IsNull(); }
+
+	inline MutableMemoryView GetMutableView() { return MutableMemoryView(GetData(), GetSize()); }
+	inline MemoryView		 GetView() const { return MemoryView(GetData(), GetSize()); }
 
 	/** Make an uninitialized owned buffer of the specified size. */
 	ZENCORE_API static UniqueBuffer Alloc(uint64_t Size);
@@ -41,8 +51,15 @@ public:
 	/** Make a non-owned view of the input. */
 	ZENCORE_API static UniqueBuffer MakeMutableView(void* DataPtr, uint64_t Size);
 
+	/**
+	 * Convert this to an immutable shared buffer, leaving this null.
+	 *
+	 * Steals the buffer owner from the unique buffer.
+	 */
+	[[nodiscard]] ZENCORE_API SharedBuffer MoveToShared();
+
 private:
-	// This may never be null
+	// This may be null, for a default constructed UniqueBuffer only
 	RefPtr<IoBufferCore> m_Buffer;
 
 	friend class SharedBuffer;
@@ -59,6 +76,7 @@ public:
 	inline explicit SharedBuffer(IoBufferCore* Owner) : m_Buffer(Owner) {}
 	ZENCORE_API explicit SharedBuffer(IoBuffer&& Buffer) : m_Buffer(std::move(Buffer.m_Core)) {}
 	ZENCORE_API explicit SharedBuffer(const IoBuffer& Buffer) : m_Buffer(Buffer.m_Core) {}
+	ZENCORE_API explicit SharedBuffer(RefPtr<IoBufferCore>&& Owner) : m_Buffer(std::move(Owner)) {}
 
 	const void* GetData() const
 	{
@@ -84,11 +102,11 @@ public:
 		m_Buffer->SetIsImmutable(true);
 	}
 
-	ZENCORE_API void MakeOwned();
-	bool			 IsOwned() const { return m_Buffer && m_Buffer->IsOwned(); }
-	inline explicit	 operator bool() const { return m_Buffer; }
-	inline bool		 IsNull() const { return !m_Buffer; }
-	inline void		 Reset() { m_Buffer = nullptr; }
+	ZENCORE_API SharedBuffer& MakeOwned();
+	bool					  IsOwned() const { return m_Buffer && m_Buffer->IsOwned(); }
+	inline explicit			  operator bool() const { return m_Buffer; }
+	inline bool				  IsNull() const { return !m_Buffer; }
+	inline void				  Reset() { m_Buffer = nullptr; }
 
 	MemoryView GetView() const
 	{
diff --git a/zencore/sharedbuffer.cpp b/zencore/sharedbuffer.cpp
index bbbaa0b24..13924c520 100644
--- a/zencore/sharedbuffer.cpp
+++ b/zencore/sharedbuffer.cpp
@@ -35,17 +35,25 @@ UniqueBuffer::UniqueBuffer(IoBufferCore* Owner) : m_Buffer(Owner)
 {
 }
 
+SharedBuffer
+UniqueBuffer::MoveToShared()
+{
+	return SharedBuffer(std::move(m_Buffer));
+}
+
 //////////////////////////////////////////////////////////////////////////
 
 SharedBuffer::SharedBuffer(UniqueBuffer&& InBuffer) : m_Buffer(std::move(InBuffer.m_Buffer))
 {
 }
 
-void
+SharedBuffer&
 SharedBuffer::MakeOwned()
 {
 	if (IsOwned() || !m_Buffer)
-		return;
+	{
+		return *this;
+	}
 
 	const uint64_t Size		= m_Buffer->DataBytes();
 	void*		   Buffer	= Memory::Alloc(Size, 16);
@@ -55,6 +63,8 @@ SharedBuffer::MakeOwned()
 	memcpy(Buffer, m_Buffer->DataPointer(), Size);
 
 	m_Buffer = NewOwner;
+
+	return *this;
 }
 
 SharedBuffer
@@ -65,6 +75,12 @@ SharedBuffer::MakeView(MemoryView View, SharedBuffer OuterBuffer)
 		ZEN_ASSERT(OuterBuffer.GetView().Contains(View));
 	}
 
+	if (View == OuterBuffer.GetView())
+	{
+		// Reference to the full buffer contents, so just return the "outer"
+		return OuterBuffer;
+	}
+
 	IoBufferCore* NewCore = new IoBufferCore(OuterBuffer.m_Buffer, View.GetData(), View.GetSize());
 	NewCore->SetIsImmutable(true);
 	return SharedBuffer(NewCore);