public void TestCollectionItemIdentifierWithDuplicates()
{
var container = new AssetPropertyGraphContainer(new AssetNodeContainer {
NodeBuilder = { NodeFactory = new AssetNodeFactory() }
});
var asset = new Types.MyAsset2 {
MyStrings = { "aaa", "bbb", "ccc" }
};
var ids = CollectionItemIdHelper.GetCollectionItemIds(asset.MyStrings);
ids.Add(0, IdentifierGenerator.Get(100));
ids.Add(1, IdentifierGenerator.Get(200));
ids.Add(2, IdentifierGenerator.Get(100));
var assetItem = new AssetItem("MyAsset", asset);
Assert.Equal(IdentifierGenerator.Get(100), ids[0]);
Assert.Equal(IdentifierGenerator.Get(200), ids[1]);
Assert.Equal(IdentifierGenerator.Get(100), ids[2]);
var graph = AssetQuantumRegistry.ConstructPropertyGraph(container, assetItem, null);
Assert.IsAssignableFrom <AssetObjectNode>(graph.RootNode);
Assert.True(CollectionItemIdHelper.TryGetCollectionItemIds(asset.MyStrings, out ids));
Assert.Equal(3, ids.KeyCount);
Assert.Equal(0, ids.DeletedCount);
Assert.Equal(IdentifierGenerator.Get(100), ids[0]);
Assert.Equal(IdentifierGenerator.Get(200), ids[1]);
Assert.NotEqual(IdentifierGenerator.Get(100), ids[2]);
Assert.NotEqual(IdentifierGenerator.Get(200), ids[2]);
}
/// <inheritdoc/>
protected override void TransformAfterDeserialization(IDictionary container, ITypeDescriptor targetDescriptor, object targetCollection, ICollection <ItemId> deletedItems = null)
{
var collectionDescriptor = (CollectionDescriptor)targetDescriptor;
var type = typeof(CollectionWithItemIds <>).MakeGenericType(collectionDescriptor.ElementType);
if (!type.IsInstanceOfType(container))
{
throw new InvalidOperationException("The given container does not match the expected type.");
}
var identifier = CollectionItemIdHelper.GetCollectionItemIds(targetCollection);
identifier.Clear();
var i = 0;
var enumerator = container.GetEnumerator();
while (enumerator.MoveNext())
{
collectionDescriptor.Add(targetCollection, enumerator.Value);
identifier.Add(i, (ItemId)enumerator.Key);
++i;
}
if (deletedItems != null)
{
foreach (var deletedItem in deletedItems)
{
identifier.MarkAsDeleted(deletedItem);
}
}
}
private bool ShouldGenerateItemIdCollection(object collection)
{
// Do not generate for value types (collections that are struct) or null
if (collection?.GetType().IsValueType != false)
{
return(false);
}
// Do not generate if within a type that doesn't use identifiable collections
if (inNonIdentifiableType > 0)
{
return(false);
}
// Do not generate if item id collection already exists
if (CollectionItemIdHelper.HasCollectionItemIds(collection))
{
return(false);
}
// Do not generate if the collection has been flagged to not be identifiable
if (nonIdentifiableCollection?.Contains(collection) == true)
{
return(false);
}
return(true);
}
private static void ClearNode(IUndoRedoService actionService, AssetViewModel asset, ItemToReload itemToReload)
{
// Get the node we want to change
var index = itemToReload.GraphPathIndex;
var node = itemToReload.GraphPath.GetNode();
var oldValue = node.Retrieve(index);
// Apply the change
// TODO: Share this code with ContentValueChangeOperation?
// TODO: How to better detect CollectionAdd vs ValueChange?
ContentChangeType operationType;
if (index != NodeIndex.Empty)
{
if (CollectionItemIdHelper.TryGetCollectionItemIds(node.Retrieve(), out CollectionItemIdentifiers ids))
{
itemToReload.ItemId = ids[index.Value];
}
operationType = ContentChangeType.CollectionRemove;
((IObjectNode)node).Remove(oldValue, index);
}
else
{
operationType = ContentChangeType.ValueChange;
((IMemberNode)node).Update(null);
}
// Save the change on the stack
var operation = new ContentValueChangeOperation(node, operationType, index, oldValue, null, Enumerable.Empty <IDirtiable>());
actionService.PushOperation(operation);
string operationName = $"Unload object {oldValue.GetType().Name} in asset {asset.Url}";
actionService.SetName(operation, operationName);
}
public override ObjectReference FindTargetReference(IGraphNode sourceNode, IGraphNode targetNode, ObjectReference sourceReference)
{
// Not identifiable - default applies
if (sourceReference.Index.IsEmpty || sourceReference.ObjectValue == null)
{
return(base.FindTargetReference(sourceNode, targetNode, sourceReference));
}
// Special case for objects that are identifiable: the object must be linked to the base only if it has the same id
var sourceAssetNode = (AssetObjectNode)sourceNode;
var targetAssetNode = (AssetObjectNode)targetNode;
if (!CollectionItemIdHelper.HasCollectionItemIds(sourceAssetNode.Retrieve()))
{
return(null);
}
// Enumerable reference: we look for an object with the same id
var targetReference = targetAssetNode.ItemReferences;
var sourceIds = CollectionItemIdHelper.GetCollectionItemIds(sourceNode.Retrieve());
var targetIds = CollectionItemIdHelper.GetCollectionItemIds(targetNode.Retrieve());
var itemId = sourceIds[sourceReference.Index.Value];
var targetKey = targetIds.GetKey(itemId);
foreach (var targetRef in targetReference)
{
if (Equals(targetRef.Index.Value, targetKey))
{
return(targetRef);
}
}
return(null);
}
private void AssetContentChanging(object sender, MemberNodeChangeEventArgs e)
{
var overrideValue = OverrideType.Base;
var node = (AssetMemberNode)e.Member;
// For value change and remove, we store the current override state.
if (e.ChangeType == ContentChangeType.ValueChange)
{
overrideValue = node.GetContentOverride();
}
else if (!node.IsNonIdentifiableCollectionContent)
{
overrideValue = node.GetItemOverride(e.Index);
if (e.ChangeType == ContentChangeType.CollectionRemove)
{
// For remove, we also collect the id of the item that will be removed, so we can pass it to the Changed event.
var itemId = ItemId.Empty;
CollectionItemIdentifiers ids;
if (CollectionItemIdHelper.TryGetCollectionItemIds(e.Member.Retrieve(), out ids))
{
ids.TryGet(e.Index.Value, out itemId);
}
removedItemIds[e.Member] = itemId;
}
}
previousOverrides[e.Member] = overrideValue;
}
private void AssetContentChanging(object sender, ContentChangeEventArgs e)
{
var overrideValue = OverrideType.Base;
var node = (AssetNode)e.Content.OwnerNode;
if (e.ChangeType == ContentChangeType.ValueChange || e.ChangeType == ContentChangeType.CollectionRemove)
{
// For value change and remove, we store the current override state.
if (e.Index == Index.Empty)
{
overrideValue = node.GetContentOverride();
}
else if (!node.IsNonIdentifiableCollectionContent)
{
overrideValue = node.GetItemOverride(e.Index);
}
}
if (e.ChangeType == ContentChangeType.CollectionRemove)
{
// For remove, we also collect the id of the item that will be removed, so we can pass it to the Changed event.
var itemId = ItemId.Empty;
CollectionItemIdentifiers ids;
if (CollectionItemIdHelper.TryGetCollectionItemIds(e.Content.Retrieve(), out ids))
{
ids.TryGet(e.Index.Value, out itemId);
}
removedItemIds[e.Content.OwnerNode] = itemId;
}
if (e.ChangeType == ContentChangeType.CollectionAdd && !node.IsNonIdentifiableCollectionContent)
{
// If the change is an add, we set the previous override as New so the Undo will try to remove the item instead of resetting to the base value
previousOverrides[e.Content.OwnerNode] = OverrideType.New;
}
previousOverrides[e.Content.OwnerNode] = overrideValue;
}
private void OnObjectDeserialized(int i, object newObject)
{
if (objectReferences != null && newObject != null)
{
var previousObject = objectReferences[i];
//// If the object is an attached reference, there is no need to copy the shadow object
//if (AttachedReferenceManager.GetAttachedReference(previousObject) != null)
//{
// return;
//}
ShadowObject.Copy(previousObject, newObject);
// NOTE: we don't use Add because of strings that might be duplicated
clonedObjectMapping[previousObject] = newObject;
if ((flags & AssetClonerFlags.RemoveItemIds) != AssetClonerFlags.RemoveItemIds)
{
CollectionItemIdentifiers sourceIds;
if (CollectionItemIdHelper.TryGetCollectionItemIds(previousObject, out sourceIds))
{
var newIds = CollectionItemIdHelper.GetCollectionItemIds(newObject);
sourceIds.CloneInto(newIds, clonedObjectMapping);
}
}
}
}
public void TestCloneCollectionIds()
{
var obj = new TestObjectWithCollection {
Name = "Test", Items = { "aaa", "bbb" }
};
var ids = CollectionItemIdHelper.GetCollectionItemIds(obj.Items);
ids.Add(0, new ItemId());
ids.Add(1, new ItemId());
ids.MarkAsDeleted(new ItemId());
var clone = AssetCloner.Clone(obj);
CollectionItemIdentifiers cloneIds;
var idsExist = CollectionItemIdHelper.TryGetCollectionItemIds(clone.Items, out cloneIds);
Assert.True(idsExist);
Assert.AreEqual(ids.KeyCount, cloneIds.KeyCount);
Assert.AreEqual(ids.DeletedCount, cloneIds.DeletedCount);
Assert.AreEqual(ids[0], cloneIds[0]);
Assert.AreEqual(ids[1], cloneIds[1]);
Assert.AreEqual(ids.DeletedItems.Single(), cloneIds.DeletedItems.Single());
clone = AssetCloner.Clone(obj, AssetClonerFlags.RemoveItemIds);
idsExist = CollectionItemIdHelper.TryGetCollectionItemIds(clone.Items, out cloneIds);
Assert.False(idsExist);
}
/// <inheritdoc/>
protected override object TransformForSerialization(ITypeDescriptor descriptor, object collection)
{
var instance = CreatEmptyContainer(descriptor);
CollectionItemIdentifiers identifier;
if (!CollectionItemIdHelper.TryGetCollectionItemIds(collection, out identifier))
{
identifier = new CollectionItemIdentifiers();
}
var i = 0;
foreach (var item in (IEnumerable)collection)
{
ItemId id;
if (!identifier.TryGet(i, out id))
{
id = ItemId.New();
identifier.Add(i, id);
}
instance.Add(id, item);
++i;
}
return(instance);
}
public void TestAddBaseRemoveDerivedAndAddInBaseWithSubDerived()
{
var asset = new Types.MyAsset2 {
MyStrings = { "String1", "String2" }
};
var context = DeriveAssetTest <Types.MyAsset2, Types.MyAssetBasePropertyGraph> .DeriveAsset(asset);
var baseIds = CollectionItemIdHelper.GetCollectionItemIds(context.BaseAsset.MyStrings);
var derivedIds = CollectionItemIdHelper.GetCollectionItemIds(context.DerivedAsset.MyStrings);
var subDerivedIds = CollectionItemIdHelper.GetCollectionItemIds(context.SubDerivedAsset.MyStrings);
var basePropertyNode = context.BaseGraph.RootNode[nameof(Types.MyAsset2.MyStrings)];
var derivedPropertyNode = context.DerivedGraph.RootNode[nameof(Types.MyAsset2.MyStrings)];
var subDerivedPropertyNode = context.SubDerivedGraph.RootNode[nameof(Types.MyAsset2.MyStrings)];
// Delete an item from the derived and then update the same from the base
basePropertyNode.Target.Add("String3");
var derivedDeletedId = derivedIds[2];
derivedPropertyNode.Target.Remove("String3", new NodeIndex(2));
basePropertyNode.Target.Add("String4");
Assert.Equal(4, context.BaseAsset.MyStrings.Count);
Assert.Equal(3, context.DerivedAsset.MyStrings.Count);
Assert.Equal(3, context.SubDerivedAsset.MyStrings.Count);
Assert.Equal("String1", basePropertyNode.Retrieve(new NodeIndex(0)));
Assert.Equal("String2", basePropertyNode.Retrieve(new NodeIndex(1)));
Assert.Equal("String3", basePropertyNode.Retrieve(new NodeIndex(2)));
Assert.Equal("String4", basePropertyNode.Retrieve(new NodeIndex(3)));
Assert.Equal("String1", derivedPropertyNode.Retrieve(new NodeIndex(0)));
Assert.Equal("String2", derivedPropertyNode.Retrieve(new NodeIndex(1)));
Assert.Equal("String4", derivedPropertyNode.Retrieve(new NodeIndex(2)));
Assert.Equal("String1", subDerivedPropertyNode.Retrieve(new NodeIndex(0)));
Assert.Equal("String2", subDerivedPropertyNode.Retrieve(new NodeIndex(1)));
Assert.Equal("String4", subDerivedPropertyNode.Retrieve(new NodeIndex(2)));
Assert.Equal(OverrideType.Base, basePropertyNode.GetContentOverride());
Assert.Equal(OverrideType.Base, basePropertyNode.Target.GetItemOverride(new NodeIndex(0)));
Assert.Equal(OverrideType.Base, basePropertyNode.Target.GetItemOverride(new NodeIndex(1)));
Assert.Equal(OverrideType.Base, basePropertyNode.Target.GetItemOverride(new NodeIndex(2)));
Assert.Equal(OverrideType.Base, basePropertyNode.Target.GetItemOverride(new NodeIndex(3)));
Assert.Equal(OverrideType.Base, derivedPropertyNode.GetContentOverride());
Assert.Equal(OverrideType.Base, derivedPropertyNode.Target.GetItemOverride(new NodeIndex(0)));
Assert.Equal(OverrideType.Base, derivedPropertyNode.Target.GetItemOverride(new NodeIndex(1)));
Assert.Equal(OverrideType.Base, derivedPropertyNode.Target.GetItemOverride(new NodeIndex(2)));
Assert.Equal(OverrideType.Base, subDerivedPropertyNode.GetContentOverride());
Assert.Equal(OverrideType.Base, subDerivedPropertyNode.Target.GetItemOverride(new NodeIndex(0)));
Assert.Equal(OverrideType.Base, subDerivedPropertyNode.Target.GetItemOverride(new NodeIndex(1)));
Assert.Equal(OverrideType.Base, subDerivedPropertyNode.Target.GetItemOverride(new NodeIndex(2)));
Assert.Equal(4, baseIds.KeyCount);
Assert.Equal(0, baseIds.DeletedCount);
Assert.Equal(3, derivedIds.KeyCount);
Assert.Equal(1, derivedIds.DeletedCount);
Assert.Equal(3, subDerivedIds.KeyCount);
Assert.Equal(0, subDerivedIds.DeletedCount);
Assert.Equal(baseIds[0], derivedIds[0]);
Assert.Equal(baseIds[1], derivedIds[1]);
Assert.Equal(baseIds[3], derivedIds[2]);
Assert.Equal(derivedIds[0], subDerivedIds[0]);
Assert.Equal(derivedIds[1], subDerivedIds[1]);
Assert.Equal(derivedIds[2], subDerivedIds[2]);
Assert.True(derivedIds.IsDeleted(derivedDeletedId));
}
/// <inheritdoc/>
protected override object TransformForSerialization(ITypeDescriptor descriptor, object collection)
{
var dictionaryDescriptor = (DictionaryDescriptor)descriptor;
var instance = CreatEmptyContainer(descriptor);
CollectionItemIdentifiers identifier;
if (!CollectionItemIdHelper.TryGetCollectionItemIds(collection, out identifier))
{
identifier = new CollectionItemIdentifiers();
}
var keyWithIdType = typeof(KeyWithId <>).MakeGenericType(dictionaryDescriptor.KeyType);
foreach (var item in dictionaryDescriptor.GetEnumerator(collection))
{
ItemId id;
if (!identifier.TryGet(item.Key, out id))
{
id = ItemId.New();
identifier.Add(item.Key, id);
}
var keyWithId = Activator.CreateInstance(keyWithIdType, id, item.Key);
instance.Add(keyWithId, item.Value);
}
return(instance);
}
public void TestDictionaryDeserialization()
{
ShadowObject.Enable = true;
var stream = new MemoryStream();
var writer = new StreamWriter(stream);
writer.Write(YamlDictionary);
writer.Flush();
stream.Position = 0;
var instance = AssetYamlSerializer.Default.Deserialize(stream);
Assert.NotNull(instance);
Assert.Equal(typeof(ContainerDictionary), instance.GetType());
var obj = (ContainerDictionary)instance;
Assert.Equal("Root", obj.Name);
Assert.Equal(2, obj.Strings.Count);
Assert.Equal("aaa", obj.Strings[GuidGenerator.Get(200)]);
Assert.Equal("bbb", obj.Strings[GuidGenerator.Get(100)]);
Assert.Equal(2, obj.Objects.Count);
Assert.Equal("obj1", obj.Objects["key3"].Name);
Assert.Equal("obj2", obj.Objects["key4"].Name);
var stringIds = CollectionItemIdHelper.GetCollectionItemIds(obj.Strings);
Assert.Equal(IdentifierGenerator.Get(2), stringIds[GuidGenerator.Get(200)]);
Assert.Equal(IdentifierGenerator.Get(1), stringIds[GuidGenerator.Get(100)]);
var objectIds = CollectionItemIdHelper.GetCollectionItemIds(obj.Objects);
Assert.Equal(IdentifierGenerator.Get(3), objectIds["key3"]);
Assert.Equal(IdentifierGenerator.Get(4), objectIds["key4"]);
}
public void TestDictionarySerializationWithDeleted()
{
ShadowObject.Enable = true;
var obj = new ContainerDictionary("Root")
{
Strings = { { GuidGenerator.Get(200), "aaa" }, { GuidGenerator.Get(100), "bbb" } },
Objects = { { "key3", new ContainerCollection("obj1") }, { "key4", new ContainerCollection("obj2") } },
};
var stringIds = CollectionItemIdHelper.GetCollectionItemIds(obj.Strings);
stringIds[GuidGenerator.Get(200)] = IdentifierGenerator.Get(8);
stringIds[GuidGenerator.Get(100)] = IdentifierGenerator.Get(5);
stringIds.MarkAsDeleted(IdentifierGenerator.Get(3));
stringIds.MarkAsDeleted(IdentifierGenerator.Get(1));
var objectIds = CollectionItemIdHelper.GetCollectionItemIds(obj.Objects);
objectIds["key3"] = IdentifierGenerator.Get(3);
objectIds["key4"] = IdentifierGenerator.Get(4);
objectIds.MarkAsDeleted(IdentifierGenerator.Get(1));
objectIds.MarkAsDeleted(IdentifierGenerator.Get(6));
var yaml = SerializeAsString(obj);
Assert.Equal(YamlDictionaryWithDeleted, yaml);
}
protected override void UpdateAssetFromSource(ModelAsset assetToMerge)
{
// Create a dictionary containing all new and old materials, favoring old ones to maintain existing references
var dictionary = assetToMerge.Materials.ToDictionary(x => x.Name, x => x);
Asset.Materials.ForEach(x => dictionary[x.Name] = x);
// Create a dictionary mapping existing materials to their item id, to attempt to maintain existing ids and avoid unnecessary changes.
var ids = CollectionItemIdHelper.GetCollectionItemIds(Asset.Materials).ToDictionary(x => Asset.Materials[(int)x.Key].Name, x => x.Value);
// Remove currently existing materials, one by one because Quantum does not provide a Clear method.
var materialsNode = AssetRootNode[nameof(ModelAsset.Materials)].Target;
while (Asset.Materials.Count > 0)
{
materialsNode.Remove(Asset.Materials[0], new NodeIndex(0));
}
// Repopulate the list of materials
for (var i = 0; i < assetToMerge.Materials.Count; ++i)
{
// Retrieve or create an id for the material
ItemId id;
if (!ids.TryGetValue(assetToMerge.Materials[i].Name, out id))
{
id = ItemId.New();
}
// Use Restore to allow to set manually the id.
materialsNode.Restore(dictionary[assetToMerge.Materials[i].Name], new NodeIndex(i), id);
}
}
public void TestCollectionSerializationWithDeleted()
{
ShadowObject.Enable = true;
var obj = new ContainerCollection("Root")
{
Strings = { "aaa", "bbb" },
Objects = { new ContainerCollection("obj1"), new ContainerCollection("obj2") }
};
var stringIds = CollectionItemIdHelper.GetCollectionItemIds(obj.Strings);
stringIds[0] = IdentifierGenerator.Get(8);
stringIds[1] = IdentifierGenerator.Get(5);
stringIds.MarkAsDeleted(IdentifierGenerator.Get(3));
stringIds.MarkAsDeleted(IdentifierGenerator.Get(1));
var objectIds = CollectionItemIdHelper.GetCollectionItemIds(obj.Objects);
objectIds[0] = IdentifierGenerator.Get(3);
objectIds[1] = IdentifierGenerator.Get(4);
objectIds.MarkAsDeleted(IdentifierGenerator.Get(1));
objectIds.MarkAsDeleted(IdentifierGenerator.Get(6));
var yaml = SerializeAsString(obj);
Assert.Equal(YamlCollectionWithDeleted, yaml);
}
public void TestSimpleSerialization()
{
var asset = new MyAsset {
Strings = { "aa", "bb" }
};
var asset1Ids = CollectionItemIdHelper.GetCollectionItemIds(asset.Strings);
asset1Ids.Add(0, new ItemId(MakeArray(1)));
asset1Ids.Add(1, new ItemId(MakeArray(2)));
var serializer = new YamlAssetSerializer();
var stream = new MemoryStream();
serializer.Save(stream, asset);
stream.Position = 0;
var sr = new StreamReader(stream);
var yaml = sr.ReadToEnd();
stream.Position = 0;
bool aliasOccurred;
Dictionary <YamlAssetPath, OverrideType> overrides;
var loadedAsset = (MyAsset)serializer.Load(stream, null, null, out aliasOccurred, out overrides);
var asset2Ids = CollectionItemIdHelper.GetCollectionItemIds(loadedAsset.Strings);
Assert.AreEqual(2, asset2Ids.Count);
Assert.AreEqual(asset1Ids[0], asset2Ids[0]);
Assert.AreEqual(asset1Ids[1], asset2Ids[1]);
}
/// <inheritdoc />
public override bool ProcessDeserializedData(AssetPropertyGraphContainer graphContainer, object targetRootObject, Type targetMemberType, ref object data, bool isRootDataObjectReference, AssetId?sourceId, YamlAssetMetadata <OverrideType> overrides, YamlAssetPath basePath)
{
if (targetRootObject == null)
{
throw new ArgumentNullException(nameof(targetRootObject));
}
if (data == null)
{
throw new ArgumentNullException(nameof(data));
}
var collectionDescriptor = (CollectionDescriptor)TypeDescriptorFactory.Default.Find(targetRootObject.GetType());
var collection = data as IList <AssetItem>;
if (collection == null)
{
collection = (IList <AssetItem>)Activator.CreateInstance(collectionDescriptor.Type, true);
collectionDescriptor.Add(collection, data);
}
for (var i = 0; i < collection.Count; i++)
{
var assetItem = collection[i];
// If the asset already exists, clone it with new identifiers
if (session.GetAssetById(assetItem.Id) != null)
{
// Create a derived asset and restore archetype to handle asset-specific cloning process.
Dictionary <Guid, Guid> idRemapping;
var clone = AssetCloner.Clone(assetItem.Asset, AssetClonerFlags.GenerateNewIdsForIdentifiableObjects, out idRemapping);
var assetType = assetItem.Asset.GetType();
if (assetType.HasInterface(typeof(AssetCompositeHierarchy <,>)))
{
try
{
// TODO: Find a way to fallback to the asset or generalize for all asset composite
dynamic assetComposite = clone;
// Remap indices of parts in Hierarchy.Part
var path = basePath.Clone();
path.PushItemId(CollectionItemIdHelper.GetCollectionItemIds(collection)[i]);
AssetCloningHelper.RemapIdentifiablePaths(overrides, idRemapping, path);
AssetPartsAnalysis.GenerateNewBaseInstanceIds(assetComposite.Hierarchy);
}
catch (RuntimeBinderException e)
{
e.Ignore();
}
}
// FIXME: rework this
var postProcessor = session.ServiceProvider.Get <ICopyPasteService>().PostProcessors.FirstOrDefault(p => p.Accept(assetType));
postProcessor?.PostPasteDeserialization(clone);
collection[i] = new AssetItem(assetItem.Location, clone);
}
}
// Get the fixed-up value
data = collection;
return(true);
}
protected override ObjectReference FindTargetReference(IGraphNode sourceNode, IGraphNode targetNode, ObjectReference sourceReference)
{
if (sourceReference.Index.IsEmpty)
{
return(targetNode.Content.Reference as ObjectReference);
}
// Special case for objects that are identifiable: the object must be linked to the base only if it has the same id
if (sourceReference.ObjectValue != null)
{
if (sourceReference.Index.IsEmpty)
{
return(targetNode.Content.Reference.AsObject);
}
var sourceAssetNode = (AssetNode)sourceNode;
if (sourceAssetNode.IsNonIdentifiableCollectionContent)
{
return(null);
}
// Enumerable reference: we look for an object with the same id
var targetReference = targetNode.Content.Reference.AsEnumerable;
var sourceIds = CollectionItemIdHelper.GetCollectionItemIds(sourceNode.Content.Retrieve());
var targetIds = CollectionItemIdHelper.GetCollectionItemIds(targetNode.Content.Retrieve());
var itemId = sourceIds[sourceReference.Index.Value];
var targetKey = targetIds.GetKey(itemId);
return(targetReference.FirstOrDefault(x => Equals(x.Index.Value, targetKey)));
}
// Not identifiable - default applies
return(base.FindTargetReference(sourceNode, targetNode, sourceReference));
}
public void TestCollectionRemovedItemFromBase()
{
const string baseYaml = @"!SiliconStudio.Assets.Quantum.Tests.Types+MyAsset2,SiliconStudio.Assets.Quantum.Tests
Id: 10000000-0000-0000-0000-000000000000
Tags: []
Struct:
MyStrings: {}
MyStrings:
0a0000000a0000000a0000000a000000: String1
14000000140000001400000014000000: String3
";
const string derivedYaml = @"!SiliconStudio.Assets.Quantum.Tests.Types+MyAsset2,SiliconStudio.Assets.Quantum.Tests
Id: 20000000-0000-0000-0000-000000000000
Archetype: 10000000-0000-0000-0000-000000000000:MyAsset
Tags: []
Struct:
MyStrings: {}
MyStrings:
0a0000000a0000000a0000000a000000: String1
24000000240000002400000024000000: String2
14000000140000001400000014000000: String3
";
var context = DeriveAssetTest <Types.MyAsset2> .LoadFromYaml(baseYaml, derivedYaml);
var baseIds = CollectionItemIdHelper.GetCollectionItemIds(context.BaseAsset.MyStrings);
var derivedIds = CollectionItemIdHelper.GetCollectionItemIds(context.DerivedAsset.MyStrings);
Assert.AreEqual(2, context.BaseAsset.MyStrings.Count);
Assert.AreEqual("String1", context.BaseAsset.MyStrings[0]);
Assert.AreEqual("String3", context.BaseAsset.MyStrings[1]);
Assert.AreEqual(3, context.DerivedAsset.MyStrings.Count);
Assert.AreEqual("String1", context.DerivedAsset.MyStrings[0]);
Assert.AreEqual("String2", context.DerivedAsset.MyStrings[1]);
Assert.AreEqual("String3", context.DerivedAsset.MyStrings[2]);
Assert.AreEqual(2, baseIds.KeyCount);
Assert.AreEqual(0, baseIds.DeletedCount);
Assert.AreEqual(IdentifierGenerator.Get(10), baseIds[0]);
Assert.AreEqual(IdentifierGenerator.Get(20), baseIds[1]);
Assert.AreEqual(3, derivedIds.KeyCount);
Assert.AreEqual(0, derivedIds.DeletedCount);
Assert.AreEqual(IdentifierGenerator.Get(10), derivedIds[0]);
Assert.AreEqual(IdentifierGenerator.Get(36), derivedIds[1]);
Assert.AreEqual(IdentifierGenerator.Get(20), derivedIds[2]);
context.DerivedGraph.ReconcileWithBase();
Assert.AreEqual(2, context.BaseAsset.MyStrings.Count);
Assert.AreEqual("String1", context.BaseAsset.MyStrings[0]);
Assert.AreEqual("String3", context.BaseAsset.MyStrings[1]);
Assert.AreEqual(2, context.DerivedAsset.MyStrings.Count);
Assert.AreEqual("String1", context.DerivedAsset.MyStrings[0]);
Assert.AreEqual("String3", context.DerivedAsset.MyStrings[1]);
Assert.AreEqual(2, baseIds.KeyCount);
Assert.AreEqual(0, baseIds.DeletedCount);
Assert.AreEqual(IdentifierGenerator.Get(10), baseIds[0]);
Assert.AreEqual(IdentifierGenerator.Get(20), baseIds[1]);
Assert.AreEqual(2, derivedIds.KeyCount);
Assert.AreEqual(0, derivedIds.DeletedCount);
Assert.AreEqual(IdentifierGenerator.Get(10), derivedIds[0]);
Assert.AreEqual(IdentifierGenerator.Get(20), derivedIds[1]);
}
public void TestSimpleCollectionAddMultipleAndCheckOrder()
{
var asset = new Types.MyAsset2 {
MyStrings = { "String1", "String2", "String3", "String4" }
};
var context = DeriveAssetTest <Types.MyAsset2> .DeriveAsset(asset);
var baseIds = CollectionItemIdHelper.GetCollectionItemIds(context.BaseAsset.MyStrings);
var derivedIds = CollectionItemIdHelper.GetCollectionItemIds(context.DerivedAsset.MyStrings);
var basePropertyNode = (AssetNode)((IGraphNode)context.BaseGraph.RootNode).TryGetChild(nameof(Types.MyAsset2.MyStrings));
var derivedPropertyNode = (AssetNode)((IGraphNode)context.DerivedGraph.RootNode).TryGetChild(nameof(Types.MyAsset2.MyStrings));
derivedPropertyNode.Content.Add("String3.5", new Index(3));
derivedPropertyNode.Content.Add("String1.5", new Index(1));
Assert.AreEqual(6, context.DerivedAsset.MyStrings.Count);
AssertCollection(derivedPropertyNode.Content, "String1", "String1.5", "String2", "String3", "String3.5", "String4");
basePropertyNode.Content.Add("String0.1", new Index(0));
Assert.AreEqual(5, context.BaseAsset.MyStrings.Count);
AssertCollection(basePropertyNode.Content, "String0.1", "String1", "String2", "String3", "String4");
Assert.AreEqual(7, context.DerivedAsset.MyStrings.Count);
AssertCollection(derivedPropertyNode.Content, "String0.1", "String1", "String1.5", "String2", "String3", "String3.5", "String4");
basePropertyNode.Content.Add("String1.1", new Index(2));
Assert.AreEqual(6, context.BaseAsset.MyStrings.Count);
AssertCollection(basePropertyNode.Content, "String0.1", "String1", "String1.1", "String2", "String3", "String4");
Assert.AreEqual(8, context.DerivedAsset.MyStrings.Count);
AssertCollection(derivedPropertyNode.Content, "String0.1", "String1", "String1.1", "String1.5", "String2", "String3", "String3.5", "String4");
basePropertyNode.Content.Add("String2.1", new Index(4));
Assert.AreEqual(7, context.BaseAsset.MyStrings.Count);
AssertCollection(basePropertyNode.Content, "String0.1", "String1", "String1.1", "String2", "String2.1", "String3", "String4");
Assert.AreEqual(9, context.DerivedAsset.MyStrings.Count);
AssertCollection(derivedPropertyNode.Content, "String0.1", "String1", "String1.1", "String1.5", "String2", "String2.1", "String3", "String3.5", "String4");
basePropertyNode.Content.Add("String3.1", new Index(6));
Assert.AreEqual(8, context.BaseAsset.MyStrings.Count);
AssertCollection(basePropertyNode.Content, "String0.1", "String1", "String1.1", "String2", "String2.1", "String3", "String3.1", "String4");
Assert.AreEqual(10, context.DerivedAsset.MyStrings.Count);
AssertCollection(derivedPropertyNode.Content, "String0.1", "String1", "String1.1", "String1.5", "String2", "String2.1", "String3", "String3.1", "String3.5", "String4");
basePropertyNode.Content.Add("String4.1", new Index(8));
Assert.AreEqual(9, context.BaseAsset.MyStrings.Count);
AssertCollection(basePropertyNode.Content, "String0.1", "String1", "String1.1", "String2", "String2.1", "String3", "String3.1", "String4", "String4.1");
Assert.AreEqual(11, context.DerivedAsset.MyStrings.Count);
AssertCollection(derivedPropertyNode.Content, "String0.1", "String1", "String1.1", "String1.5", "String2", "String2.1", "String3", "String3.1", "String3.5", "String4", "String4.1");
Assert.AreEqual(9, baseIds.Count);
Assert.AreEqual(11, derivedIds.Count);
Assert.AreEqual(baseIds[0], derivedIds[0]);
Assert.AreEqual(baseIds[1], derivedIds[1]);
Assert.AreEqual(baseIds[2], derivedIds[2]);
Assert.AreEqual(baseIds[3], derivedIds[4]);
Assert.AreEqual(baseIds[4], derivedIds[5]);
Assert.AreEqual(baseIds[5], derivedIds[6]);
Assert.AreEqual(baseIds[6], derivedIds[7]);
Assert.AreEqual(baseIds[7], derivedIds[9]);
Assert.AreEqual(baseIds[8], derivedIds[10]);
}
public void TestDictionaryAddedKeyInBase()
{
const string baseYaml = @"!SiliconStudio.Assets.Quantum.Tests.Types+MyAsset3,SiliconStudio.Assets.Quantum.Tests
Id: 10000000-0000-0000-0000-000000000000
Tags: []
MyDictionary:
0a0000000a0000000a0000000a000000~Key1: String1
15000000150000001500000015000000~Key2.5: String2.5
14000000140000001400000014000000~Key2: String2
";
const string derivedYaml = @"!SiliconStudio.Assets.Quantum.Tests.Types+MyAsset3,SiliconStudio.Assets.Quantum.Tests
Id: 20000000-0000-0000-0000-000000000000
Archetype: 10000000-0000-0000-0000-000000000000:MyAsset
Tags: []
MyDictionary:
0a0000000a0000000a0000000a000000~Key1: String1
14000000140000001400000014000000~Key2: String2
";
var context = DeriveAssetTest <Types.MyAsset3> .LoadFromYaml(baseYaml, derivedYaml);
var baseIds = CollectionItemIdHelper.GetCollectionItemIds(context.BaseAsset.MyDictionary);
var derivedIds = CollectionItemIdHelper.GetCollectionItemIds(context.DerivedAsset.MyDictionary);
Assert.AreEqual(3, context.BaseAsset.MyDictionary.Count);
Assert.AreEqual("String1", context.BaseAsset.MyDictionary["Key1"]);
Assert.AreEqual("String2.5", context.BaseAsset.MyDictionary["Key2.5"]);
Assert.AreEqual("String2", context.BaseAsset.MyDictionary["Key2"]);
Assert.AreEqual(2, context.DerivedAsset.MyDictionary.Count);
Assert.AreEqual("String1", context.DerivedAsset.MyDictionary["Key1"]);
Assert.AreEqual("String2", context.DerivedAsset.MyDictionary["Key2"]);
Assert.AreEqual(3, baseIds.KeyCount);
Assert.AreEqual(0, baseIds.DeletedCount);
Assert.AreEqual(IdentifierGenerator.Get(10), baseIds["Key1"]);
Assert.AreEqual(IdentifierGenerator.Get(21), baseIds["Key2.5"]);
Assert.AreEqual(IdentifierGenerator.Get(20), baseIds["Key2"]);
Assert.AreEqual(2, derivedIds.KeyCount);
Assert.AreEqual(0, derivedIds.DeletedCount);
Assert.AreEqual(IdentifierGenerator.Get(10), derivedIds["Key1"]);
Assert.AreEqual(IdentifierGenerator.Get(20), derivedIds["Key2"]);
context.DerivedGraph.ReconcileWithBase();
Assert.AreEqual(3, context.BaseAsset.MyDictionary.Count);
Assert.AreEqual("String1", context.BaseAsset.MyDictionary["Key1"]);
Assert.AreEqual("String2.5", context.BaseAsset.MyDictionary["Key2.5"]);
Assert.AreEqual("String2", context.BaseAsset.MyDictionary["Key2"]);
Assert.AreEqual(3, context.DerivedAsset.MyDictionary.Count);
Assert.AreEqual("String1", context.DerivedAsset.MyDictionary["Key1"]);
Assert.AreEqual("String2.5", context.DerivedAsset.MyDictionary["Key2.5"]);
Assert.AreEqual("String2", context.DerivedAsset.MyDictionary["Key2"]);
Assert.AreEqual(3, baseIds.KeyCount);
Assert.AreEqual(0, baseIds.DeletedCount);
Assert.AreEqual(IdentifierGenerator.Get(10), baseIds["Key1"]);
Assert.AreEqual(IdentifierGenerator.Get(21), baseIds["Key2.5"]);
Assert.AreEqual(IdentifierGenerator.Get(20), baseIds["Key2"]);
Assert.AreEqual(3, derivedIds.KeyCount);
Assert.AreEqual(0, derivedIds.DeletedCount);
Assert.AreEqual(IdentifierGenerator.Get(10), derivedIds["Key1"]);
Assert.AreEqual(IdentifierGenerator.Get(21), derivedIds["Key2.5"]);
Assert.AreEqual(IdentifierGenerator.Get(20), derivedIds["Key2"]);
}
public static YamlAssetPath FromMemberPath([NotNull] MemberPath path, object root)
{
if (path == null)
{
throw new ArgumentNullException(nameof(path));
}
var result = new YamlAssetPath();
var clone = new MemberPath();
foreach (var item in path.Decompose())
{
if (item.MemberDescriptor != null)
{
clone.Push(item.MemberDescriptor);
var member = item.MemberDescriptor.Name;
result.PushMember(member);
}
else
{
object index = null;
if (item is MemberPath.ArrayPathItem arrayItem)
{
clone.Push(arrayItem.Descriptor, arrayItem.Index);
index = arrayItem.Index;
}
else if (item is MemberPath.CollectionPathItem collectionItem)
{
clone.Push(collectionItem.Descriptor, collectionItem.Index);
index = collectionItem.Index;
}
else if (item is MemberPath.DictionaryPathItem dictionaryItem)
{
clone.Push(dictionaryItem.Descriptor, dictionaryItem.Key);
index = dictionaryItem.Key;
}
else if (item is MemberPath.SetPathItem setItem)
{
clone.Push(setItem.Descriptor, setItem.Index);
index = setItem.Index;
}
if (!CollectionItemIdHelper.TryGetCollectionItemIds(clone.GetValue(root), out CollectionItemIdentifiers ids))
{
result.PushIndex(index);
}
else
{
var id = ids[index];
// Create a new id if we don't have any so far
if (id == ItemId.Empty)
{
id = ItemId.New();
}
result.PushItemId(id);
}
}
}
return(result);
}
public AssetNode ResolveObjectPath(YamlAssetPath path, out Index index, out bool overrideOnKey)
{
var currentNode = this;
index = Index.Empty;
overrideOnKey = false;
for (var i = 0; i < path.Items.Count; i++)
{
var item = path.Items[i];
switch (item.Type)
{
case YamlAssetPath.ItemType.Member:
index = Index.Empty;
overrideOnKey = false;
if (currentNode.Content.IsReference)
{
currentNode = (AssetNode)((IGraphNode)currentNode).Target;
}
string name = item.AsMember();
currentNode = (AssetNode)((IGraphNode)currentNode).TryGetChild(name);
break;
case YamlAssetPath.ItemType.Index:
index = new Index(item.Value);
overrideOnKey = true;
if (currentNode.Content.IsReference && i < path.Items.Count - 1)
{
Index index1 = new Index(item.Value);
currentNode = (AssetNode)((IGraphNode)currentNode).IndexedTarget(index1);
}
break;
case YamlAssetPath.ItemType.ItemId:
var ids = CollectionItemIdHelper.GetCollectionItemIds(currentNode.Content.Retrieve());
var key = ids.GetKey(item.AsItemId());
index = new Index(key);
overrideOnKey = false;
if (currentNode.Content.IsReference && i < path.Items.Count - 1)
{
Index index1 = new Index(key);
currentNode = (AssetNode)((IGraphNode)currentNode).IndexedTarget(index1);
}
break;
default:
throw new ArgumentOutOfRangeException();
}
// Something wrong happen, the node is unreachable.
if (currentNode == null)
{
return(null);
}
}
return(currentNode);
}
public void TestCollectionMismatchItem()
{
const string baseYaml = @"!Stride.Core.Assets.Quantum.Tests.Helpers.Types+MyAsset2,Stride.Core.Assets.Quantum.Tests
Id: 10000000-0000-0000-0000-000000000000
Tags: []
Struct:
MyStrings: {}
MyStrings:
0a0000000a0000000a0000000a000000: String1
14000000140000001400000014000000: String2
";
const string derivedYaml = @"!Stride.Core.Assets.Quantum.Tests.Helpers.Types+MyAsset2,Stride.Core.Assets.Quantum.Tests
Id: 20000000-0000-0000-0000-000000000000
Archetype: 10000000-0000-0000-0000-000000000000:MyAsset
Tags: []
Struct:
MyStrings: {}
MyStrings:
0a0000000a0000000a0000000a000000*: MyDerivedString
14000000140000001400000014000000: MyBaseString
";
var context = DeriveAssetTest <Types.MyAsset2, Types.MyAssetBasePropertyGraph> .LoadFromYaml(baseYaml, derivedYaml);
var baseIds = CollectionItemIdHelper.GetCollectionItemIds(context.BaseAsset.MyStrings);
var derivedIds = CollectionItemIdHelper.GetCollectionItemIds(context.DerivedAsset.MyStrings);
Assert.Equal(2, context.BaseAsset.MyStrings.Count);
Assert.Equal("String1", context.BaseAsset.MyStrings[0]);
Assert.Equal("String2", context.BaseAsset.MyStrings[1]);
Assert.Equal(2, context.DerivedAsset.MyStrings.Count);
Assert.Equal("MyDerivedString", context.DerivedAsset.MyStrings[0]);
Assert.Equal("MyBaseString", context.DerivedAsset.MyStrings[1]);
Assert.Equal(2, baseIds.KeyCount);
Assert.Equal(0, baseIds.DeletedCount);
Assert.Equal(IdentifierGenerator.Get(10), baseIds[0]);
Assert.Equal(IdentifierGenerator.Get(20), baseIds[1]);
Assert.Equal(2, derivedIds.KeyCount);
Assert.Equal(0, derivedIds.DeletedCount);
Assert.Equal(IdentifierGenerator.Get(10), derivedIds[0]);
Assert.Equal(IdentifierGenerator.Get(20), derivedIds[1]);
context.DerivedGraph.ReconcileWithBase();
Assert.Equal(2, context.BaseAsset.MyStrings.Count);
Assert.Equal("String1", context.BaseAsset.MyStrings[0]);
Assert.Equal("String2", context.BaseAsset.MyStrings[1]);
Assert.Equal(2, context.DerivedAsset.MyStrings.Count);
Assert.Equal("MyDerivedString", context.DerivedAsset.MyStrings[0]);
Assert.Equal("String2", context.DerivedAsset.MyStrings[1]);
Assert.Equal(2, baseIds.KeyCount);
Assert.Equal(0, baseIds.DeletedCount);
Assert.Equal(IdentifierGenerator.Get(10), baseIds[0]);
Assert.Equal(IdentifierGenerator.Get(20), baseIds[1]);
Assert.Equal(2, derivedIds.KeyCount);
Assert.Equal(0, derivedIds.DeletedCount);
Assert.Equal(IdentifierGenerator.Get(10), derivedIds[0]);
Assert.Equal(IdentifierGenerator.Get(20), derivedIds[1]);
}
public void TestDictionaryNonIdentifiableItemsDeserialization()
{
ShadowObject.Enable = true;
var stream = new MemoryStream();
var writer = new StreamWriter(stream);
writer.Write(YamlDictionaryNonIdentifiable);
writer.Flush();
stream.Position = 0;
var instance = AssetYamlSerializer.Default.Deserialize(stream);
Assert.NotNull(instance);
Assert.Equal(typeof(ContainerNonIdentifiableDictionary), instance.GetType());
var obj = (ContainerNonIdentifiableDictionary)instance;
Assert.Equal("Root", obj.Name);
Assert.Equal(2, obj.Objects.Count);
Assert.Equal("aaa", obj.Objects["AAA"].Name);
Assert.Equal(2, obj.Objects["AAA"].Strings.Count);
Assert.Equal("bbb", obj.Objects["AAA"].Strings[0]);
Assert.Equal("ccc", obj.Objects["AAA"].Strings[1]);
Assert.Equal("ddd", obj.Objects["BBB"].Name);
Assert.Equal(2, obj.Objects["BBB"].Strings.Count);
Assert.Equal("eee", obj.Objects["BBB"].Strings[0]);
Assert.Equal("fff", obj.Objects["BBB"].Strings[1]);
var objectIds = CollectionItemIdHelper.GetCollectionItemIds(obj.Objects);
Assert.Equal(IdentifierGenerator.Get(2), objectIds["AAA"]);
Assert.Equal(IdentifierGenerator.Get(1), objectIds["BBB"]);
objectIds = CollectionItemIdHelper.GetCollectionItemIds(obj.Objects["AAA"].Strings);
Assert.Equal(IdentifierGenerator.Get(5), objectIds[0]);
Assert.Equal(IdentifierGenerator.Get(6), objectIds[1]);
objectIds = CollectionItemIdHelper.GetCollectionItemIds(obj.Objects["BBB"].Strings);
Assert.Equal(IdentifierGenerator.Get(7), objectIds[0]);
Assert.Equal(IdentifierGenerator.Get(8), objectIds[1]);
Assert.Equal(2, obj.NonIdentifiableObjects.Count);
Assert.Equal("ggg", obj.NonIdentifiableObjects["CCC"].Name);
Assert.Equal(2, obj.NonIdentifiableObjects["CCC"].Strings.Count);
Assert.Equal("hhh", obj.NonIdentifiableObjects["CCC"].Strings[0]);
Assert.Equal("iii", obj.NonIdentifiableObjects["CCC"].Strings[1]);
Assert.Equal("jjj", obj.NonIdentifiableObjects["DDD"].Name);
Assert.Equal(2, obj.NonIdentifiableObjects["DDD"].Strings.Count);
Assert.Equal("kkk", obj.NonIdentifiableObjects["DDD"].Strings[0]);
Assert.Equal("lll", obj.NonIdentifiableObjects["DDD"].Strings[1]);
Assert.False(CollectionItemIdHelper.TryGetCollectionItemIds(obj.NonIdentifiableObjects, out objectIds));
objectIds = CollectionItemIdHelper.GetCollectionItemIds(obj.NonIdentifiableObjects);
Assert.Equal(0, objectIds.KeyCount);
Assert.Equal(0, objectIds.DeletedCount);
objectIds = CollectionItemIdHelper.GetCollectionItemIds(obj.NonIdentifiableObjects["CCC"].Strings);
Assert.Equal(IdentifierGenerator.Get(9), objectIds[0]);
Assert.Equal(IdentifierGenerator.Get(10), objectIds[1]);
objectIds = CollectionItemIdHelper.GetCollectionItemIds(obj.NonIdentifiableObjects["DDD"].Strings);
Assert.Equal(IdentifierGenerator.Get(11), objectIds[0]);
Assert.Equal(IdentifierGenerator.Get(12), objectIds[1]);
}
public void TestDictionaryRemovedItemFromBase()
{
const string baseYaml = @"!Stride.Core.Assets.Quantum.Tests.Helpers.Types+MyAsset3,Stride.Core.Assets.Quantum.Tests
Id: 10000000-0000-0000-0000-000000000000
Tags: []
MyDictionary:
0a0000000a0000000a0000000a000000~Key1: String1
14000000140000001400000014000000~Key3: String3
";
const string derivedYaml = @"!Stride.Core.Assets.Quantum.Tests.Helpers.Types+MyAsset3,Stride.Core.Assets.Quantum.Tests
Id: 20000000-0000-0000-0000-000000000000
Archetype: 10000000-0000-0000-0000-000000000000:MyAsset
Tags: []
MyDictionary:
0a0000000a0000000a0000000a000000~Key1: String1
24000000240000002400000024000000~Key2: String2
14000000140000001400000014000000~Key3: String3
";
var context = DeriveAssetTest <Types.MyAsset3, Types.MyAssetBasePropertyGraph> .LoadFromYaml(baseYaml, derivedYaml);
var baseIds = CollectionItemIdHelper.GetCollectionItemIds(context.BaseAsset.MyDictionary);
var derivedIds = CollectionItemIdHelper.GetCollectionItemIds(context.DerivedAsset.MyDictionary);
Assert.Equal(2, context.BaseAsset.MyDictionary.Count);
Assert.Equal("String1", context.BaseAsset.MyDictionary["Key1"]);
Assert.Equal("String3", context.BaseAsset.MyDictionary["Key3"]);
Assert.Equal(3, context.DerivedAsset.MyDictionary.Count);
Assert.Equal("String1", context.DerivedAsset.MyDictionary["Key1"]);
Assert.Equal("String2", context.DerivedAsset.MyDictionary["Key2"]);
Assert.Equal("String3", context.DerivedAsset.MyDictionary["Key3"]);
Assert.Equal(2, baseIds.KeyCount);
Assert.Equal(0, baseIds.DeletedCount);
Assert.Equal(IdentifierGenerator.Get(10), baseIds["Key1"]);
Assert.Equal(IdentifierGenerator.Get(20), baseIds["Key3"]);
Assert.Equal(3, derivedIds.KeyCount);
Assert.Equal(0, derivedIds.DeletedCount);
Assert.Equal(IdentifierGenerator.Get(10), derivedIds["Key1"]);
Assert.Equal(IdentifierGenerator.Get(36), derivedIds["Key2"]);
Assert.Equal(IdentifierGenerator.Get(20), derivedIds["Key3"]);
context.DerivedGraph.ReconcileWithBase();
Assert.Equal(2, context.BaseAsset.MyDictionary.Count);
Assert.Equal("String1", context.BaseAsset.MyDictionary["Key1"]);
Assert.Equal("String3", context.BaseAsset.MyDictionary["Key3"]);
Assert.Equal(2, context.DerivedAsset.MyDictionary.Count);
Assert.Equal("String1", context.DerivedAsset.MyDictionary["Key1"]);
Assert.Equal("String3", context.DerivedAsset.MyDictionary["Key3"]);
Assert.Equal(2, baseIds.KeyCount);
Assert.Equal(0, baseIds.DeletedCount);
Assert.Equal(IdentifierGenerator.Get(10), baseIds["Key1"]);
Assert.Equal(IdentifierGenerator.Get(20), baseIds["Key3"]);
Assert.Equal(2, derivedIds.KeyCount);
Assert.Equal(0, derivedIds.DeletedCount);
Assert.Equal(IdentifierGenerator.Get(10), derivedIds["Key1"]);
Assert.Equal(IdentifierGenerator.Get(20), derivedIds["Key3"]);
}
public override void VisitDictionary(object dictionary, DictionaryDescriptor descriptor)
{
if (ShouldGenerateItemIdCollection(dictionary))
{
var itemIds = CollectionItemIdHelper.GetCollectionItemIds(dictionary);
foreach (var element in descriptor.GetEnumerator(dictionary))
{
itemIds.Add(element.Key, ItemId.New());
}
}
}
public void TestDictionaryDeserializationOldWay()
{
ShadowObject.Enable = true;
var yaml = @"!SiliconStudio.Assets.Tests.Yaml.TestCollectionIdsSerialization+ContainerDictionary,SiliconStudio.Assets.Tests
Name: Root
Strings:
000000c8-00c8-0000-c800-0000c8000000: aaa
00000064-0064-0000-6400-000064000000: bbb
Objects:
key3:
~Id: 00000003-0003-0000-0300-000003000000
Name: obj1
Strings: {}
Objects: {}
key4:
~Id: 00000004-0004-0000-0400-000004000000
Name: obj2
Strings: {}
Objects: {}
";
var stream = new MemoryStream();
var writer = new StreamWriter(stream);
writer.Write(yaml);
writer.Flush();
stream.Position = 0;
var instance = AssetYamlSerializer.Default.Deserialize(stream);
Assert.NotNull(instance);
Assert.AreEqual(typeof(ContainerDictionary), instance.GetType());
var obj = (ContainerDictionary)instance;
Assert.AreEqual("Root", obj.Name);
Assert.AreEqual(2, obj.Strings.Count);
Assert.AreEqual("aaa", obj.Strings[GuidGenerator.Get(200)]);
Assert.AreEqual("bbb", obj.Strings[GuidGenerator.Get(100)]);
Assert.AreEqual(2, obj.Objects.Count);
Assert.AreEqual("obj1", obj.Objects["key3"].Name);
Assert.AreEqual("obj2", obj.Objects["key4"].Name);
var stringIds = CollectionItemIdHelper.GetCollectionItemIds(obj.Strings);
var objectIds = CollectionItemIdHelper.GetCollectionItemIds(obj.Objects);
Assert.AreEqual(2, stringIds.KeyCount);
Assert.AreEqual(0, stringIds.DeletedCount);
Assert.IsTrue(stringIds.ContainsKey(GuidGenerator.Get(200)));
Assert.IsTrue(stringIds.ContainsKey(GuidGenerator.Get(100)));
Assert.AreEqual(2, objectIds.KeyCount);
Assert.AreEqual(0, objectIds.DeletedCount);
Assert.IsTrue(objectIds.ContainsKey("key3"));
Assert.IsTrue(objectIds.ContainsKey("key4"));
Assert.AreEqual(IdentifierGenerator.Get(3), objectIds["key3"]);
Assert.AreEqual(IdentifierGenerator.Get(4), objectIds["key4"]);
}
public override void VisitArray(Array array, ArrayDescriptor descriptor)
{
if (ShouldGenerateItemIdCollection(array))
{
var itemIds = CollectionItemIdHelper.GetCollectionItemIds(array);
for (var i = 0; i < array.Length; ++i)
{
itemIds.Add(i, ItemId.New());
}
}
base.VisitArray(array, descriptor);
}
