/// <inheritdoc/>
public override void VisitDictionaryKeyValue(object dictionary, DictionaryDescriptor descriptor, object key, ITypeDescriptor keyDescriptor, object value, ITypeDescriptor valueDescriptor)
{
if (CurrentPath.Match(MemberPath))
{
var keyValueType = typeof(KeyValuePair <,>).MakeGenericType(keyDescriptor.Type, valueDescriptor.Type);
var keyValueDescriptor = TypeDescriptorFactory.Find(keyValueType);
var keyValuePair = Activator.CreateInstance(keyValueType, key, value);
VisitAssetMember(keyValuePair, keyValueDescriptor);
}
else
{
base.VisitDictionaryKeyValue(dictionary, descriptor, key, keyDescriptor, value, valueDescriptor);
}
}
public void TestPrimitiveDescriptor()
{
var attributeRegistry = new AttributeRegistry();
var factory = new TypeDescriptorFactory(attributeRegistry);
var descriptor = new PrimitiveDescriptor(factory, typeof(int), false, new DefaultNamingConvention());
Assert.Equal(0, descriptor.Count);
Assert.True(PrimitiveDescriptor.IsPrimitive(typeof(MyEnum)));
Assert.True(PrimitiveDescriptor.IsPrimitive(typeof(object)));
Assert.True(PrimitiveDescriptor.IsPrimitive(typeof(DateTime)));
Assert.True(PrimitiveDescriptor.IsPrimitive(typeof(TimeSpan)));
Assert.False(PrimitiveDescriptor.IsPrimitive(typeof(IList)));
}
public void TestObjectWithCustomNamingConvention()
{
var attributeRegistry = new AttributeRegistry();
var factory = new TypeDescriptorFactory(attributeRegistry);
var descriptor = new ObjectDescriptor(factory, typeof(TestObjectNamingConvention), false, new FlatNamingConvention());
descriptor.Initialize(new DefaultKeyComparer());
// Check names and their orders
Assert.AreEqual(descriptor.Members.Select(memberDescriptor => memberDescriptor.Name), new[]
{
"myname",
"name",
"this_is_camel_name"
});
}
public void Check(ModelNode node, object obj, Type type, bool checkReferences)
{
Reset();
if (node.Content.Value != obj)
{
throw new QuantumConsistencyException("The node content value [{0}]", obj.ToStringSafe(), "The node content value [{0}]", node.Content.Value.ToStringSafe(), node);
}
if (node.Content.Type != type)
{
throw new QuantumConsistencyException("The node content type [{0}]", type.Name, "The node content value [{0}]", node.Content.Type.Name, node);
}
rootNode = node;
while (rootNode != null)
{
if (rootNode.Parent != null)
{
throw new QuantumConsistencyException("A root node", "A node with a parent", rootNode);
}
if (rootNode.Content.Value != null)
{
var typeDescriptor = TypeDescriptorFactory.Find(rootNode.Content.Type);
PushContextNode(rootNode);
VisitObject(rootNode.Content.Value, typeDescriptor as ObjectDescriptor, true);
PopContextNode();
}
checkedNodes.Add(rootNode);
rootNode = null;
if (checkReferences)
{
while (references.Count > 0)
{
var reference = references.Dequeue();
if (!checkedNodes.Contains(reference.TargetNode))
{
rootNode = (ModelNode)reference.TargetNode;
break;
}
}
}
}
}
/// <summary>
/// Initialize the tests.
/// </summary>
public virtual void Initialize()
{
TypeFactory = new TypeDescriptorFactory();
var myClassDesc = TypeFactory.Find(typeof(MyClass));
var myStructDesc = TypeFactory.Find(typeof(MyStruct));
ListClassDesc = (CollectionDescriptor)TypeFactory.Find(typeof(List <MyClass>));
MapClassDesc = (DictionaryDescriptor)TypeFactory.Find(typeof(Dictionary <string, MyClass>));
MemberValue = (IMemberDescriptor)myClassDesc.Members.FirstOrDefault(member => member.Name == "Value");
MemberSub = (IMemberDescriptor)myClassDesc.Members.FirstOrDefault(member => member.Name == "Sub");
MemberStruct = (IMemberDescriptor)myClassDesc.Members.FirstOrDefault(member => member.Name == "Struct");
MemberSubs = (IMemberDescriptor)myClassDesc.Members.FirstOrDefault(member => member.Name == "Subs");
MemberMaps = (IMemberDescriptor)myClassDesc.Members.FirstOrDefault(member => member.Name == "Maps");
MemberX = (IMemberDescriptor)myStructDesc.Members.FirstOrDefault(member => member.Name == "X");
MemberClass = (IMemberDescriptor)myStructDesc.Members.FirstOrDefault(member => member.Name == "Class");
}
public IReference CreateReferenceForNode(Type type, object value, bool isMember)
{
if (isMember)
{
return(!IsPrimitiveType(type) ? Reference.CreateReference(value, type, NodeIndex.Empty, true) : null);
}
var descriptor = TypeDescriptorFactory.Find(value?.GetType());
if (descriptor is CollectionDescriptor || descriptor is DictionaryDescriptor)
{
var valueType = GetElementValueType(descriptor);
return(!IsPrimitiveType(valueType) ? Reference.CreateReference(value, type, NodeIndex.Empty, false) : null);
}
return(null);
}
/// <inheritdoc/>
public IGraphNode Build(object obj, Guid guid, NodeFactoryDelegate nodeFactory)
{
if (obj == null)
{
throw new ArgumentNullException(nameof(obj));
}
if (nodeFactory == null)
{
throw new ArgumentNullException(nameof(nodeFactory));
}
Reset();
rootGuid = guid;
var typeDescriptor = TypeDescriptorFactory.Find(obj.GetType());
currentNodeFactory = nodeFactory;
VisitObject(obj, typeDescriptor as ObjectDescriptor, true);
currentNodeFactory = null;
return(rootNode);
}
private IReference CreateReferenceForNode(Type type, object value)
{
// Is it a reference?
if ((!type.IsClass && !type.IsInterface) || IsPrimitiveType(type))
{
return(null);
}
ITypeDescriptor descriptor = value != null?TypeDescriptorFactory.Find(value.GetType()) : null;
var valueType = GetElementValueType(descriptor);
// This is either an object reference or a enumerable reference of non-primitive type (excluding custom primitive type)
if (valueType == null || !IsPrimitiveType(valueType, false))
{
return(Reference.CreateReference(value, type, Reference.NotInCollection));
}
return(null);
}
public IReference CreateReferenceForNode(Type type, object value)
{
// We don't create references for primitive types
if (IsPrimitiveType(type) || type.IsStruct())
{
return(null);
}
ITypeDescriptor descriptor = value != null?TypeDescriptorFactory.Find(value.GetType()) : null;
var valueType = GetElementValueType(descriptor);
// This is either an object reference or a enumerable reference of non-primitive type (excluding custom primitive type)
if (valueType == null || (!IsPrimitiveType(valueType) && !valueType.IsStruct()))
{
return(Reference.CreateReference(value, type, Reference.NotInCollection));
}
return(null);
}
public override void Initialize()
{
base.Initialize();
TypeFactory = new TypeDescriptorFactory();
var assetDesc = TypeFactory.Find(typeof(TestAssetUpdate));
memberMyClass = assetDesc.Members.FirstOrDefault(member => member.Name == "MyClass");
if (session != null)
{
session.Dispose();
dependencyManager.Dispose();
}
package = new Package();
session = new PackageSession(package);
dependencyManager = new AssetDependencyManager(session);
assetUpdater = new AssetUpdater(dependencyManager);
}
public IReference CreateReferenceForNode(Type type, object value)
{
// We don't create references for primitive types
if (IsPrimitiveType(type))
{
return(null);
}
// At this point it is either a struct, a reference type or a collection
var descriptor = TypeDescriptorFactory.Find(value?.GetType());
var valueType = GetElementValueType(descriptor);
// We don't create references for collection of primitive types
if (IsPrimitiveType(valueType))
{
return(null);
}
// In any other case, we create a reference
return(Reference.CreateReference(value, type, Index.Empty));
}
public IReference CreateReferenceForNode(Type type, object value)
{
// We don't create references for primitive types and structs
if (IsPrimitiveType(type) || type.IsStruct())
{
return(null);
}
// At this point it is either a reference type or a collection
ITypeDescriptor descriptor = value != null?TypeDescriptorFactory.Find(value.GetType()) : null;
var valueType = GetElementValueType(descriptor);
// We create reference only for structs (in case of collection of structs) and classes (in a collection or not)
if (valueType == null || !IsPrimitiveType(valueType))
{
return(Reference.CreateReference(value, type, Index.Empty));
}
return(null);
}
public void TestDictionaryDescriptor()
{
var attributeRegistry = new AttributeRegistry();
var factory = new TypeDescriptorFactory(attributeRegistry);
var descriptor = new DictionaryDescriptor(factory, typeof(Dictionary <int, string>), false,
new DefaultNamingConvention());
descriptor.Initialize(new DefaultKeyComparer());
Assert.AreEqual(0, descriptor.Count);
Assert.True(descriptor.IsPureDictionary);
Assert.AreEqual(typeof(int), descriptor.KeyType);
Assert.AreEqual(typeof(string), descriptor.ValueType);
descriptor = new DictionaryDescriptor(factory, typeof(NonPureDictionary), false,
new DefaultNamingConvention());
descriptor.Initialize(new DefaultKeyComparer());
Assert.AreEqual(1, descriptor.Count);
Assert.False(descriptor.IsPureDictionary);
Assert.AreEqual(typeof(float), descriptor.KeyType);
Assert.AreEqual(typeof(object), descriptor.ValueType);
}
public void TestMyClass()
{
var typeFactory = new TypeDescriptorFactory();
var myClassDesc = typeFactory.Find(typeof(MyClass));
var myStructDesc = typeFactory.Find(typeof(MyStruct));
var listClassDesc = (CollectionDescriptor)typeFactory.Find(typeof(List <MyClass>));
var mapClassDesc = (DictionaryDescriptor)typeFactory.Find(typeof(Dictionary <string, MyClass>));
var memberValue = myClassDesc.Members.FirstOrDefault(member => member.Name == "Value");
var memberSub = myClassDesc.Members.FirstOrDefault(member => member.Name == "Sub");
var memberStruct = myClassDesc.Members.FirstOrDefault(member => member.Name == "Struct");
var memberSubs = myClassDesc.Members.FirstOrDefault(member => member.Name == "Subs");
var memberMaps = myClassDesc.Members.FirstOrDefault(member => member.Name == "Maps");
var memberX = myStructDesc.Members.FirstOrDefault(member => member.Name == "X");
var testClass = new MyClass {
Sub = new MyClass()
};
testClass.Maps["XXX"] = new MyClass();
testClass.Subs.Add(new MyClass());
// 1) MyClass.Value = 1
var memberPath = new MemberPath();
memberPath.Push(memberValue);
object value;
Assert.IsTrue(memberPath.Apply(testClass, MemberPathAction.ValueSet, 1));
Assert.IsTrue(memberPath.TryGetValue(testClass, out value));
Assert.AreEqual(1, value);
Assert.AreEqual(1, testClass.Value);
// 2) MyClass.Sub.Value = 1
memberPath.Clear();
memberPath.Push(memberSub);
memberPath.Push(memberValue);
Assert.IsTrue(memberPath.Apply(testClass, MemberPathAction.ValueSet, 1));
Assert.IsTrue(memberPath.TryGetValue(testClass, out value));
Assert.AreEqual(1, value);
Assert.AreEqual(1, testClass.Sub.Value);
// 3) MyClass.Struct.X = 1
memberPath.Clear();
memberPath.Push(memberStruct);
memberPath.Push(memberX);
Assert.IsTrue(memberPath.Apply(testClass, MemberPathAction.ValueSet, 1));
Assert.IsTrue(memberPath.TryGetValue(testClass, out value));
Assert.AreEqual(1, value);
Assert.AreEqual(1, testClass.Struct.X);
// 3) MyClass.Maps["XXX"].Value = 1
memberPath.Clear();
memberPath.Push(memberMaps);
memberPath.Push(mapClassDesc, "XXX");
memberPath.Push(memberValue);
Assert.IsTrue(memberPath.Apply(testClass, MemberPathAction.ValueSet, 1));
Assert.IsTrue(memberPath.TryGetValue(testClass, out value));
Assert.AreEqual(1, value);
Assert.AreEqual(1, testClass.Maps["XXX"].Value);
// 4) MyClass.Subs[0].Value = 1
memberPath.Clear();
memberPath.Push(memberSubs);
memberPath.Push(listClassDesc, 0);
memberPath.Push(memberValue);
Assert.IsTrue(memberPath.Apply(testClass, MemberPathAction.ValueSet, 1));
Assert.IsTrue(memberPath.TryGetValue(testClass, out value));
Assert.AreEqual(1, value);
Assert.AreEqual(1, testClass.Subs[0].Value);
// 5) MyClass.Subs[0].X (invalid)
memberPath.Clear();
memberPath.Push(memberSubs);
memberPath.Push(listClassDesc, 0);
memberPath.Push(memberX);
Assert.IsFalse(memberPath.TryGetValue(testClass, out value));
Assert.IsFalse(memberPath.Apply(testClass, MemberPathAction.ValueSet, 1));
// 6) Remove key MyClass.Maps.Remove("XXX")
memberPath.Clear();
memberPath.Push(memberMaps);
memberPath.Push(mapClassDesc, "XXX");
Assert.IsTrue(memberPath.Apply(testClass, MemberPathAction.DictionaryRemove, null));
Assert.IsFalse(testClass.Maps.ContainsKey("XXX"));
// 7) Re-add a value to the dictionary
Assert.IsTrue(memberPath.Apply(testClass, MemberPathAction.ValueSet, new MyClass()));
Assert.IsTrue(testClass.Maps.ContainsKey("XXX"));
// 8) Remove key MyClass.Subs.Remove(0)
memberPath.Clear();
memberPath.Push(memberSubs);
memberPath.Push(listClassDesc, 0);
Assert.IsTrue(memberPath.Apply(testClass, MemberPathAction.CollectionRemove, null));
Assert.AreEqual(0, testClass.Subs.Count);
// 9) Add a key MyClass.Subs.Add(new MyClass())
memberPath.Clear();
memberPath.Push(memberSubs);
memberPath.Push(listClassDesc, 0);
Assert.IsTrue(memberPath.Apply(testClass, MemberPathAction.CollectionAdd, new MyClass()));
Assert.AreEqual(1, testClass.Subs.Count);
}
