1 files changed, 131 insertions, 3 deletions
diff --git a/zencore/compactbinarypackage.cpp b/zencore/compactbinarypackage.cpp
index 9b41fd3db..9a7e7c098 100644
--- a/zencore/compactbinarypackage.cpp
+++ b/zencore/compactbinarypackage.cpp
@@ -21,10 +21,8 @@ CbAttachment::CbAttachment(const SharedBuffer& InValue) : CbAttachment(Composite
 }
 
 CbAttachment::CbAttachment(const SharedBuffer& InValue, [[maybe_unused]] const IoHash& InHash)
-: CbAttachment(InValue.IsNull() ? CompressedBuffer()
-								: CompressedBuffer::Compress(InValue, OodleCompressor::NotSet, OodleCompressionLevel::None))
+: CbAttachment(CompositeBuffer(InValue), InHash)
 {
-	// This could be more efficient, and should at the very least try to validate the hash
 }
 
 CbAttachment::CbAttachment(const CompositeBuffer& InValue) : Value{std::in_place_type<BinaryValue>, InValue}
@@ -617,6 +615,136 @@ CbPackage::Save(BinaryWriter& StreamWriter) const
 	Writer.Save(StreamWriter);
 }
 
+//////////////////////////////////////////////////////////////////////////
+//
+// Legacy package serialization support
+//
+
+namespace legacy {
+
+	void SaveCbAttachment(const CbAttachment& Attachment, CbWriter& Writer)
+	{
+		if (Attachment.IsObject())
+		{
+			CbObject Object = Attachment.AsObject();
+			Writer.AddBinary(Object.GetBuffer());
+			if (Object)
+			{
+				Writer.AddObjectAttachment(Attachment.GetHash());
+			}
+		}
+		else if (Attachment.IsBinary())
+		{
+			Writer.AddBinary(Attachment.AsBinary());
+			Writer.AddBinaryAttachment(Attachment.GetHash());
+		}
+		else if (Attachment.IsNull())
+		{
+			Writer.AddBinary(MemoryView());
+		}
+		else
+		{
+			ZEN_NOT_IMPLEMENTED("Compressed binary is not supported in this serialization format");
+		}
+	}
+
+	void SaveCbPackage(const CbPackage& Package, CbWriter& Writer)
+	{
+		if (const CbObject& RootObject = Package.GetObject())
+		{
+			Writer.AddObject(RootObject);
+			Writer.AddObjectAttachment(Package.GetObjectHash());
+		}
+		for (const CbAttachment& Attachment : Package.GetAttachments())
+		{
+			SaveCbAttachment(Attachment, Writer);
+		}
+		Writer.AddNull();
+	}
+
+	void SaveCbPackage(const CbPackage& Package, BinaryWriter& Ar)
+	{
+		CbWriter Writer;
+		SaveCbPackage(Package, Writer);
+		Writer.Save(Ar);
+	}
+
+	bool TryLoadCbPackage(CbPackage& Package, IoBuffer InBuffer, BufferAllocator Allocator, CbPackage::AttachmentResolver* Mapper)
+	{
+		MemoryInStream InStream(InBuffer.Data(), InBuffer.Size());
+		BinaryReader   Reader(InStream);
+
+		return TryLoadCbPackage(Package, Reader, Allocator, Mapper);
+	}
+
+	bool TryLoadCbPackage(CbPackage& Package, BinaryReader& Reader, BufferAllocator Allocator, CbPackage::AttachmentResolver* Mapper)
+	{
+		Package = CbPackage();
+		for (;;)
+		{
+			CbField ValueField = LoadCompactBinary(Reader, Allocator);
+			if (!ValueField)
+			{
+				return false;
+			}
+			if (ValueField.IsNull())
+			{
+				return true;
+			}
+			if (ValueField.IsBinary())
+			{
+				const MemoryView View = ValueField.AsBinaryView();
+				if (View.GetSize() > 0)
+				{
+					SharedBuffer  Buffer	= SharedBuffer::MakeView(View, ValueField.GetOuterBuffer()).MakeOwned();
+					CbField		  HashField = LoadCompactBinary(Reader, Allocator);
+					const IoHash& Hash		= HashField.AsAttachment();
+					if (HashField.HasError() || IoHash::HashBuffer(Buffer) != Hash)
+					{
+						return false;
+					}
+					if (HashField.IsObjectAttachment())
+					{
+						Package.AddAttachment(CbAttachment(CbObject(std::move(Buffer)), Hash));
+					}
+					else
+					{
+						Package.AddAttachment(CbAttachment(CompositeBuffer(std::move(Buffer)), Hash));
+					}
+				}
+			}
+			else if (ValueField.IsHash())
+			{
+				const IoHash Hash = ValueField.AsHash();
+
+				ZEN_ASSERT(Mapper);
+
+				Package.AddAttachment(CbAttachment((*Mapper)(Hash), Hash));
+			}
+			else
+			{
+				CbObject Object = ValueField.AsObject();
+				if (ValueField.HasError())
+				{
+					return false;
+				}
+
+				if (Object)
+				{
+					CbField HashField  = LoadCompactBinary(Reader, Allocator);
+					IoHash	ObjectHash = HashField.AsObjectAttachment();
+					if (HashField.HasError() || Object.GetHash() != ObjectHash)
+					{
+						return false;
+					}
+					Package.SetObject(Object, ObjectHash);
+				}
+			}
+		}
+	}
+
+}  // namespace legacy
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 void