public void TestClone()
{
var obj = new Class { ClassMember = new Class(), ListMember = { new Class(), new Class(), new Class() } };
var nodeContainer = new NodeContainer();
var path1 = new GraphNodePath(nodeContainer.GetOrCreateNode(obj));
var clone = path1.Clone();
AssertAreEqual(path1, clone);
AssertAreEqual(path1.GetHashCode(), clone.GetHashCode());
AssertAreEqual(path1.RootNode, clone.RootNode);
AssertAreEqual(path1.IsValid, clone.IsValid);
AssertAreEqual(path1.IsEmpty, clone.IsEmpty);
AssertAreEqual(path1.GetNode(), clone.GetNode());
var path2 = path1.PushMember(nameof(Class.ClassMember)).PushTarget().PushMember(nameof(Class.IntMember));
clone = path2.Clone();
AssertAreEqual(path2, clone);
AssertAreEqual(path2.RootNode, clone.RootNode);
AssertAreEqual(path2.IsValid, clone.IsValid);
AssertAreEqual(path2.IsEmpty, clone.IsEmpty);
AssertAreEqual(path2.GetNode(), clone.GetNode());
var path3 = path1.PushMember(nameof(Class.ListMember)).PushIndex(new Index(1)).PushMember(nameof(Class.IntMember));
clone = path3.Clone();
AssertAreEqual(path3, clone);
AssertAreEqual(path3.RootNode, clone.RootNode);
AssertAreEqual(path3.IsValid, clone.IsValid);
AssertAreEqual(path3.IsEmpty, clone.IsEmpty);
AssertAreEqual(path3.GetNode(), clone.GetNode());
}
public void TestObjectReferenceUpdate()
{
var nodeContainer = new NodeContainer();
var instance = new TestObject { Name = "Test" };
var container = new ObjectContainer { Instance = instance };
var containerNode = nodeContainer.GetOrCreateNode(container);
var memberNode = containerNode.Children.First();
var instanceNode = memberNode.Content.Reference.AsObject.TargetNode;
// Update to a new instance
var newInstance = new TestObject { Name = "Test2" };
memberNode.Content.Update(newInstance);
Helper.TestMemberContentNode(containerNode, memberNode, container, newInstance, nameof(ObjectContainer.Instance), true);
Helper.TestNonNullObjectReference(memberNode.Content.Reference, newInstance, false);
var newInstanceNode = nodeContainer.GetNode(newInstance);
Helper.TestNonNullObjectReference(memberNode.Content.Reference, newInstanceNode, newInstance);
Assert.AreNotEqual(instanceNode.Guid, newInstanceNode.Guid);
// Update to null
memberNode.Content.Update(null);
Helper.TestMemberContentNode(containerNode, memberNode, container, null, nameof(ObjectContainer.Instance), true);
Helper.TestNullObjectReference(memberNode.Content.Reference);
// Update back to the initial instance
memberNode.Content.Update(instance);
Helper.TestMemberContentNode(containerNode, memberNode, container, instance, nameof(ObjectContainer.Instance), true);
Helper.TestNonNullObjectReference(memberNode.Content.Reference, instanceNode, instance);
}
public void TestReferenceMember()
{
var obj = new ReferenceMember { Member = new StringMember { Member = "a" } };
var container = new NodeContainer();
var node = container.GetOrCreateNode(obj);
Assert.AreEqual(obj, node.Content.Value);
Assert.AreEqual(1, node.Children.Count);
Assert.AreEqual(nameof(ReferenceMember.Member), node.Children.First().Name);
Assert.AreEqual(obj.Member, node.Children.First().Content.Value);
Assert.AreEqual(true, node.Children.First().Content.IsReference);
Assert.IsInstanceOf<ObjectReference>(node.Children.First().Content.Reference);
var reference = (ObjectReference)node.Children.First().Content.Reference;
Assert.AreEqual(obj.Member, reference.ObjectValue);
Assert.IsNotNull(reference.TargetNode);
Assert.AreEqual(obj.Member, reference.TargetNode.Content.Value);
node = reference.TargetNode;
Assert.AreEqual(obj.Member, node.Content.Value);
Assert.AreEqual(1, node.Children.Count);
Assert.AreEqual(nameof(StringMember.Member), node.Children.First().Name);
Assert.AreEqual(obj.Member.Member, node.Children.First().Content.Value);
obj.Member.Member = "b";
Assert.AreEqual(obj.Member.Member, node.Children.First().Content.Value);
node.Children.First().Content.Update("c");
Assert.AreEqual(obj.Member.Member, node.Children.First().Content.Value);
}
public void TestCloneNewRoot()
{
var obj1 = new Class { ClassMember = new Class(), ListMember = { new Class(), new Class(), new Class() } };
var obj2 = new Class { ClassMember = new Class(), ListMember = { new Class(), new Class(), new Class() } };
var nodeContainer = new NodeContainer();
var newRoot = nodeContainer.GetOrCreateNode(obj2);
var path1 = new GraphNodePath(nodeContainer.GetOrCreateNode(obj1));
var clone = path1.Clone(newRoot);
Assert.AreNotEqual(newRoot, path1.RootNode);
Assert.AreEqual(newRoot, clone.RootNode);
Assert.AreEqual(path1.IsValid, clone.IsValid);
Assert.AreEqual(path1.IsEmpty, clone.IsEmpty);
var path2 = path1.PushMember(nameof(Class.ClassMember)).PushTarget().PushMember(nameof(Class.IntMember));
clone = path2.Clone(newRoot);
Assert.AreNotEqual(newRoot, path2.RootNode);
Assert.AreEqual(newRoot, clone.RootNode);
Assert.AreEqual(path2.IsValid, clone.IsValid);
Assert.AreEqual(path2.IsEmpty, clone.IsEmpty);
var path3 = path1.PushMember(nameof(Class.ListMember)).PushIndex(new Index(1)).PushMember(nameof(Class.IntMember));
clone = path3.Clone(newRoot);
Assert.AreNotEqual(newRoot, path3.RootNode);
Assert.AreEqual(newRoot, clone.RootNode);
Assert.AreEqual(path3.IsValid, clone.IsValid);
Assert.AreEqual(path3.IsEmpty, clone.IsEmpty);
}
public void TestConstruction()
{
var obj = new ClassWithStructs();
var container = new NodeContainer();
container.NodeBuilder.PrimitiveTypes.Add(typeof(PrimitiveStruct));
IGraphNode model = container.GetOrCreateNode(obj);
Helper.PrintModelContainerContent(container, model);
// Members should never have children
Assert.That(model.GetChild("PrimitiveStruct").Children.Count, Is.EqualTo(0));
// Primitive struct has been registered as a primitive type, so it should not hold a reference.
Assert.Null(model.GetChild("PrimitiveStruct").Content.Reference);
// Members should never have children.
Assert.That(model.GetChild("NestedStruct").Children.Count, Is.EqualTo(0));
// NestedStruct members should be accessible via a reference.
Assert.NotNull(model.GetChild("NestedStruct").Content.Reference);
// The referenced node must exist.
var structNode = model.GetChild("NestedStruct").Content.Reference.AsObject.TargetNode;
Assert.NotNull(structNode);
// It should have two children, as the NestedStruct has.
Assert.That(structNode.Children.Count, Is.EqualTo(2));
// Similarly, the Struct member of the NestedStruct should hold a reference.
Assert.NotNull(structNode.GetChild("Struct").Content.Reference);
// The referenced node must exist.
structNode = structNode.GetChild("Struct").Content.Reference.AsObject.TargetNode;
Assert.NotNull(structNode);
// It should have two children, as the SimpleStruct has.
Assert.That(structNode.Children.Count, Is.EqualTo(2));
// Finally, we run the ModelConsistencyCheckVisitor to detect potential other issues.
Helper.ConsistencyCheck(container, obj);
}
public void TestSimpleObject()
{
var nodeContainer = new NodeContainer();
var instance = new SimpleClass { Member1 = 3, Member2 = new SimpleClass() };
var rootNode = nodeContainer.GetOrCreateNode(instance);
var visitor = new TestVisitor();
visitor.Visit(rootNode);
var expectedNodes = new[]
{
rootNode,
rootNode.TryGetChild(nameof(SimpleClass.Member1)),
rootNode.TryGetChild(nameof(SimpleClass.Member2)),
rootNode.TryGetChild(nameof(SimpleClass.Member2)).Target,
rootNode.TryGetChild(nameof(SimpleClass.Member2)).Target.TryGetChild(nameof(SimpleClass.Member1)),
rootNode.TryGetChild(nameof(SimpleClass.Member2)).Target.TryGetChild(nameof(SimpleClass.Member2)),
};
var expectedPaths = new[]
{
new GraphNodePath(rootNode),
new GraphNodePath(rootNode).PushMember(nameof(SimpleClass.Member1)),
new GraphNodePath(rootNode).PushMember(nameof(SimpleClass.Member2)),
new GraphNodePath(rootNode).PushMember(nameof(SimpleClass.Member2)).PushTarget(),
new GraphNodePath(rootNode).PushMember(nameof(SimpleClass.Member2)).PushTarget().PushMember(nameof(SimpleClass.Member1)),
new GraphNodePath(rootNode).PushMember(nameof(SimpleClass.Member2)).PushTarget().PushMember(nameof(SimpleClass.Member2)),
};
VerifyNodesAndPath(expectedNodes, expectedPaths, visitor);
}
public MemberContent(INodeBuilder nodeBuilder, IContent container, IMemberDescriptor member, bool isPrimitive, IReference reference)
: base(nodeBuilder.TypeDescriptorFactory.Find(member.Type), isPrimitive, reference)
{
if (container == null) throw new ArgumentNullException(nameof(container));
Member = member;
Container = container;
nodeContainer = nodeBuilder.NodeContainer;
}
public void UploadNodes(NodeContainer nodes)
{
// for large sets of nodes, this shoud be async with ListBlobsSegmentedAsync
foreach (var node in nodes)
{
this.UploadNode(node);
}
}
public void SearchPathSuccess()
{
var nodes = new NodeContainer
{
new Node()
{
id = 1,
adjacentNodes = new int[] {2, 3},
label = "top"
},
new Node()
{
id = 2,
adjacentNodes = new int[] {1},
label = "second"
},
new Node()
{
id = 3,
adjacentNodes = new int[] {1, 5, 4},
label = "second"
},
new Node()
{
id = 4,
adjacentNodes = new int[] {3},
label = "second"
},
new Node()
{
id = 5,
adjacentNodes = new int[] {3},
label = "blind"
},
new Node()
{
id = 6,
adjacentNodes = new int[] {4},
label = "end"
},
new Node()
{
id = 7,
adjacentNodes = new int[] {1},
label = "blind"
},
};
var graphService = new Graph();
graphService.MakeAdjactedBothWay(nodes);
var search = new SearchPath(nodes);
var result = search.ShortestPath(1, 6);
Assert.AreEqual(new int[] {6,4,3}, result);
}
public void TestChangeBoxedPrimitiveMember()
{
var nodeContainer = new NodeContainer();
var instance = new ComplexClass { Member3 = 3 };
var rootNode = nodeContainer.GetOrCreateNode(instance);
var listener = new GraphNodeChangeListener(rootNode);
var node = rootNode.TryGetChild(nameof(ComplexClass.Member3));
TestContentChange(listener, node, ContentChangeType.ValueChange, Index.Empty, 3, 4, () => node.Content.Update(4));
TestContentChange(listener, node, ContentChangeType.ValueChange, Index.Empty, 4, 5, () => node.Content.Update(5));
}
public static void ConsistencyCheck(NodeContainer container, object rootObject)
{
var visitor = new ModelConsistencyCheckVisitor(container.NodeBuilder);
var model = container.GetNode(rootObject);
visitor.Check((GraphNode)model, rootObject, rootObject.GetType(), true);
foreach (var node in container.Nodes)
{
visitor.Check((GraphNode)node, node.Content.Value, node.Content.Type, true);
}
}
public void TestConstructor()
{
var obj = new Class();
var nodeContainer = new NodeContainer();
var rootNode = nodeContainer.GetOrCreateNode(obj);
var path = new GraphNodePath(rootNode);
Assert.True(path.IsValid);
Assert.True(path.IsEmpty);
Assert.AreEqual(rootNode, path.RootNode);
}
public void TestChangeReferenceMemberToNull()
{
var nodeContainer = new NodeContainer();
var obj = new[] { new SimpleClass(), null, new SimpleClass() };
var instance = new ComplexClass { Member2 = obj[0] };
var rootNode = nodeContainer.GetOrCreateNode(instance);
var listener = new GraphNodeChangeListener(rootNode);
var node = rootNode.TryGetChild(nameof(ComplexClass.Member2));
TestContentChange(listener, node, ContentChangeType.ValueChange, Index.Empty, obj[0], obj[1], () => node.Content.Update(obj[1]));
TestContentChange(listener, node, ContentChangeType.ValueChange, Index.Empty, obj[1], obj[2], () => node.Content.Update(obj[2]));
}
public void TestNullObjectReference()
{
var nodeContainer = new NodeContainer();
var container = new ObjectContainer { Instance = null };
var containerNode = nodeContainer.GetOrCreateNode(container);
Helper.TestNonCollectionObjectContentNode(containerNode, container, 1);
var memberNode = containerNode.Children.First();
Helper.TestMemberContentNode(containerNode, memberNode, container, null, nameof(ObjectContainer.Instance), true);
Helper.TestNullObjectReference(memberNode.Content.Reference);
}
public async Task<NodeContainer> GetAllNodesAsync()
{
var nodeContainer = new NodeContainer();
var blobs = this.ListAllBlobes();
foreach (var blob in blobs)
{
var node = await this.CreateNode(blob).ConfigureAwait(false);
nodeContainer.Add(node);
}
return nodeContainer;
}
public void MakeAdjactedBothWay(NodeContainer nodes)
{
foreach (var node in nodes)
{
foreach (var adjacted in node.adjacentNodes)
{
var adjNode = nodes.GetNode(adjacted);
var corrected = adjNode.adjacentNodes.Concat(new[] {node.id}).ToArray();
adjNode.adjacentNodes = corrected;
}
}
}
public GraphElementContainer GetGraphElements(NodeContainer nodes)
{
this.MakeAdjactedBothWay(nodes);
var paths = Graph.ExtractPaths(nodes);
var container = new GraphElementContainer
{
nodes = nodes.Select(n => new GraphElement<Node> {data = n}).ToList(),
edges = paths.Select(p => new GraphElement<GraphPath> {data = p}).ToList(),
};
return container;
}
public void TestChangeBoxedPrimitiveMember()
{
var nodeContainer = new NodeContainer();
var instance = new ComplexClass { Member3 = 3 };
var rootNode = nodeContainer.GetOrCreateNode(instance);
var dynNode = DynamicNode.FromNode(rootNode);
Assert.AreEqual(instance.Member3, (int)dynNode.Member3);
dynNode.Member3 = 4;
Assert.AreEqual(4, instance.Member3);
Assert.AreEqual(instance.Member3, (int)dynNode.Member3);
rootNode.TryGetChild(nameof(ComplexClass.Member3)).Content.Update(5);
Assert.AreEqual(5, instance.Member3);
Assert.AreEqual(instance.Member3, (int)dynNode.Member3);
}
public void TestSimpleStruct()
{
var nodeContainer = new NodeContainer();
var container = new StructContainer { Struct = new SimpleStruct { Name = "Test", Value = 1 } };
var containerNode = nodeContainer.GetOrCreateNode(container);
Helper.TestNonCollectionObjectContentNode(containerNode, container, 1);
var memberNode = containerNode.Children.First();
Helper.TestMemberContentNode(containerNode, memberNode, container, container.Struct, nameof(StructContainer.Struct), false);
Helper.TestStructContentNode(memberNode, container.Struct, 2);
var structMember1Node = memberNode.Children.First();
Helper.TestMemberContentNode(memberNode, structMember1Node, container.Struct, container.Struct.Name, nameof(SimpleStruct.Name), false);
var structMember2Node = memberNode.Children.Last();
Helper.TestMemberContentNode(memberNode, structMember2Node, container.Struct, container.Struct.Value, nameof(SimpleStruct.Value), false);
}
public void TestPrimitiveMember()
{
var obj = new PrimitiveMember { Member = 5 };
var container = new NodeContainer();
var node = (GraphNode)container.GetOrCreateNode(obj);
Assert.AreEqual(obj, node.Content.Value);
Assert.AreEqual(1, node.Children.Count);
Assert.AreEqual(nameof(PrimitiveMember.Member), node.Children.First().Name);
Assert.AreEqual(obj.Member, node.Children.First().Content.Value);
obj.Member = 6;
Assert.AreEqual(obj.Member, node.Children.First().Content.Value);
node.Children.First().Content.Update(7);
Assert.AreEqual(obj.Member, node.Children.First().Content.Value);
}
public void TestStringMember()
{
var obj = new StringMember { Member = "a" };
var container = new NodeContainer();
var node = (GraphNode)container.GetOrCreateNode(obj);
Assert.AreEqual(obj, node.Content.Value);
Assert.AreEqual(1, node.Children.Count);
Assert.AreEqual(nameof(StringMember.Member), node.Children.First().Name);
Assert.AreEqual(obj.Member, node.Children.First().Content.Value);
obj.Member = "b";
Assert.AreEqual(obj.Member, node.Children.First().Content.Value);
node.Children.First().Content.Update("c");
Assert.AreEqual(obj.Member, node.Children.First().Content.Value);
}
public void TestChangeReferenceMemberToNull()
{
var nodeContainer = new NodeContainer();
var obj = new[] { new SimpleClass(), null, new SimpleClass() };
var instance = new ComplexClass { Member2 = obj[0] };
var rootNode = nodeContainer.GetOrCreateNode(instance);
var dynNode = DynamicNode.FromNode(rootNode);
Assert.AreEqual(instance.Member2, (SimpleClass)dynNode.Member2);
dynNode.Member2 = obj[1];
Assert.AreEqual(obj[1], instance.Member2);
Assert.AreEqual(instance.Member2, (SimpleClass)dynNode.Member2);
rootNode.TryGetChild(nameof(ComplexClass.Member2)).Content.Update(obj[2]);
Assert.AreEqual(obj[2], instance.Member2);
Assert.AreEqual(instance.Member2, (SimpleClass)dynNode.Member2);
}
public void TestDoubleReferenceMemberDataUpdate()
{
var doubleRef = new DoubleReferenceClass(new SimpleObject());
var container = new NodeContainer();
IGraphNode model = container.GetOrCreateNode(doubleRef);
doubleRef.Object1.Name = "New Name";
Assert.That(doubleRef.Object1.Name, Is.EqualTo("New Name"));
Assert.That(doubleRef.Object2.Name, Is.EqualTo("New Name"));
var object1TargetNode = ((ObjectReference)model.GetChild("Object1").Content.Reference).TargetNode;
var object2TargetNode = ((ObjectReference)model.GetChild("Object2").Content.Reference).TargetNode;
Assert.That(object1TargetNode.GetChild("Name").Content.Value, Is.EqualTo("New Name"));
Assert.That(object2TargetNode.GetChild("Name").Content.Value, Is.EqualTo("New Name"));
}
public void TestSimpleStructUpdate()
{
var nodeContainer = new NodeContainer();
var container = new StructContainer { Struct = new SimpleStruct { Name = "Test", Value = 1 } };
var containerNode = nodeContainer.GetOrCreateNode(container);
var memberNode = containerNode.Children.First();
memberNode.Content.Update(new SimpleStruct { Name = "Test2", Value = 2 });
Assert.AreEqual("Test2", container.Struct.Name);
Assert.AreEqual(2, container.Struct.Value);
var structMember1Node = memberNode.Children.First();
Helper.TestMemberContentNode(memberNode, structMember1Node, container.Struct, container.Struct.Name, nameof(SimpleStruct.Name), false);
var structMember2Node = memberNode.Children.Last();
Helper.TestMemberContentNode(memberNode, structMember2Node, container.Struct, container.Struct.Value, nameof(SimpleStruct.Value), false);
}
public static void PrintModelContainerContent(NodeContainer container, IGraphNode rootNode = null)
{
Console.WriteLine(@"Container content:");
Console.WriteLine(@"------------------");
// Print the root node first, if specified
if (rootNode != null)
Console.WriteLine(rootNode.PrintHierarchy());
// Print other nodes next
// TODO: FIXME
//foreach (var node in container.Guids.Select(container.GetNode).Where(x => x != rootNode))
//{
// Console.WriteLine(node.PrintHierarchy());
//}
Console.WriteLine(@"------------------");
}
/// <summary>
/// Set the <see cref="TargetNode"/> and <see cref="TargetGuid"/> of the targeted object by retrieving it from or creating it to the given <see cref="NodeContainer"/>.
/// </summary>
/// <param name="nodeContainer">The <see cref="NodeContainer"/> used to retrieve or create the target node.</param>
public IGraphNode SetTarget(NodeContainer nodeContainer)
{
if (nodeContainer == null) throw new ArgumentNullException("nodeContainer");
IGraphNode targetNode = nodeContainer.GetOrCreateNode(ObjectValue);
if (targetNode != null)
{
if (targetNode.Content.Value != null && !Type.IsInstanceOfType(targetNode.Content.Value)) throw new InvalidOperationException(@"The type of the retrieved node content does not match the type of this reference");
if (TargetNode != null || TargetGuid != Guid.Empty)
throw new InvalidOperationException("TargetNode has already been set.");
if (targetNode.Content.Value != null && !Type.IsInstanceOfType(targetNode.Content.Value))
throw new InvalidOperationException("TargetNode type does not match the reference type.");
TargetNode = targetNode;
TargetGuid = targetNode.Guid;
}
return targetNode;
}
public void TestDoubleReferenceAtConstruction()
{
var doubleRef = new DoubleReferenceClass(new SimpleObject());
var container = new NodeContainer();
IGraphNode model = container.GetOrCreateNode(doubleRef);
Assert.That(doubleRef.Object1, Is.EqualTo(doubleRef.Object2));
Assert.That(model.GetChild("Object1").Content.Value, Is.EqualTo(doubleRef.Object1));
Assert.That(model.GetChild("Object2").Content.Value, Is.EqualTo(doubleRef.Object2));
Assert.That(model.GetChild("Object1").Content.IsReference, Is.True);
Assert.That(model.GetChild("Object2").Content.IsReference, Is.True);
var object1TargetNode = ((ObjectReference)model.GetChild("Object1").Content.Reference).TargetNode;
var object2TargetNode = ((ObjectReference)model.GetChild("Object2").Content.Reference).TargetNode;
Assert.That(object1TargetNode, Is.EqualTo(object2TargetNode));
Assert.That(object1TargetNode.Content.Value, Is.EqualTo(doubleRef.Object1));
}
public void TestObjectReference()
{
var nodeContainer = new NodeContainer();
var instance = new TestObject { Name = "Test" };
var container = new ObjectContainer { Instance = instance };
var containerNode = nodeContainer.GetOrCreateNode(container);
Helper.TestNonCollectionObjectContentNode(containerNode, container, 1);
var memberNode = containerNode.Children.First();
Helper.TestMemberContentNode(containerNode, memberNode, container, instance, nameof(ObjectContainer.Instance), true);
Helper.TestNonNullObjectReference(memberNode.Content.Reference, instance, false);
var instanceNode = nodeContainer.GetNode(instance);
Helper.TestNonNullObjectReference(memberNode.Content.Reference, instanceNode, instance);
memberNode = instanceNode.Children.First();
Helper.TestMemberContentNode(instanceNode, memberNode, instance, instance.Name, nameof(TestObject.Name), false);
}
internal void Refresh(IGraphNode ownerNode, NodeContainer nodeContainer, NodeFactoryDelegate nodeFactory, Index index)
{
var objectValue = ownerNode.Content.Retrieve(index);
if (TargetNode?.Content.Value != objectValue)
{
// This call will recursively update the references.
var target = SetTarget(objectValue, nodeContainer, nodeFactory);
if (target != null)
{
var ownerContent = (ContentBase)ownerNode.Content;
var boxedContent = target.Content as BoxedContent;
boxedContent?.SetOwnerContent(ownerContent, index);
}
}
// This reference is not orphan anymore.
orphanObject = null;
}
public void TestConstruction()
{
var obj = new ClassWithDictionaries();
var container = new NodeContainer();
IGraphNode model = container.GetOrCreateNode(obj);
Helper.PrintModelContainerContent(container, model);
Assert.That(model.TryGetChild("StringIntDic").Children.Count, Is.EqualTo(0));
Assert.That(model.TryGetChild("StringIntDic").Content.Value, Is.SameAs(obj.StringIntDic));
Assert.That(model.TryGetChild("StringIntDic").Content.IsReference, Is.False);
Assert.That(model.TryGetChild("StringClassDic").Children.Count, Is.EqualTo(0));
Assert.That(model.TryGetChild("StringClassDic").Content.Value, Is.SameAs(obj.StringClassDic));
Assert.That(model.TryGetChild("StringClassDic").Content.Reference, Is.AssignableFrom(typeof(ReferenceEnumerable)));
var enumerator = obj.StringClassDic.GetEnumerator();
foreach (var reference in model.TryGetChild("StringClassDic").Content.Reference.AsEnumerable)
{
enumerator.MoveNext();
var keyValuePair = enumerator.Current;
Assert.That(reference.Index, Is.EqualTo(keyValuePair.Key));
Assert.That(reference.ObjectValue, Is.EqualTo(keyValuePair.Value));
}
//Assert.That(model.GetChild("SimpleStructList").Children.Count, Is.EqualTo(0));
//Assert.That(model.GetChild("SimpleStructList").Content.Value, Is.SameAs(obj.SimpleStructList));
//Assert.That(model.GetChild("SimpleStructList").Content.Reference, Is.AssignableFrom(typeof(ReferenceEnumerable)));
//Assert.That(model.GetChild("NestedStructList").Children.Count, Is.EqualTo(0));
//Assert.That(model.GetChild("NestedStructList").Content.Value, Is.SameAs(obj.NestedStructList));
//Assert.That(model.GetChild("NestedStructList").Content.Reference, Is.AssignableFrom(typeof(ReferenceEnumerable)));
//Assert.That(model.GetChild("ListOfSimpleStructLists").Children.Count, Is.EqualTo(0));
//Assert.That(model.GetChild("ListOfSimpleStructLists").Content.Value, Is.SameAs(obj.ListOfSimpleStructLists));
//Assert.That(model.GetChild("ListOfSimpleStructLists").Content.Reference, Is.AssignableFrom(typeof(ReferenceEnumerable)));
//foreach (var reference in (ReferenceEnumerable)model.GetChild("ListOfSimpleStructLists").Content.Reference)
//{
// Assert.That(reference, Is.AssignableFrom(typeof(ReferenceEnumerable)));
//}
//Assert.That(model.GetChild("ListOfNestedStructLists").Children.Count, Is.EqualTo(0));
//Assert.That(model.GetChild("ListOfNestedStructLists").Content.Value, Is.SameAs(obj.ListOfNestedStructLists));
//Assert.That(model.GetChild("ListOfNestedStructLists").Content.Reference, Is.AssignableFrom(typeof(ReferenceEnumerable)));
//foreach (var reference in (ReferenceEnumerable)model.GetChild("ListOfNestedStructLists").Content.Reference)
//{
// Assert.That(reference, Is.AssignableFrom(typeof(ReferenceEnumerable)));
//}
//Assert.That(container.GetNode(obj.ClassList[0]), !Is.Null);
//Assert.That(container.Guids.Count(), Is.EqualTo(10));
}
public void TestCustomFindTargetReference()
{
var nodeContainer = new NodeContainer();
var instance1 = new ObjectListClass {
Member1 = 3, Member2 = new List <SimpleClass> {
new SimpleClass {
Member1 = 1
}, new SimpleClass {
Member1 = 2
}, new SimpleClass {
Member1 = 3
}
}
};
var instance2 = new ObjectListClass {
Member1 = 3, Member2 = new List <SimpleClass> {
new SimpleClass {
Member1 = 2
}, new SimpleClass {
Member1 = 4
}, new SimpleClass {
Member1 = 1
}
}
};
var source = nodeContainer.GetOrCreateNode(instance1);
var target = nodeContainer.GetOrCreateNode(instance2);
var linker = new CustomFindTargetReferenceLinker();
linker.LinkGraph(source, target);
// Expected links by index: 0 -> 2, 1 -> 0, 2 -> null
Index index = new Index(0);
IContentNode tempQualifier = source[nameof(SimpleClass.Member2)];
Index index1 = new Index(2);
IContentNode tempQualifier1 = target[nameof(SimpleClass.Member2)];
Index index2 = new Index(0);
IContentNode tempQualifier2 = source[nameof(SimpleClass.Member2)];
Index index3 = new Index(2);
IContentNode tempQualifier3 = target[nameof(SimpleClass.Member2)];
Index index4 = new Index(0);
IContentNode tempQualifier4 = source[nameof(SimpleClass.Member2)];
Index index5 = new Index(2);
IContentNode tempQualifier5 = target[nameof(SimpleClass.Member2)];
Index index6 = new Index(1);
IContentNode tempQualifier6 = source[nameof(SimpleClass.Member2)];
Index index7 = new Index(0);
IContentNode tempQualifier7 = target[nameof(SimpleClass.Member2)];
Index index8 = new Index(1);
IContentNode tempQualifier8 = source[nameof(SimpleClass.Member2)];
Index index9 = new Index(0);
IContentNode tempQualifier9 = target[nameof(SimpleClass.Member2)];
Index index10 = new Index(1);
IContentNode tempQualifier10 = source[nameof(SimpleClass.Member2)];
Index index11 = new Index(0);
IContentNode tempQualifier11 = target[nameof(SimpleClass.Member2)];
Index index12 = new Index(2);
IContentNode tempQualifier12 = source[nameof(SimpleClass.Member2)];
Index index13 = new Index(2);
IContentNode tempQualifier13 = source[nameof(SimpleClass.Member2)];
Index index14 = new Index(2);
IContentNode tempQualifier14 = source[nameof(SimpleClass.Member2)];
var expectedLinks = new Dictionary <IContentNode, IContentNode>
{
{ source, target },
{ source[nameof(SimpleClass.Member1)], target[nameof(SimpleClass.Member1)] },
{ source[nameof(SimpleClass.Member2)], target[nameof(SimpleClass.Member2)] },
{ tempQualifier.IndexedTarget(index), tempQualifier1.IndexedTarget(index1) },
{ tempQualifier2.IndexedTarget(index2)[nameof(SimpleClass.Member1)], tempQualifier3.IndexedTarget(index3)[nameof(SimpleClass.Member1)] },
{ tempQualifier4.IndexedTarget(index4)[nameof(SimpleClass.Member2)], tempQualifier5.IndexedTarget(index5)[nameof(SimpleClass.Member2)] },
{ tempQualifier6.IndexedTarget(index6), tempQualifier7.IndexedTarget(index7) },
{ tempQualifier8.IndexedTarget(index8)[nameof(SimpleClass.Member1)], tempQualifier9.IndexedTarget(index9)[nameof(SimpleClass.Member1)] },
{ tempQualifier10.IndexedTarget(index10)[nameof(SimpleClass.Member2)], tempQualifier11.IndexedTarget(index11)[nameof(SimpleClass.Member2)] },
{ tempQualifier12.IndexedTarget(index12), null },
{ tempQualifier13.IndexedTarget(index13)[nameof(SimpleClass.Member1)], null },
{ tempQualifier14.IndexedTarget(index14)[nameof(SimpleClass.Member2)], null },
};
VerifyLinks(expectedLinks, linker);
}
public CustomFindTargetLinker(NodeContainer container, IGraphNode root)
{
this.root = root;
CustomTarget = container.GetOrCreateNode(new SimpleClass());
}
public BoundInventory(ItemDB itemDB, ItemInventory item, ItemManager itemManager, NodeContainer nodeContainer, BoundServiceManager manager) : base(manager)
{
this.mInventory = item;
this.mFlag = ItemFlags.None;
this.ItemDB = itemDB;
this.ItemManager = itemManager;
this.NodeContainer = nodeContainer;
}
public void TestCircularReference()
{
var nodeContainer = new NodeContainer();
var obj1 = new SimpleClass {
Member1 = 3
};
var obj2 = new SimpleClass {
Member1 = 3
};
obj1.Member2 = obj2;
obj2.Member2 = obj1;
var rootNode1 = nodeContainer.GetOrCreateNode(obj1);
var rootNode2 = nodeContainer.GetOrCreateNode(obj2);
var visitor = new TestVisitor();
visitor.Visit(rootNode1);
var expectedNodes = new IGraphNode[]
{
rootNode1,
rootNode1[nameof(SimpleClass.Member1)],
rootNode1[nameof(SimpleClass.Member2)],
rootNode2,
rootNode2[nameof(SimpleClass.Member1)],
rootNode2[nameof(SimpleClass.Member2)],
};
var expectedPaths = new GraphNodePath[6];
expectedPaths[0] = new GraphNodePath(rootNode1);
expectedPaths[1] = expectedPaths[0].Clone();
expectedPaths[1].PushMember(nameof(SimpleClass.Member1));
expectedPaths[2] = expectedPaths[0].Clone();
expectedPaths[2].PushMember(nameof(SimpleClass.Member2));
expectedPaths[3] = expectedPaths[2].Clone();
expectedPaths[3].PushTarget();
expectedPaths[4] = expectedPaths[3].Clone();
expectedPaths[4].PushMember(nameof(SimpleClass.Member1));
expectedPaths[5] = expectedPaths[3].Clone();
expectedPaths[5].PushMember(nameof(SimpleClass.Member2));
VerifyNodesAndPath(expectedNodes, expectedPaths, visitor);
visitor.Visit(rootNode2);
expectedNodes = new IGraphNode[]
{
rootNode2,
rootNode2[nameof(SimpleClass.Member1)],
rootNode2[nameof(SimpleClass.Member2)],
rootNode1,
rootNode1[nameof(SimpleClass.Member1)],
rootNode1[nameof(SimpleClass.Member2)],
};
expectedPaths = new GraphNodePath[6];
expectedPaths[0] = new GraphNodePath(rootNode2);
expectedPaths[1] = expectedPaths[0].Clone();
expectedPaths[1].PushMember(nameof(SimpleClass.Member1));
expectedPaths[2] = expectedPaths[0].Clone();
expectedPaths[2].PushMember(nameof(SimpleClass.Member2));
expectedPaths[3] = expectedPaths[2].Clone();
expectedPaths[3].PushTarget();
expectedPaths[4] = expectedPaths[3].Clone();
expectedPaths[4].PushMember(nameof(SimpleClass.Member1));
expectedPaths[5] = expectedPaths[3].Clone();
expectedPaths[5].PushMember(nameof(SimpleClass.Member2));
VerifyNodesAndPath(expectedNodes, expectedPaths, visitor);
}
//public class JoPaths
//{
// public string getpath { get; set; }
//}
public async void handle(Object myClientSocket)
{
Socket ClientSocket = null;
try
{
ClientSocket = (Socket)myClientSocket;
Projection projection = new Projection();
WindowControl wc = new WindowControl();
Applacation app = new Applacation();
MediaFunction media = new MediaFunction();
Game game = new Game();
Response response = null;
//test = windows.BackGroundWindow.Instance();
Console.WriteLine("name is:{0}", name);
log.Info(string.Format("接收到手机发来的指令 name = {0}，command = {1}，param = {2}", name, command, param));
switch (name)
{
case CommandName.PC:
if (command.Equals("AddDirsHTTP"))
{
string status = null;
bool flag = true;
Console.WriteLine("paths is:{0}", param["paths"]);
String[] pathlist = param["paths"].Split(new char[] { '?' }, StringSplitOptions.RemoveEmptyEntries);
//List<JoPaths> pathlist = JsonConvert.DeserializeObject<List<JoPaths>>(param["paths"]);
//List<JoPaths> err_pathlist = new List<JoPaths>();
//String[] err_pathlist = null;
List <string> err_pathlist = new List <string>();
foreach (string path in pathlist)
{
Console.WriteLine("path is:{0}" + path);
string dirPath = path;
if (File.Exists(dirPath) || Directory.Exists(dirPath))
{
if (Directory.Exists(dirPath))
{
DirectoryInfo Folder = new DirectoryInfo(dirPath);
foreach (FileInfo file in Folder.GetFiles())
{
if (File.Exists(file.FullName))
{
Console.WriteLine("file fullname_1 is:{0}", file.FullName);
Node node = new Node(file.FullName);
NodeContainer.addNode(node);
}
}
}
else
{
FileInfo file = new FileInfo(dirPath);
Console.WriteLine("file fullname_2 is:{0}", file.FullName);
Node node = new Node(file.FullName);
NodeContainer.addNode(node);
}
Console.WriteLine("status:200");
}
else
{
flag = false;
err_pathlist.Add(path);
Console.WriteLine("status:404");
}
}
if (flag)
{
status = "200";
}
else
{
status = "404";
}
//string errpaths = "{\"errorPaths:\"" + "\"" + err_pathlist +"\"}";
response = new Response(status, "", CommandName.PC, err_pathlist);
ClientSocket.Send(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(response)));
}
else if (command.Equals("close"))
{
Environment.Exit(0);
}
else if (command.Equals("SEARCH"))
{
string key = param["key"];
List <MediaMengMeng> allmedia = util.config.MediaConfig.SearchAll(key);
response = new Response("200", "", CommandName.PC, JsonConvert.SerializeObject(allmedia));
ClientSocket.Send(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(response)));
}
break;
case CommandName.VIDEO:
if (command.Equals("PLAY"))
{
PlayMedia(param["tvname"], param["path"]);
media.AddRecentMeiaList(new MediaItem(param["path"]));
response = new Response("200", "", CommandName.VIDEO, null); //////////////////////////////////////
ClientSocket.Send(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(response)));
}
else if (command.Equals("GETTOTALLIST"))
{
response = new Response("200", "", CommandName.VIDEO, JsonConvert.SerializeObject(media.getMediasByPath("VIDEO", param["folder"])));
ClientSocket.Send(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(response)));
}
else if (command.Equals("GETRECENTLIST"))
{
response = new Response("200", "", CommandName.VIDEO, JsonConvert.SerializeObject(media.GetRecentVideoList()));
ClientSocket.Send(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(response)));
}
else if (command.Equals("DELETE"))
{
if (media.DeletMyMediaLibrary("UserVideoConfig", param["folder"]))
{
response = new Response("200", "DELETE_SUCCESS", CommandName.VIDEO, null);
}
else
{
response = new Response("404", "DELETE_FAILED", CommandName.VIDEO, null);
}
ClientSocket.Send(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(response)));
}
break;
case CommandName.AUDIO:
if (command.Equals("PLAY"))
{
PlayMedia(param["tvname"], param["path"]);
media.AddRecentMeiaList(new MediaItem(param["path"]));
response = new Response("200", "", CommandName.AUDIO, null);
ClientSocket.Send(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(response)));
}
else if (command.Equals("GETTOTALLIST"))
{
response = new Response("200", "", CommandName.AUDIO, JsonConvert.SerializeObject(media.getMediasByPath("AUDIO", param["folder"])));
ClientSocket.Send(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(response)));
}
else if (command.Equals("GETRECENTLIST"))
{
response = new Response("200", "", CommandName.AUDIO, JsonConvert.SerializeObject(media.GetRecentAudioList()));
ClientSocket.Send(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(response)));
}
else if (command.Equals("GETSETS"))
{
response = new Response("200", "", CommandName.AUDIO, JsonConvert.SerializeObject(media.GetAudioSet()));
ClientSocket.Send(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(response)));
}
else if (command.Equals("ADDSET"))
{
if (media.AddAudioSet(param["setname"]))
{
response = new Response("200", "", CommandName.AUDIO, null);
}
else
{
response = new Response("404", "", CommandName.AUDIO, null);
}
ClientSocket.Send(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(response)));
}
else if (command.Equals("ADDFILESTOSET"))
{
string s = param["liststr"];
if (media.AddAudioSet(param["setname"], JsonConvert.DeserializeObject <List <MediaMengMeng> >(s)))
{
response = new Response("200", "", CommandName.AUDIO, null);
}
else
{
response = new Response("404", "", CommandName.AUDIO, null);
}
ClientSocket.Send(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(response)));
}
else if (command.Equals("DELETESET"))
{
if (media.DeleteAudiSet(param["setname"]))
{
response = new Response("200", "", CommandName.AUDIO, null);
}
else
{
response = new Response("404", "", CommandName.AUDIO, null);
}
ClientSocket.Send(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(response)));
}
else if (command.Equals("PLAYSET"))
{
bool re;
//if (!param.ContainsKey("asBGM"))
//{
// re = PlayMedias(param["tvname"], "audio", param["setname"]);
//}
//else
//{
re = PlayMedias(param["tvname"], "audio", param["setname"]);
//}
if (re)
{
List <MediaMengMeng> list = media.GetAudioSet()[param["setname"]];
if (list.Count < 10)
{
foreach (MediaMengMeng m in list)
{
media.AddRecentAudioList(m);
}
}
else
{
for (int i = list.Count - 10; i < list.Count; i++)
{
media.AddRecentAudioList(list[i]);
}
}
response = new Response("200", "", CommandName.AUDIO, null);
}
else
{
response = new Response("404", "", CommandName.AUDIO, null);
}
ClientSocket.Send(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(response)));
}
else if (command.Equals("PLAYSETASBGM"))
{
bool re;
re = PlayMedias(param["tvname"], "audio", param["setname"], null);
if (re)
{
List <MediaMengMeng> list = media.GetAudioSet()[param["setname"]];
if (list.Count < 10)
{
foreach (MediaMengMeng m in list)
{
media.AddRecentAudioList(m);
}
}
else
{
for (int i = list.Count - 10; i < list.Count; i++)
{
media.AddRecentAudioList(list[i]);
}
}
response = new Response("200", "", CommandName.AUDIO, null);
}
else
{
response = new Response("404", "", CommandName.AUDIO, null);
}
ClientSocket.Send(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(response)));
}
else if (command.Equals("DELETE"))
{
if (media.DeletMyMediaLibrary("UserAudioConfig", param["folder"]))
{
response = new Response("200", "DELETE_SUCCESS", CommandName.AUDIO, null);
}
else
{
response = new Response("404", "DELETE_FAILED", CommandName.AUDIO, null);
}
ClientSocket.Send(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(response)));
}
break;
case CommandName.IMAGE:
if (command.Equals("PLAY"))
{
PlayMedia(param["tvname"], param["path"]);
response = new Response("200", "", CommandName.IMAGE, null);
ClientSocket.Send(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(response)));
}
else if (command.Equals("PLAYALL"))
{
List <MediaMengMeng> l = media.getMediasByPath("IMAGE", param["folder"]);
List <string> urls = new List <string>();
foreach (MediaMengMeng m in l)
{
info.media.MediaItem mi = new info.media.MediaItem(m.pathName);
urls.Add(mi.url);
}
foreach (info.tv.TVInfo item in MyInfo.tvLibrary.value)
{
if (item.name.Equals(param["tvname"]))
{
function.tv.TVFunction.sendCommand(item.ip, info.tv.TVCommand.GetInstance("OPEN_HTTP_MEDIA", null, false, "", "image", urls, null));
}
}
//foreach (var ls in list)
//{
// PlayMedia(param["tvname"], ls[""]);
//}
response = new Response("200", "", CommandName.IMAGE, null);
ClientSocket.Send(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(response)));
}
else if (command.Equals("GETTOTALLIST"))
{
List <MediaMengMeng> list = media.getMediasByPath("IMAGE", param["folder"]);
response = new Response("200", "", CommandName.IMAGE, JsonConvert.SerializeObject(list));
ClientSocket.Send(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(response)));
}
else if (command.Equals("GETSETS"))
{
response = new Response("200", "", CommandName.IMAGE, JsonConvert.SerializeObject(media.GetImageSet()));
ClientSocket.Send(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(response)));
}
else if (command.Equals("ADDSET"))
{
if (media.AddImageSet(param["setname"]))
{
response = new Response("200", "", CommandName.IMAGE, null);
}
else
{
response = new Response("404", "", CommandName.IMAGE, null);
}
ClientSocket.Send(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(response)));
}
else if (command.Equals("ADDFILESTOSET"))
{
string s = param["liststr"];
if (media.AddImageSet(param["setname"], JsonConvert.DeserializeObject <List <MediaMengMeng> >(s)))
{
response = new Response("200", "", CommandName.IMAGE, null);
}
else
{
response = new Response("404", "", CommandName.IMAGE, null);
}
ClientSocket.Send(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(response)));
}
else if (command.Equals("DELETESET"))
{
if (media.DeleteImageSet(param["setname"]))
{
response = new Response("200", "", CommandName.IMAGE, null);
}
else
{
response = new Response("404", "", CommandName.IMAGE, null);
}
ClientSocket.Send(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(response)));
}
else if (command.Equals("PLAYSET"))
{
bool re = PlayMedias(param["tvname"], "image", param["setname"]);
if (re)
{
List <MediaMengMeng> list = media.GetImageSet()[param["setname"]];
if (list.Count < 10)
{
foreach (MediaMengMeng m in list)
{
media.AddRecentImageList(m);
}
}
else
{
for (int i = list.Count - 10; i < list.Count; i++)
{
media.AddRecentImageList(list[i]);
}
}
response = new Response("200", "", CommandName.IMAGE, null);
}
else
{
response = new Response("404", "", CommandName.IMAGE, null);
}
ClientSocket.Send(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(response)));
}
else if (command.Equals("DELETE"))
{
if (media.DeletMyMediaLibrary("UserImageConfig", param["folder"]))
{
response = new Response("200", "DELETE_SUCCESS", CommandName.VIDEO, null);
}
else
{
response = new Response("404", "DELETE_FAILED", CommandName.VIDEO, null);
}
ClientSocket.Send(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(response)));
}
break;
case CommandName.APP:
if (command.Equals("GETTOTALLIST"))
{
response = new Response("200", "", CommandName.APP, JsonConvert.SerializeObject(app.GetAppList()));
ClientSocket.Send(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(response)));
}
else if (command.Equals("OPEN_RDP"))
{
if ((string)param["path"] == "back")
{
App.Current.Dispatcher.Invoke((Action)(() =>
{
System.Windows.Window test = windows.BackGroundWindow.Instance();
test.Hide();
}));
app.CloseAll();
Type oleType = Type.GetTypeFromProgID("Shell.Application");
object oleObject = System.Activator.CreateInstance(oleType);
oleType.InvokeMember("ToggleDesktop", BindingFlags.InvokeMethod, null, oleObject, null);
}
else
{
App.Current.Dispatcher.Invoke((Action)(() =>
{
System.Windows.Window test = windows.BackGroundWindow.Instance();
test.Show();
}));
app.OpenApp((string)param["path"], "");
}
}
else if (command.Equals("OPEN_MIRACAST"))
{
//WindowControl.SetTaskBarState(0);
if (!projection.IsConnection())
{
app.CloseAll();
//projection.EnterQS();
//projection.ClosePopup();
}
Process pro;
pro = app.OpenApp((string)param["path"], "");
//Console.WriteLine(System.Windows.Forms.Screen.AllScreens.Last());
DeviceItem item = util.config.UserScreenConfig.GetScreen(param["tvname"]);
if (item != null)
{
await projection.SelectProjectionDevice(item.screen);
wc.MoveWindow(pro, System.Windows.Forms.Screen.AllScreens.Last(), true);
response = new Response("200", "", CommandName.APP, null);
}
else
{
response = new Response("404", "don't have set miracast", CommandName.APP, null);
}
//projection.ClearMiracastPopup();
ClientSocket.Send(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(response)));
}
break;
case CommandName.GAME:
if (command.Equals("GETTOTALLIST"))
{
response = new Response("200", "", CommandName.GAME, JsonConvert.SerializeObject(game.GetGameList()));
ClientSocket.Send(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(response)));
}
else if (command.Equals("OPEN"))
{
game.OpenGame(param["path"], "");
response = new Response("200", "", CommandName.GAME, null);
ClientSocket.Send(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(response)));
}
break;
case CommandName.SYS:
if (command.Equals("GETINFOR"))
{
response = new Response("200", "", CommandName.SYS, JsonConvert.SerializeObject(function.pcapp.PCInformation.GetInstance()));
ClientSocket.Send(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(response)));
}
else if (command.Equals("GETSCREENSTATE"))
{
if (MyInfo.IsSreenLock)
{
response = new Response("404", "", CommandName.SYS, null);
}
else
{
response = new Response("200", "", CommandName.SYS, null);
}
ClientSocket.Send(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(response)));
}
break;
case CommandName.SECURITY:
if (command.Equals("PAIR"))
{
string code = param["code"];
if (code.Equals(PairCodeConfig.GetPairCode()))
{
response = new Response("200", "", CommandName.SECURITY, "true");
}
else
{
response = new Response("200", "", CommandName.SECURITY, "false");
}
ClientSocket.Send(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(response)));
}
break;
}
log.InfoFormat("Command 接受到的命令: {0},返回的结果: {1}", JsonConvert.SerializeObject(this), JsonConvert.SerializeObject(response));
ClientSocket.Close();
}
catch (Exception e)
{
if (ClientSocket != null)
{
ClientSocket.Close();
}
log.Error("Comand 执行出错", e);
}
}
public void Refresh(IGraphNode ownerNode, NodeContainer nodeContainer, NodeFactoryDelegate nodeFactory)
{
var newObjectValue = ownerNode.Content.Value;
if (!(newObjectValue is IEnumerable))
{
throw new ArgumentException(@"The object is not an IEnumerable", nameof(newObjectValue));
}
ObjectValue = newObjectValue;
var newReferences = new HybridDictionary <Index, ObjectReference>();
if (IsDictionary)
{
foreach (var item in (IEnumerable)ObjectValue)
{
var key = GetKey(item);
var value = (ObjectReference)Reference.CreateReference(GetValue(item), elementType, key);
newReferences.Add(key, value);
}
}
else
{
var i = 0;
foreach (var item in (IEnumerable)ObjectValue)
{
var key = new Index(i);
var value = (ObjectReference)Reference.CreateReference(item, elementType, key);
newReferences.Add(key, value);
++i;
}
}
// The reference need to be updated if it has never been initialized, if the number of items is different, or if any index or any value is different.
var needUpdate = items == null || newReferences.Count != items.Count || !AreItemsEqual(items, newReferences);
if (needUpdate)
{
// We create a mapping values of the old list of references to their corresponding target node. We use a list because we can have multiple times the same target in items.
var oldReferenceMapping = new List <KeyValuePair <object, ObjectReference> >();
if (items != null)
{
oldReferenceMapping.AddRange(items.Values.Where(x => x.ObjectValue != null && !(x.TargetNode?.Content is BoxedContent)).Select(x => new KeyValuePair <object, ObjectReference>(x.ObjectValue, x)));
}
foreach (var newReference in newReferences)
{
if (newReference.Value.ObjectValue != null)
{
var found = false;
var i = 0;
foreach (var item in oldReferenceMapping)
{
if (Equals(newReference.Value.ObjectValue, item.Key))
{
// If this value was already present in the old list of reference, just use the same target node in the new list.
newReference.Value.SetTarget(item.Value.TargetNode);
// Remove consumed existing reference so if there is a second entry with the same "key", it will be the other reference that will be used.
oldReferenceMapping.RemoveAt(i);
found = true;
break;
}
++i;
}
if (!found)
{
// Otherwise, do a full update that will properly initialize the new reference.
newReference.Value.Refresh(ownerNode, nodeContainer, nodeFactory, newReference.Key);
}
}
}
items = newReferences;
// Remark: this works because both KeyCollection and List implements IReadOnlyCollection. Any internal change to HybridDictionary might break this!
Indices = (IReadOnlyCollection <Index>)newReferences.Keys;
}
}
public void HasChildNodesGetShouldReturnFalseWhenNoCollection()
{
NodeContainer target = CreateNodeContainer();
Assert.IsFalse(target.HasChildNodes);
}
public void TestEquals()
{
// Note: comparing GraphNodePath.GetHashCode() returns true when the root node is equivalent. This is because the root node is the only invariant.
var obj = new Class {
StructMember = { StringMember = "aa" }, ClassMember = new Class(), ListMember = { new Class(), new Class(), new Class() }
};
var nodeContainer = new NodeContainer();
var path1 = new GraphNodePath(nodeContainer.GetOrCreateNode(obj));
path1.PushMember(nameof(Class.IntMember));
var path2 = new GraphNodePath(nodeContainer.GetOrCreateNode(obj));
path2.PushMember(nameof(Class.IntMember));
AssertAreEqual(path1.GetHashCode(), path2.GetHashCode());
AssertAreEqual(path1, path2);
path1 = new GraphNodePath(nodeContainer.GetOrCreateNode(obj));
path1.PushMember(nameof(Class.ClassMember));
AssertAreEqual(path1.GetHashCode(), path2.GetHashCode());
AssertAreNotEqual(path1, path2);
path2 = new GraphNodePath(nodeContainer.GetOrCreateNode(obj));
path2.PushMember(nameof(Class.ClassMember));
AssertAreEqual(path1.GetHashCode(), path2.GetHashCode());
AssertAreEqual(path1, path2);
path1 = new GraphNodePath(nodeContainer.GetOrCreateNode(obj));
path1.PushMember(nameof(Class.ClassMember));
path1.PushTarget();
AssertAreEqual(path1.GetHashCode(), path2.GetHashCode());
AssertAreNotEqual(path1, path2);
path2 = new GraphNodePath(nodeContainer.GetOrCreateNode(obj));
path2.PushMember(nameof(Class.ClassMember));
path2.PushTarget();
AssertAreEqual(path1.GetHashCode(), path2.GetHashCode());
AssertAreEqual(path1, path2);
path1 = new GraphNodePath(nodeContainer.GetOrCreateNode(obj));
path1.PushMember(nameof(Class.ClassMember));
path1.PushTarget();
path1.PushMember(nameof(Class.IntMember));
AssertAreEqual(path1.GetHashCode(), path2.GetHashCode());
AssertAreNotEqual(path1, path2);
path2 = new GraphNodePath(nodeContainer.GetOrCreateNode(obj));
path2.PushMember(nameof(Class.ClassMember));
path2.PushTarget();
path2.PushMember(nameof(Class.IntMember));
AssertAreEqual(path1.GetHashCode(), path2.GetHashCode());
AssertAreEqual(path1, path2);
path1 = new GraphNodePath(nodeContainer.GetOrCreateNode(obj));
path1.PushMember(nameof(Class.ListMember));
path1.PushIndex(new NodeIndex(0));
AssertAreEqual(path1.GetHashCode(), path2.GetHashCode());
AssertAreNotEqual(path1, path2);
path2 = new GraphNodePath(nodeContainer.GetOrCreateNode(obj));
path2.PushMember(nameof(Class.ListMember));
path2.PushIndex(new NodeIndex(0));
AssertAreEqual(path1.GetHashCode(), path2.GetHashCode());
AssertAreEqual(path1, path2);
path2 = new GraphNodePath(nodeContainer.GetOrCreateNode(obj));
path2.PushMember(nameof(Class.ListMember));
path2.PushIndex(new NodeIndex(1));
AssertAreEqual(path1.GetHashCode(), path2.GetHashCode());
AssertAreNotEqual(path1, path2);
}
/// <inheritdoc />
protected override IObjectNode GetPropertiesRootNode()
{
return(NodeContainer.GetNode(((UIAssetBase)Asset).Design));
}
public character(CacheStorage cacheStorage, CharacterDB db, ChatDB chatDB, ItemFactory itemFactory, Logger logger, Configuration.Character configuration, NodeContainer container, NotificationManager notificationManager)
{
this.Log = logger.CreateLogChannel("character");
this.mConfiguration = configuration;
this.DB = db;
this.ChatDB = chatDB;
this.ItemFactory = itemFactory;
this.CacheStorage = cacheStorage;
this.Container = container;
this.NotificationManager = notificationManager;
this.mBloodlineCache = this.DB.GetBloodlineInformation();
this.mAncestriesCache = this.DB.GetAncestryInformation(this.mBloodlineCache);
}
public ConfigDB(NodeContainer nodeContainer, DatabaseConnection db) : base(db)
{
this.NodeContainer = nodeContainer;
}
public BoundInventory(ItemDB itemDB, ItemInventory item, Flags flag, ItemFactory itemFactory, NodeContainer nodeContainer, BoundServiceManager manager, Client client) : base(manager, client)
{
this.mInventory = item;
this.mFlag = flag;
this.ItemDB = itemDB;
this.ItemFactory = itemFactory;
this.NodeContainer = nodeContainer;
}
public static ObservableViewModel CombineViewModels(IViewModelServiceProvider serviceProvider, NodeContainer nodeContainer, IReadOnlyCollection <ObservableViewModel> viewModels)
{
if (viewModels == null)
{
throw new ArgumentNullException(nameof(viewModels));
}
var combinedViewModel = new ObservableViewModel(serviceProvider, nodeContainer, viewModels.SelectMany(x => x.Dirtiables));
var rootNodes = new List <ObservableModelNode>();
foreach (var viewModel in viewModels)
{
if (!(viewModel.RootNode is SingleObservableNode))
{
throw new ArgumentException(@"The view models to combine must contains SingleObservableNode.", nameof(viewModels));
}
viewModel.parent = combinedViewModel;
var rootNode = (ObservableModelNode)viewModel.RootNode;
rootNodes.Add(rootNode);
}
if (rootNodes.Count < 2)
{
throw new ArgumentException(@"Called CombineViewModels with a collection of view models that is either empty or containt just a single item.", nameof(viewModels));
}
// Find best match for the root node type
var rootNodeType = rootNodes.First().Root.Type;
if (rootNodes.Skip(1).Any(x => x.Type != rootNodeType))
{
rootNodeType = typeof(object);
}
CombinedObservableNode rootCombinedNode = CombinedObservableNode.Create(combinedViewModel, "Root", null, rootNodeType, rootNodes, null);
rootCombinedNode.Initialize();
combinedViewModel.RootNode = rootCombinedNode;
return(combinedViewModel);
}
public static PySubStruct BindInventory(ItemDB itemDB, ItemInventory item, Flags flag, ItemFactory itemFactory, NodeContainer nodeContainer, BoundServiceManager boundServiceManager, Client client)
{
BoundService instance = new BoundInventory(itemDB, item, flag, itemFactory, nodeContainer, boundServiceManager, client);
// bind the service
int boundID = boundServiceManager.BoundService(instance);
// build the bound service string
string boundServiceStr = boundServiceManager.BuildBoundServiceString(boundID);
// TODO: the expiration time is 1 day, might be better to properly support this?
// TODO: investigate these a bit more closely in the future
// TODO: i'm not so sure about the expiration time
PyTuple boundServiceInformation = new PyTuple(2)
{
[0] = boundServiceStr,
[1] = DateTime.UtcNow.Add(TimeSpan.FromDays(1)).ToFileTime()
};
// after the service is bound the call can be run (if required)
return(new PySubStruct(new PySubStream(boundServiceInformation)));
}
public void Refresh(IGraphNode ownerNode, NodeContainer nodeContainer, NodeFactoryDelegate nodeFactory)
{
Refresh(ownerNode, nodeContainer, nodeFactory, Index.Empty);
}
//SubElement Ends G o svg element
public void OnEndElement(string name)
{
currentContainer = currentContainer.parent;
}
public void Refresh(IContentNode ownerNode, NodeContainer nodeContainer)
{
Refresh(ownerNode, nodeContainer, Index.Empty);
}
/// <summary>
/// Initializes a new instance of the <see cref="PropertiesViewModel"/> class.
/// </summary>
/// <param name="serviceProvider">The view model service provider to use.</param>
/// <param name="nodeContainer">The <see cref="NodeContainer"/> containing the nodes used to access object properties.</param>
protected PropertiesViewModel([NotNull] IViewModelServiceProvider serviceProvider, [NotNull] NodeContainer nodeContainer)
: base(serviceProvider)
{
if (nodeContainer == null)
{
throw new ArgumentNullException(nameof(nodeContainer));
}
NodeContainer = nodeContainer;
// Create the service needed to manage graph view models
ViewModelService = new GraphViewModelService(nodeContainer);
// Update the service provider of this view model to contains the GraphViewModelService we created.
ServiceProvider = new ViewModelServiceProvider(serviceProvider, ViewModelService.Yield());
RegisterNodePresenterCommand(new CreateNewInstanceCommand());
RegisterNodePresenterCommand(new AddNewItemCommand());
RegisterNodePresenterCommand(new AddPrimitiveKeyCommand());
RegisterNodePresenterCommand(new RemoveItemCommand());
RegisterNodePresenterCommand(new RenameStringKeyCommand());
RegisterNodePresenterCommand(new MoveItemCommand());
RegisterNodePresenterCommand(new FlagEnumSelectAllCommand());
RegisterNodePresenterCommand(new FlagEnumSelectNoneCommand());
RegisterNodePresenterCommand(new FlagEnumSelectInvertCommand());
RegisterNodePresenterUpdater(new AbstractNodeEntryNodeUpdater());
RegisterNodePresenterUpdater(new CategoryNodeUpdater());
RegisterNodePresenterUpdater(new CollectionPropertyNodeUpdater());
RegisterNodePresenterUpdater(new DisplayAttributeNodeUpdater());
RegisterNodePresenterUpdater(new MathematicsNodeUpdater());
RegisterNodePresenterUpdater(new NumericValueNodeUpdater());
RegisterNodePresenterUpdater(new UPathNodeUpdater());
// Note: try to keep InlineMemberNodeUpdater last since it's transfering some metadata generated by previous updater between nodes
RegisterNodePresenterUpdater(new InlineMemberNodeUpdater());
}
public ItemManager(Logger logger, NodeContainer nodeContainer)
{
// create a log channel for the rare occurence of the ItemManager wanting to log something
this.Log = logger.CreateLogChannel("ItemManager");
this.NodeContainer = nodeContainer;
}
public void TestNullLists()
{
var obj = new ClassWithNullLists();
var container = new NodeContainer();
var model = container.GetOrCreateNode(obj);
}
public LSC(ChatDB db, MessagesDB messagesDB, CharacterDB characterDB, ItemFactory itemFactory, NodeContainer nodeContainer, Logger logger, NotificationManager notificationManager, MachoNet machoNet, MailManager mailManager)
{
this.DB = db;
this.MessagesDB = messagesDB;
this.CharacterDB = characterDB;
this.ItemFactory = itemFactory;
this.NodeContainer = nodeContainer;
this.NotificationManager = notificationManager;
this.MachoNet = machoNet;
this.MailManager = mailManager;
this.Log = logger.CreateLogChannel("LSC");
}
public ServiceManager(
NodeContainer container, CacheStorage storage, Logger logger, TimerManager timerManager,
BoundServiceManager boundServiceManager,
machoNet machoNet,
objectCaching objectCaching,
alert alert,
authentication authentication,
character character,
userSvc userSvc,
charmgr charmgr,
config config,
dogmaIM dogmaIM,
invbroker invbroker,
warRegistry warRegistry,
station station,
map map,
account account,
skillMgr skillMgr,
contractMgr contractMgr,
corpStationMgr corpStationMgr,
bookmark bookmark,
LSC LSC,
onlineStatus onlineStatus,
billMgr billMgr,
facWarMgr facWarMgr,
corporationSvc corporationSvc,
clientStatsMgr clientStatsMgr,
voiceMgr voiceMgr,
standing2 standing2,
tutorialSvc tutorialSvc,
agentMgr agentMgr,
corpRegistry corpRegistry,
marketProxy marketProxy,
stationSvc stationSvc,
certificateMgr certificateMgr,
jumpCloneSvc jumpCloneSvc,
LPSvc LPSvc,
lookupSvc lookupSvc,
insuranceSvc insuranceSvc,
slash slash,
ship ship,
corpmgr corpmgr,
repairSvc repairSvc,
reprocessingSvc reprocessingSvc,
ramProxy ramProxy,
factory factory)
{
this.Container = container;
this.CacheStorage = storage;
this.BoundServiceManager = boundServiceManager;
this.TimerManager = timerManager;
this.Logger = logger;
this.Log = this.Logger.CreateLogChannel("ServiceManager");
// store all the services
this.machoNet = machoNet;
this.objectCaching = objectCaching;
this.alert = alert;
this.authentication = authentication;
this.character = character;
this.userSvc = userSvc;
this.charmgr = charmgr;
this.config = config;
this.dogmaIM = dogmaIM;
this.invbroker = invbroker;
this.warRegistry = warRegistry;
this.station = station;
this.map = map;
this.account = account;
this.skillMgr = skillMgr;
this.contractMgr = contractMgr;
this.corpStationMgr = corpStationMgr;
this.bookmark = bookmark;
this.LSC = LSC;
this.onlineStatus = onlineStatus;
this.billMgr = billMgr;
this.facWarMgr = facWarMgr;
this.corporationSvc = corporationSvc;
this.clientStatsMgr = clientStatsMgr;
this.voiceMgr = voiceMgr;
this.standing2 = standing2;
this.tutorialSvc = tutorialSvc;
this.agentMgr = agentMgr;
this.corpRegistry = corpRegistry;
this.marketProxy = marketProxy;
this.stationSvc = stationSvc;
this.certificateMgr = certificateMgr;
this.jumpCloneSvc = jumpCloneSvc;
this.LPSvc = LPSvc;
this.lookupSvc = lookupSvc;
this.insuranceSvc = insuranceSvc;
this.slash = slash;
this.ship = ship;
this.corpmgr = corpmgr;
this.repairSvc = repairSvc;
this.reprocessingSvc = reprocessingSvc;
this.ramProxy = ramProxy;
this.factory = factory;
}
public void TestMultipleReferences()
{
var nodeContainer = new NodeContainer();
var commonObj = new SimpleClass();
var instance = new SimpleClass2 {
Member1 = 3, Member2 = new SimpleClass {
Member1 = 4, Member2 = commonObj
}, Member3 = new SimpleClass {
Member1 = 5, Member2 = commonObj
}
};
var rootNode = nodeContainer.GetOrCreateNode(instance);
var visitor = new TestVisitor();
visitor.Visit(rootNode);
var expectedNodes = new IGraphNode[]
{
rootNode,
rootNode[nameof(SimpleClass2.Member1)],
rootNode[nameof(SimpleClass2.Member2)],
rootNode[nameof(SimpleClass2.Member2)].Target,
rootNode[nameof(SimpleClass2.Member2)].Target[nameof(SimpleClass.Member1)],
rootNode[nameof(SimpleClass2.Member2)].Target[nameof(SimpleClass.Member2)],
rootNode[nameof(SimpleClass2.Member2)].Target[nameof(SimpleClass.Member2)].Target,
rootNode[nameof(SimpleClass2.Member2)].Target[nameof(SimpleClass.Member2)].Target[nameof(SimpleClass.Member1)],
rootNode[nameof(SimpleClass2.Member2)].Target[nameof(SimpleClass.Member2)].Target[nameof(SimpleClass.Member2)],
rootNode[nameof(SimpleClass2.Member3)],
rootNode[nameof(SimpleClass2.Member3)].Target,
rootNode[nameof(SimpleClass2.Member3)].Target[nameof(SimpleClass.Member1)],
rootNode[nameof(SimpleClass2.Member3)].Target[nameof(SimpleClass.Member2)],
rootNode[nameof(SimpleClass2.Member3)].Target[nameof(SimpleClass.Member2)].Target,
rootNode[nameof(SimpleClass2.Member3)].Target[nameof(SimpleClass.Member2)].Target[nameof(SimpleClass.Member1)],
rootNode[nameof(SimpleClass2.Member3)].Target[nameof(SimpleClass.Member2)].Target[nameof(SimpleClass.Member2)],
};
var expectedPaths = new GraphNodePath[16];
expectedPaths[0] = new GraphNodePath(rootNode);
expectedPaths[1] = expectedPaths[0].Clone();
expectedPaths[1].PushMember(nameof(SimpleClass2.Member1));
expectedPaths[2] = expectedPaths[0].Clone();
expectedPaths[2].PushMember(nameof(SimpleClass2.Member2));
expectedPaths[3] = expectedPaths[2].Clone();
expectedPaths[3].PushTarget();
expectedPaths[4] = expectedPaths[3].Clone();
expectedPaths[4].PushMember(nameof(SimpleClass.Member1));
expectedPaths[5] = expectedPaths[3].Clone();
expectedPaths[5].PushMember(nameof(SimpleClass.Member2));
expectedPaths[6] = expectedPaths[5].Clone();
expectedPaths[6].PushTarget();
expectedPaths[7] = expectedPaths[6].Clone();
expectedPaths[7].PushMember(nameof(SimpleClass.Member1));
expectedPaths[8] = expectedPaths[6].Clone();
expectedPaths[8].PushMember(nameof(SimpleClass.Member2));
expectedPaths[9] = expectedPaths[0].Clone();
expectedPaths[9].PushMember(nameof(SimpleClass2.Member3));
expectedPaths[10] = expectedPaths[9].Clone();
expectedPaths[10].PushTarget();
expectedPaths[11] = expectedPaths[10].Clone();
expectedPaths[11].PushMember(nameof(SimpleClass.Member1));
expectedPaths[12] = expectedPaths[10].Clone();
expectedPaths[12].PushMember(nameof(SimpleClass.Member2));
expectedPaths[13] = expectedPaths[12].Clone();
expectedPaths[13].PushTarget();
expectedPaths[14] = expectedPaths[13].Clone();
expectedPaths[14].PushMember(nameof(SimpleClass.Member1));
expectedPaths[15] = expectedPaths[13].Clone();
expectedPaths[15].PushMember(nameof(SimpleClass.Member2));
VerifyNodesAndPath(expectedNodes, expectedPaths, visitor);
}
public void Refresh(IGraphNode ownerNode, NodeContainer nodeContainer)
{
var newObjectValue = ownerNode.Retrieve();
if (!(newObjectValue is IEnumerable))
{
throw new ArgumentException(@"The object is not an IEnumerable", nameof(newObjectValue));
}
ObjectValue = newObjectValue;
var newReferences = new HybridDictionary <NodeIndex, ObjectReference>();
if (IsDictionary)
{
foreach (var item in (IEnumerable)ObjectValue)
{
var key = GetKey(item);
var value = (ObjectReference)Reference.CreateReference(GetValue(item), ElementType, key, true);
newReferences.Add(key, value);
}
}
else
{
var i = 0;
foreach (var item in (IEnumerable)ObjectValue)
{
var key = new NodeIndex(i);
var value = (ObjectReference)Reference.CreateReference(item, ElementType, key, true);
newReferences.Add(key, value);
++i;
}
}
// The reference need to be updated if it has never been initialized, if the number of items is different, or if any index or any value is different.
var needUpdate = items == null || newReferences.Count != items.Count || !AreItemsEqual(items, newReferences);
if (needUpdate)
{
// We create a mapping values of the old list of references to their corresponding target node. We use a list because we can have multiple times the same target in items.
var oldReferenceMapping = new List <KeyValuePair <object, ObjectReference> >();
if (items != null)
{
var existingIndices = GraphNodeBase.GetIndices(ownerNode).ToList();
foreach (var item in items)
{
var boxedTarget = item.Value.TargetNode as BoxedNode;
// For collection of struct, we need to update the target nodes first so equity comparer will work. Careful tho, we need to skip removed items!
if (boxedTarget != null && existingIndices.Contains(item.Key))
{
// If we are boxing a struct, we reuse the same nodes if they are type-compatible and just overwrite the struct value.
var value = ownerNode.Retrieve(item.Key);
if (value?.GetType() == item.Value.TargetNode?.Type)
{
boxedTarget.UpdateFromOwner(ownerNode.Retrieve(item.Key));
}
}
if (item.Value.ObjectValue != null)
{
oldReferenceMapping.Add(new KeyValuePair <object, ObjectReference>(item.Value.ObjectValue, item.Value));
}
}
}
foreach (var newReference in newReferences)
{
if (newReference.Value.ObjectValue != null)
{
var found = false;
var i = 0;
foreach (var item in oldReferenceMapping)
{
if (Equals(newReference.Value.ObjectValue, item.Key))
{
// If this value was already present in the old list of reference, just use the same target node in the new list.
newReference.Value.SetTarget(item.Value.TargetNode);
// Remove consumed existing reference so if there is a second entry with the same "key", it will be the other reference that will be used.
oldReferenceMapping.RemoveAt(i);
found = true;
break;
}
++i;
}
if (!found)
{
// Otherwise, do a full update that will properly initialize the new reference.
newReference.Value.Refresh(ownerNode, nodeContainer, newReference.Key);
}
}
}
items = newReferences;
// Remark: this works because both KeyCollection and List implements IReadOnlyCollection. Any internal change to HybridDictionary might break this!
Indices = (IReadOnlyCollection <NodeIndex>)newReferences.Keys;
}
}
public async Task StartNodeBinding(IApiHandler api, IWebSocketHandler socket)
{
apiHandler = api;
socketHandler = socket;
//apiHandler.DataNodeChanged += HandleNodeChange;
try
{
var nodes = await apiHandler.GetNodes();
//nodes.Select(GetNodeInstance);
foreach (var node in nodes.OrderBy(d => d.Name))
{
GetNodeInstance(node);
//Nodes.Add(realNode);
}
var containers = await apiHandler.GetContainers();
foreach (var cnt in containers)
{
var ncnt = new NodeContainer();
ncnt.Parse(cnt);
Containers.Add(ncnt);
}
}
catch (HttpRequestException ex)
{
App.ShowConnectionErrorMessage("Unable to fetch data over http", ex);
//await App.Current.MainPage.DisplayAlert("Connection", "Unable to fetch data over http\n\r"+ex.Message, "Wait...");
ScheduleNewDataLoad();
return;
//return null;
}
try
{
socket.Subscribe("homeninja/conatiners", (JsonMessage message) =>
{
var node = message.Data as JContainer;
if (node != null)
{
var dataCnt = node.ToObject <IEnumerable <DataNodeContainer> >();
foreach (var n in dataCnt)
{
GetNodeContainerInstance(n);
}
}
});
socket.Subscribe("homeninja/nodechange", (JsonMessage message) =>
{
var node = message.Data as JContainer;
if (node != null)
{
var dataNodes = node.ToObject <IEnumerable <DataNode> >();
foreach (var n in dataNodes)
{
GetNodeInstance(n);
}
}
});
await socket.StartListening();
}
catch (WebSocketException ex) {
App.ShowConnectionErrorMessage("Unable to fetch data over websocket", ex);
ScheduleNewDataLoad();
}
}
public NodeContainer(SVGNodeType n, Dictionary <string, string> a, NodeContainer p) : base(n, a, p)
{
Name = n;
Attributes = a;
childs = new List <Node>();
}
public ItemFactory(NodeContainer container, Container dependencyInjection)
{
this.DependencyInjection = dependencyInjection;
this.Container = container;
}
public LSC(ChatDB db, MessagesDB messagesDB, CharacterDB characterDB, ItemManager itemManager, NodeContainer nodeContainer, Logger logger)
{
this.DB = db;
this.MessagesDB = messagesDB;
this.CharacterDB = characterDB;
this.ItemManager = itemManager;
this.NodeContainer = nodeContainer;
this.Log = logger.CreateLogChannel("LSC");
}
public Node(SVGNodeType n, Dictionary <string, string> a, NodeContainer p)
{
Name = n;
Attributes = a;
parent = p;
}
public void Refresh(IGraphNode ownerNode, NodeContainer nodeContainer)
{
Refresh(ownerNode, nodeContainer, NodeIndex.Empty);
}
