CompactBinary: Restricted compact binary attachments to objects to simplify package management

based on CL16533710 @ p4

1 files changed, 134 insertions, 182 deletions

diff --git a/zencore/compactbinarypackage.cpp b/zencore/compactbinarypackage.cpp
index 411733a8c..92bb5d411 100644
--- a/zencore/compactbinarypackage.cpp
+++ b/zencore/compactbinarypackage.cpp
@@ -12,36 +12,24 @@ namespace zen {
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-CbAttachment::CbAttachment(CbFieldIterator InValue, const IoHash* const InHash)
+CbAttachment::CbAttachment(CbObject InValue, const IoHash* const InHash)
 {
-	if (InValue)
+	MemoryView View;
+	if (!InValue.IsOwned() || !InValue.TryGetSerializedView(View))
 	{
-		if (!InValue.IsOwned())
-		{
-			InValue = CbFieldIterator::CloneRange(InValue);
-		}
-
-		CompactBinary = CbFieldViewIterator(InValue);
-		Buffer		  = std::move(InValue).GetOuterBuffer();
+		InValue = CbObject::Clone(InValue);
 	}
 
+	Object = InValue.AsFieldView();
+	Buffer = std::move(InValue).GetBuffer();
+
 	if (InHash)
 	{
 		Hash = *InHash;
-		if (CompactBinary)
-		{
-			ZEN_ASSERT_SLOW(Hash == CompactBinary.GetRangeHash());
-		}
-		else
-		{
-#if 0
-			zenfs_assertSlow(Hash.IsZero(), TEXT("A null or empty field range must use a hash of zero."));
-#endif
-		}
 	}
-	else if (CompactBinary)
+	else
 	{
-		Hash = CompactBinary.GetRangeHash();
+		Hash = IoHash::HashMemory(Buffer);
 	}
 }
 
@@ -62,37 +50,10 @@ CbAttachment::CbAttachment(SharedBuffer InBuffer, const IoHash* const InHash) :
 			ZEN_ASSERT_SLOW(Hash == IoHash::Zero, TEXT("A null or empty buffer must use a hash of zero."));
 		}
 	}
-	else if (Buffer.GetSize())
-	{
-		Hash = IoHash::HashMemory(Buffer.GetData(), Buffer.GetSize());
-	}
 	else
 	{
-		Buffer.Reset();
-	}
-}
-
-SharedBuffer
-CbAttachment::AsBinaryView() const
-{
-	if (!CompactBinary)
-	{
-		return Buffer;
-	}
-
-	MemoryView SerializedView;
-	if (CompactBinary.TryGetSerializedRangeView(SerializedView))
-	{
-		return SerializedView == Buffer.GetView() ? Buffer : SharedBuffer::MakeView(SerializedView, Buffer);
+		Hash = IoHash::HashMemory(Buffer.GetData(), Buffer.GetSize());
 	}
-
-	return CbFieldIterator::CloneRange(CompactBinary).GetRangeBuffer();
-}
-
-CbFieldIterator
-CbAttachment::AsCompactBinary() const
-{
-	return CompactBinary ? CbFieldIterator::MakeRangeView(CompactBinary, Buffer) : CbFieldIterator();
 }
 
 bool
@@ -124,7 +85,7 @@ CbAttachment::TryLoad(CbFieldIterator& Fields)
 		}
 		if (Fields.IsObjectAttachment())
 		{
-			CompactBinary = CbFieldViewIterator::MakeRange(Buffer);
+			Object = CbFieldView(Buffer.GetData());
 		}
 		++Fields;
 	}
@@ -132,8 +93,8 @@ CbAttachment::TryLoad(CbFieldIterator& Fields)
 	{
 		++Fields;
 		Buffer.Reset();
-		CompactBinary.Reset();
-		Hash = IoHash::Zero;
+		Object = CbFieldView();
+		Hash   = IoHash::Zero;
 	}
 
 	return true;
@@ -150,8 +111,8 @@ CbAttachment::TryLoad(BinaryReader& Reader, BufferAllocator Allocator)
 	}
 	if (View.GetSize() > 0)
 	{
-		Buffer		  = SharedBuffer::MakeView(View, BufferField.GetOuterBuffer()).MakeOwned();
-		CompactBinary = CbFieldViewIterator();
+		Buffer = SharedBuffer::MakeView(View, BufferField.GetOuterBuffer()).MakeOwned();
+		Object = CbFieldView();
 
 		std::vector<uint8_t> HashBuffer;
 		CbField				 HashField = LoadCompactBinary(Reader, [&HashBuffer](uint64_t Size) -> UniqueBuffer {
@@ -165,14 +126,14 @@ CbAttachment::TryLoad(BinaryReader& Reader, BufferAllocator Allocator)
 		}
 		if (HashField.IsObjectAttachment())
 		{
-			CompactBinary = CbFieldViewIterator::MakeRange(Buffer);
+			Object = CbFieldView(Buffer.GetData());
 		}
 	}
 	else
 	{
 		Buffer.Reset();
-		CompactBinary.Reset();
-		Hash = IoHash::Zero;
+		Object = CbFieldView();
+		Hash   = IoHash::Zero;
 	}
 	return true;
 }
@@ -180,18 +141,13 @@ CbAttachment::TryLoad(BinaryReader& Reader, BufferAllocator Allocator)
 void
 CbAttachment::Save(CbWriter& Writer) const
 {
-	if (CompactBinary)
+	if (Object.IsObject())
 	{
-		MemoryView SerializedView;
-		if (CompactBinary.TryGetSerializedRangeView(SerializedView))
-		{
-			Writer.AddBinary(SerializedView);
-		}
-		else
+		Writer.AddBinary(Buffer);
+		if (CbFieldView(Object).AsObjectView())
 		{
-			Writer.AddBinary(AsBinaryView());
+			Writer.AddObjectAttachment(Hash);
 		}
-		Writer.AddObjectAttachment(Hash);
 	}
 	else if (Buffer && Buffer.GetSize())
 	{
@@ -231,7 +187,7 @@ CbPackage::SetObject(CbObject InObject, const IoHash* InObjectHash, AttachmentRe
 		}
 		if (InResolver)
 		{
-			GatherAttachments(Object.CreateIterator(), *InResolver);
+			GatherAttachments(Object, *InResolver);
 		}
 	}
 	else
@@ -250,9 +206,9 @@ CbPackage::AddAttachment(const CbAttachment& Attachment, AttachmentResolver* Res
 		if (It != Attachments.end() && *It == Attachment)
 		{
 			CbAttachment& Existing = *It;
-			if (Attachment.IsCompactBinary() && !Existing.IsCompactBinary())
+			if (Attachment.IsObject() && !Existing.IsObject())
 			{
-				Existing = CbAttachment(CbFieldIterator::MakeRange(Existing.AsBinaryView()));
+				Existing = CbAttachment(CbObject(Existing.AsBinary()), Existing.GetHash());
 			}
 		}
 		else
@@ -260,9 +216,9 @@ CbPackage::AddAttachment(const CbAttachment& Attachment, AttachmentResolver* Res
 			Attachments.insert(It, Attachment);
 		}
 
-		if (Attachment.IsCompactBinary() && Resolver)
+		if (Attachment.IsObject() && Resolver)
 		{
-			GatherAttachments(Attachment.AsCompactBinary(), *Resolver);
+			GatherAttachments(Attachment.AsObject(), *Resolver);
 		}
 	}
 }
@@ -294,16 +250,16 @@ CbPackage::FindAttachment(const IoHash& Hash) const
 }
 
 void
-CbPackage::GatherAttachments(const CbFieldViewIterator& Fields, AttachmentResolver Resolver)
+CbPackage::GatherAttachments(const CbObject& Value, AttachmentResolver Resolver)
 {
-	Fields.IterateRangeAttachments([this, &Resolver](CbFieldView Field) {
+	Value.IterateAttachments([this, &Resolver](CbFieldView Field) {
 		const IoHash& Hash = Field.AsAttachment();
 
 		if (SharedBuffer Buffer = Resolver(Hash))
 		{
 			if (Field.IsObjectAttachment())
 			{
-				AddAttachment(CbAttachment(CbFieldIterator::MakeRange(std::move(Buffer)), Hash), &Resolver);
+				AddAttachment(CbAttachment(CbObject(std::move(Buffer)), Hash), &Resolver);
 			}
 			else
 			{
@@ -404,7 +360,7 @@ CbPackage::TryLoad(BinaryReader& Reader, BufferAllocator Allocator, AttachmentRe
 				ZEN_ASSERT(!HashField.HasError(), "Attachments must be a non-empty binary value with a content hash.");
 				if (HashField.IsObjectAttachment())
 				{
-					AddAttachment(CbAttachment(CbFieldIterator::MakeRange(std::move(Buffer)), Hash));
+					AddAttachment(CbAttachment(CbObject(std::move(Buffer)), Hash));
 				}
 				else
 				{
@@ -512,10 +468,10 @@ TEST_CASE("usonpackage")
 		CbAttachment Attachment;
 		CHECK(Attachment.IsNull());
 		CHECK_FALSE(bool(Attachment));
-		CHECK_FALSE(bool(Attachment.AsBinaryView()));
-		CHECK_FALSE(Attachment.AsCompactBinary().HasValue());
+		CHECK_FALSE(bool(Attachment.AsBinary()));
+		CHECK_FALSE(bool(Attachment.AsObject()));
 		CHECK_FALSE(Attachment.IsBinary());
-		CHECK_FALSE(Attachment.IsCompactBinary());
+		CHECK_FALSE(Attachment.IsObject());
 		CHECK(Attachment.GetHash() == IoHash::Zero);
 		TestSaveLoadValidate("Null", Attachment);
 	}
@@ -526,28 +482,30 @@ TEST_CASE("usonpackage")
 		CbAttachment	   Attachment(Buffer);
 		CHECK_FALSE(Attachment.IsNull());
 		CHECK(bool(Attachment));
-		CHECK(Attachment.AsBinaryView() == Buffer);
-		CHECK_FALSE(Attachment.AsCompactBinary().HasValue());
+		CHECK(Attachment.AsBinary() == Buffer);
+		CHECK_FALSE(bool(Attachment.AsObject()));
 		CHECK(Attachment.IsBinary());
-		CHECK_FALSE(Attachment.IsCompactBinary());
+		CHECK_FALSE(Attachment.IsObject());
 		CHECK(Attachment.GetHash() == IoHash::HashMemory(Buffer));
 		TestSaveLoadValidate("Binary", Attachment);
 	}
 
-	SUBCASE("Compact Binary Attachment")
+	SUBCASE("Object Attachment")
 	{
 		CbWriter Writer;
+		Writer.BeginObject();
 		Writer << "Name"sv << 42;
-		CbFieldIterator Fields = Writer.Save();
-		CbAttachment	Attachment(Fields);
+		Writer.EndObject();
+		CbObject	 Object = Writer.Save().AsObject();
+		CbAttachment Attachment(Object);
 
 		CHECK_FALSE(Attachment.IsNull());
 		CHECK(bool(Attachment));
-		CHECK(Attachment.AsBinaryView() == Fields.GetRangeBuffer());
-		CHECK(Attachment.AsCompactBinary() == Fields);
+		CHECK(Attachment.AsBinary() == Object.GetBuffer());
+		CHECK(Attachment.AsObject().Equals(Object));
 		CHECK(Attachment.IsBinary());
-		CHECK(Attachment.IsCompactBinary());
-		CHECK(Attachment.GetHash() == Fields.GetRangeHash());
+		CHECK(Attachment.IsObject());
+		CHECK(Attachment.GetHash() == Object.GetHash());
 		TestSaveLoadValidate("CompactBinary", Attachment);
 	}
 
@@ -558,29 +516,31 @@ TEST_CASE("usonpackage")
 		CbAttachment  Attachment(Buffer);
 		CHECK_FALSE(Attachment.IsNull());
 		CHECK(bool(Attachment));
-		CHECK(Attachment.AsBinaryView().GetView().EqualBytes(Buffer.GetView()));
-		CHECK_FALSE(Attachment.AsCompactBinary().HasValue());
+		CHECK(Attachment.AsBinary().GetView().EqualBytes(Buffer.GetView()));
+		CHECK_FALSE(bool(Attachment.AsObject()));
 		CHECK(Attachment.IsBinary());
-		CHECK_FALSE(Attachment.IsCompactBinary());
+		CHECK_FALSE(Attachment.IsObject());
 		CHECK(Attachment.GetHash() == IoHash::HashMemory(Buffer));
 	}
 
-	SUBCASE("Compact Binary View")
+	SUBCASE("Object View")
 	{
 		CbWriter Writer;
+		Writer.BeginObject();
 		Writer << "Name"sv << 42;
-		CbFieldIterator Fields	   = Writer.Save();
-		CbFieldIterator FieldsView = CbFieldIterator::MakeRangeView(CbFieldViewIterator(Fields));
-		CbAttachment	Attachment(FieldsView);
+		Writer.EndObject();
+		CbObject	 Object		= Writer.Save().AsObject();
+		CbObject	 ObjectView = CbObject::MakeView(Object);
+		CbAttachment Attachment(ObjectView);
 
 		CHECK_FALSE(Attachment.IsNull());
 		CHECK(bool(Attachment));
 
-		CHECK(Attachment.AsBinaryView() != FieldsView.GetRangeBuffer());
-
-		CHECK(Attachment.AsCompactBinary().GetRangeView().EqualBytes(Fields.GetRangeView()));
+		CHECK(Attachment.AsBinary() != ObjectView.GetBuffer());
+		CHECK(Attachment.AsObject().Equals(Object));
 		CHECK(Attachment.IsBinary());
-		CHECK(Attachment.GetHash() == Fields.GetRangeHash());
+		CHECK(Attachment.IsObject());
+		CHECK(Attachment.GetHash() == IoHash(Object.GetHash()));
 	}
 
 	SUBCASE("Binary Load from View")
@@ -597,21 +557,23 @@ TEST_CASE("usonpackage")
 
 		CHECK_FALSE(Attachment.IsNull());
 		CHECK(bool(Attachment));
-		CHECK_FALSE(FieldsView.GetRangeBuffer().GetView().Contains(Attachment.AsBinaryView().GetView()));
-		CHECK(Attachment.AsBinaryView().GetView().EqualBytes(Buffer.GetView()));
-		CHECK_FALSE(Attachment.AsCompactBinary().HasValue());
+		CHECK_FALSE(FieldsView.GetRangeBuffer().GetView().Contains(Attachment.AsBinary().GetView()));
+		CHECK(Attachment.AsBinary().GetView().EqualBytes(Buffer.GetView()));
+		CHECK_FALSE(Attachment.AsObject());
 		CHECK(Attachment.IsBinary());
-		CHECK_FALSE(Attachment.IsCompactBinary());
+		CHECK_FALSE(Attachment.IsObject());
 		CHECK(Attachment.GetHash() == IoHash::HashMemory(MakeMemoryView(Value)));
 	}
 
-	SUBCASE("Compact Binary Load from View")
+	SUBCASE("Object Load from View")
 	{
 		CbWriter ValueWriter;
+		ValueWriter.BeginObject();
 		ValueWriter << "Name"sv << 42;
-		const CbFieldIterator Value = ValueWriter.Save();
+		ValueWriter.EndObject();
+		const CbObject Value = ValueWriter.Save().AsObject();
 
-		CHECK(ValidateCompactBinaryRange(Value.GetRangeView(), CbValidateMode::All) == CbValidateError::None);
+		CHECK(ValidateCompactBinaryRange(Value.GetView(), CbValidateMode::All) == CbValidateError::None);
 		CbAttachment Attachment(Value);
 
 		CbWriter Writer;
@@ -624,27 +586,12 @@ TEST_CASE("usonpackage")
 		CHECK_FALSE(Attachment.IsNull());
 		CHECK(bool(Attachment));
 
-		CHECK(Attachment.AsBinaryView().GetView().EqualBytes(Value.GetRangeView()));
-		CHECK_FALSE(FieldsView.GetRangeBuffer().GetView().Contains(Attachment.AsCompactBinary().GetRangeBuffer().GetView()));
+		CHECK(Attachment.AsBinary().GetView().EqualBytes(Value.GetView()));
+		CHECK_FALSE(FieldsView.GetBuffer().GetView().Contains(Attachment.AsObject().GetBuffer().GetView()));
 		CHECK(Attachment.IsBinary());
-		CHECK(Attachment.IsCompactBinary());
-
-		CHECK(Attachment.GetHash() == Value.GetRangeHash());
-	}
+		CHECK(Attachment.IsObject());
 
-	SUBCASE("Compact Binary Uniform Sub-View")
-	{
-		const SharedBuffer		  Buffer	  = SharedBuffer::Clone(MakeMemoryView<uint8_t>({0, 1, 2, 3}));
-		const CbFieldViewIterator FieldViews  = CbFieldViewIterator::MakeRange(Buffer.GetView().RightChop(2), CbFieldType::IntegerPositive);
-		const CbFieldIterator	  SavedFields = CbFieldIterator::CloneRange(FieldViews);
-		CbFieldIterator			  Fields	  = CbFieldIterator::MakeRangeView(FieldViews, Buffer);
-		CbAttachment			  Attachment(Fields);
-		const SharedBuffer		  Binary = Attachment.AsBinaryView();
-		CHECK(Attachment.AsCompactBinary() == Fields);
-		CHECK(Binary.GetSize() == SavedFields.GetRangeSize());
-		CHECK(Binary.GetView().EqualBytes(SavedFields.GetRangeView()));
-		CHECK(Attachment.GetHash() == SavedFields.GetRangeHash());
-		TestSaveLoadValidate("CompactBinaryUniformSubView", Attachment);
+		CHECK(Attachment.GetHash() == Value.GetHash());
 	}
 
 	SUBCASE("Binary Null")
@@ -653,28 +600,28 @@ TEST_CASE("usonpackage")
 
 		CHECK(Attachment.IsNull());
 		CHECK_FALSE(Attachment.IsBinary());
-		CHECK_FALSE(Attachment.IsCompactBinary());
-		CHECK(Attachment.GetHash() == IoHash::Zero);
+		CHECK_FALSE(Attachment.IsObject());
+		CHECK(Attachment.GetHash() == IoHash::HashMemory(SharedBuffer{}));
 	}
 
 	SUBCASE("Binary Empty")
 	{
-		const CbAttachment Attachment(SharedBuffer(UniqueBuffer::Alloc(0)));
+		const CbAttachment Attachment(UniqueBuffer::Alloc(0).MoveToShared());
 
-		CHECK(Attachment.IsNull());
-		CHECK_FALSE(Attachment.IsBinary());
-		CHECK_FALSE(Attachment.IsCompactBinary());
-		CHECK(Attachment.GetHash() == IoHash::Zero);
+		CHECK_FALSE(Attachment.IsNull());
+		CHECK(Attachment.IsBinary());
+		CHECK_FALSE(Attachment.IsObject());
+		CHECK(Attachment.GetHash() == IoHash::HashMemory(SharedBuffer{}));
 	}
 
-	SUBCASE("Compact Binary Empty")
+	SUBCASE("Object Empty")
 	{
-		const CbAttachment Attachment(CbFieldIterator{});
+		const CbAttachment Attachment(CbObject{});
 
-		CHECK(Attachment.IsNull());
-		CHECK_FALSE(Attachment.IsBinary());
-		CHECK_FALSE(Attachment.IsCompactBinary());
-		CHECK(Attachment.GetHash() == IoHash::Zero);
+		CHECK_FALSE(Attachment.IsNull());
+		CHECK(Attachment.IsBinary());
+		CHECK(Attachment.IsObject());
+		CHECK(Attachment.GetHash() == CbObject().GetHash());
 	}
 }
 
@@ -757,19 +704,26 @@ TEST_CASE("usonpackage.serialization")
 
 	// Attachment Only
 	{
-		CbObject Object;
+		CbObject Object1;
+		{
+			CbWriter Writer;
+			Writer.BeginObject();
+			Writer << "Field1" << 42;
+			Writer.EndObject();
+			Object1 = Writer.Save().AsObject();
+		}
+		CbObject Object2;
 		{
 			CbWriter Writer;
 			Writer.BeginObject();
-			Writer << "Field" << 42;
+			Writer << "Field2" << 42;
 			Writer.EndObject();
-			Object = Writer.Save().AsObject();
+			Object2 = Writer.Save().AsObject();
 		}
-		CbField Field = CbField::Clone(Object["Field"]);
 
 		CbPackage Package;
-		Package.AddAttachment(CbAttachment(CbFieldIterator::MakeSingle(Object.AsField())));
-		Package.AddAttachment(CbAttachment(Field.GetBuffer()));
+		Package.AddAttachment(CbAttachment(Object1));
+		Package.AddAttachment(CbAttachment(Object2.GetBuffer()));
 
 		CHECK_FALSE(Package.IsNull());
 		CHECK(bool(Package));
@@ -778,26 +732,23 @@ TEST_CASE("usonpackage.serialization")
 		CHECK(Package.GetObjectHash() == IoHash());
 		TestSaveLoadValidate("Attachments", Package);
 
-		const CbAttachment* const ObjectAttachment = Package.FindAttachment(Object.GetHash());
-		REQUIRE(ObjectAttachment);
+		const CbAttachment* const Object1Attachment = Package.FindAttachment(Object1.GetHash());
+		const CbAttachment* const Object2Attachment = Package.FindAttachment(Object2.GetHash());
 
-		const CbAttachment* const FieldAttachment = Package.FindAttachment(Field.GetHash());
-		REQUIRE(FieldAttachment);
+		CHECK((Object1Attachment && Object1Attachment->AsObject().Equals(Object1)));
+		CHECK((Object2Attachment && Object2Attachment->AsBinary() == Object2.GetBuffer()));
 
-		CHECK(ObjectAttachment->AsCompactBinary().AsObject().Equals(Object));
-		CHECK(FieldAttachment->AsBinaryView() == Field.GetBuffer());
-
-		Package.AddAttachment(CbAttachment(SharedBuffer::Clone(Object.GetView())));
-		Package.AddAttachment(CbAttachment(CbFieldIterator::CloneRange(CbFieldViewIterator::MakeSingle(Field))));
+		Package.AddAttachment(CbAttachment(SharedBuffer::Clone(Object1.GetView())));
+		Package.AddAttachment(CbAttachment(CbObject::Clone(Object2)));
 
 		CHECK(Package.GetAttachments().size() == 2);
-		CHECK(Package.FindAttachment(Object.GetHash()) == ObjectAttachment);
-		CHECK(Package.FindAttachment(Field.GetHash()) == FieldAttachment);
+		CHECK(Package.FindAttachment(Object1.GetHash()) == Object1Attachment);
+		CHECK(Package.FindAttachment(Object2.GetHash()) == Object2Attachment);
 
-		CHECK(ObjectAttachment->AsCompactBinary().AsObject().Equals(Object));
-		CHECK(ObjectAttachment->AsBinaryView() == Object.GetBuffer());
-		CHECK(FieldAttachment->AsCompactBinary().Equals(Field));
-		CHECK(FieldAttachment->AsBinaryView() == Field.GetBuffer());
+		CHECK((Object1Attachment && Object1Attachment->AsObject().Equals(Object1)));
+		CHECK((Object1Attachment && Object1Attachment->AsBinary() == Object1.GetBuffer()));
+		CHECK((Object2Attachment && Object2Attachment->AsObject().Equals(Object2)));
+		CHECK((Object2Attachment && Object2Attachment->AsBinary() == Object2.GetBuffer()));
 
 		CHECK(std::is_sorted(begin(Package.GetAttachments()), end(Package.GetAttachments())));
 	}
@@ -807,34 +758,35 @@ TEST_CASE("usonpackage.serialization")
 	SharedBuffer  Level4	 = SharedBuffer::MakeView(MakeMemoryView(Level4Values));
 	const IoHash  Level4Hash = IoHash::HashMemory(Level4);
 
-	CbField Level3;
+	CbObject Level3;
 	{
 		CbWriter Writer;
-		Writer.SetName("Level4").AddBinaryAttachment(Level4Hash);
-		Level3 = Writer.Save();
+		Writer.BeginObject();
+		Writer.AddBinaryAttachment("Level4", Level4Hash);
+		Writer.EndObject();
+		Level3 = Writer.Save().AsObject();
 	}
 	const IoHash Level3Hash = Level3.GetHash();
 
-	CbArray Level2;
+	CbObject Level2;
 	{
 		CbWriter Writer;
-		Writer.SetName("Level3");
-		Writer.BeginArray();
-		Writer.AddObjectAttachment(Level3Hash);
-		Writer.EndArray();
-		Level2 = Writer.Save().AsArray();
+		Writer.BeginObject();
+		Writer.AddObjectAttachment("Level3", Level3Hash);
+		Writer.EndObject();
+		Level2 = Writer.Save().AsObject();
 	}
-	const IoHash Level2Hash = Level2.AsFieldView().GetHash();
+	const IoHash Level2Hash = Level2.GetHash();
 
 	CbObject Level1;
 	{
 		CbWriter Writer;
 		Writer.BeginObject();
-		Writer.SetName("Level2").AddObjectAttachment(Level2Hash);
+		Writer.AddObjectAttachment("Level2", Level2Hash);
 		Writer.EndObject();
 		Level1 = Writer.Save().AsObject();
 	}
-	const IoHash Level1Hash = Level1.AsFieldView().GetHash();
+	const IoHash Level1Hash = Level1.GetHash();
 
 	const auto Resolver = [&Level2, &Level2Hash, &Level3, &Level3Hash, &Level4, &Level4Hash](const IoHash& Hash) -> SharedBuffer {
 		return Hash == Level2Hash	? Level2.GetBuffer()
@@ -858,10 +810,10 @@ TEST_CASE("usonpackage.serialization")
 		const CbAttachment* const Level2Attachment = Package.FindAttachment(Level2Hash);
 		const CbAttachment* const Level3Attachment = Package.FindAttachment(Level3Hash);
 		const CbAttachment* const Level4Attachment = Package.FindAttachment(Level4Hash);
-		CHECK((Level2Attachment && Level2Attachment->AsCompactBinary().AsArray().Equals(Level2)));
-		CHECK((Level3Attachment && Level3Attachment->AsCompactBinary().Equals(Level3)));
-		CHECK((Level4Attachment && Level4Attachment->AsBinaryView() != Level4 &&
-			   Level4Attachment->AsBinaryView().GetView().EqualBytes(Level4.GetView())));
+		CHECK((Level2Attachment && Level2Attachment->AsObject().Equals(Level2)));
+		CHECK((Level3Attachment && Level3Attachment->AsObject().Equals(Level3)));
+		CHECK((Level4Attachment && Level4Attachment->AsBinary() != Level4 &&
+			   Level4Attachment->AsBinary().GetView().EqualBytes(Level4.GetView())));
 
 		CHECK(std::is_sorted(begin(Package.GetAttachments()), end(Package.GetAttachments())));
 
@@ -913,16 +865,16 @@ TEST_CASE("usonpackage.serialization")
 
 		const MemoryView FieldsOuterBufferView = Fields.GetOuterBuffer().GetView();
 
-		CHECK(Level2Attachment->AsCompactBinary().AsArray().Equals(Level2));
-		CHECK(FieldsOuterBufferView.Contains(Level2Attachment->AsBinaryView().GetView()));
+		CHECK(Level2Attachment->AsObject().Equals(Level2));
+		CHECK(FieldsOuterBufferView.Contains(Level2Attachment->AsBinary().GetView()));
 		CHECK(Level2Attachment->GetHash() == Level2Hash);
 
-		CHECK(Level3Attachment->AsCompactBinary().Equals(Level3));
-		CHECK(FieldsOuterBufferView.Contains(Level3Attachment->AsBinaryView().GetView()));
+		CHECK(Level3Attachment->AsObject().Equals(Level3));
+		CHECK(FieldsOuterBufferView.Contains(Level3Attachment->AsBinary().GetView()));
 		CHECK(Level3Attachment->GetHash() == Level3Hash);
 
-		CHECK(Level4Attachment->AsBinaryView().GetView().EqualBytes(Level4.GetView()));
-		CHECK(FieldsOuterBufferView.Contains(Level4Attachment->AsBinaryView().GetView()));
+		CHECK(Level4Attachment->AsBinary().GetView().EqualBytes(Level4.GetView()));
+		CHECK(FieldsOuterBufferView.Contains(Level4Attachment->AsBinary().GetView()));
 		CHECK(Level4Attachment->GetHash() == Level4Hash);
 
 		MemoryOutStream WriteStream;
@@ -973,7 +925,7 @@ TEST_CASE("usonpackage.serialization")
 		bool	  bResolved = false;
 		CbPackage Package;
 		Package.AddAttachment(CbAttachment(Level3.GetBuffer()));
-		Package.AddAttachment(CbAttachment(CbFieldIterator::MakeSingle(Level3)), [&bResolved](const IoHash& Hash) -> SharedBuffer {
+		Package.AddAttachment(CbAttachment(Level3), [&bResolved](const IoHash& Hash) -> SharedBuffer {
 			ZEN_UNUSED(Hash);
 			bResolved = true;
 			return SharedBuffer();