public void TestPushTarget() { var obj = new Class { ClassMember = new Class() }; var nodeContainer = new NodeContainer(); var rootNode = nodeContainer.GetOrCreateNode(obj); var path = new GraphNodePath(rootNode); path.PushMember(nameof(Class.ClassMember)); path.PushTarget(); var targetNode = nodeContainer.GetNode(obj.ClassMember); var nodes = new IGraphNode[] { rootNode, rootNode[nameof(Class.ClassMember)], targetNode }; Assert.NotNull(targetNode); Assert.False(path.IsEmpty); AssertAreEqual(rootNode, path.RootNode); AssertAreEqual(targetNode, path.GetNode()); var i = 0; foreach (var node in path) { AssertAreEqual(nodes[i++], node); } AssertAreEqual(nodes.Length, i); }
public void TestGetParent() { var obj = new Class { StructMember = { StringMember = "aa" }, ClassMember = new Class(), ListMember = { new Class(), new Class(), new Class() } }; var nodeContainer = new NodeContainer(); var rootNode = nodeContainer.GetOrCreateNode(obj); var path = new GraphNodePath(rootNode).PushMember(nameof(Class.IntMember)); var parentPath = new GraphNodePath(rootNode); AssertAreEqual(parentPath, path.GetParent()); path = new GraphNodePath(rootNode).PushMember(nameof(Class.StructMember)).PushMember(nameof(Struct.StringMember)); parentPath = new GraphNodePath(rootNode).PushMember(nameof(Class.StructMember)); AssertAreEqual(parentPath, path.GetParent()); path = new GraphNodePath(rootNode).PushMember(nameof(Class.ClassMember)).PushTarget(); parentPath = new GraphNodePath(rootNode).PushMember(nameof(Class.ClassMember)); AssertAreEqual(parentPath, path.GetParent()); path = new GraphNodePath(rootNode).PushMember(nameof(Class.ClassMember)).PushTarget().PushMember(nameof(Class.IntMember)); parentPath = new GraphNodePath(rootNode).PushMember(nameof(Class.ClassMember)).PushTarget(); AssertAreEqual(parentPath, path.GetParent()); path = new GraphNodePath(rootNode).PushMember(nameof(Class.ListMember)).PushIndex(new Index(1)); parentPath = new GraphNodePath(rootNode).PushMember(nameof(Class.ListMember)); AssertAreEqual(parentPath, path.GetParent()); path = new GraphNodePath(rootNode).PushMember(nameof(Class.ListMember)).PushIndex(new Index(1)).PushMember(nameof(Class.IntMember)); parentPath = new GraphNodePath(rootNode).PushMember(nameof(Class.ListMember)).PushIndex(new Index(1)); AssertAreEqual(parentPath, path.GetParent()); }
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 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 TestPushIndexAndMember() { var obj = new Class { ListMember = { new Class(), new Class(), new Class() } }; var nodeContainer = new NodeContainer(); var rootNode = nodeContainer.GetOrCreateNode(obj); var path = new GraphNodePath(rootNode); path.PushMember(nameof(Class.ListMember)); path.PushTarget(); path.PushIndex(new NodeIndex(1)); path.PushMember(nameof(Class.IntMember)); var targetNode = nodeContainer.GetNode(obj.ListMember[1]); var intNode = targetNode[nameof(Class.IntMember)]; var nodes = new IGraphNode[] { rootNode, rootNode[nameof(Class.ListMember)], rootNode[nameof(Class.ListMember)].Target, targetNode, intNode }; Assert.NotNull(targetNode); Assert.NotNull(intNode); Assert.False(path.IsEmpty); AssertAreEqual(rootNode, path.RootNode); AssertAreEqual(intNode, path.GetNode()); var i = 0; foreach (var node in path) { AssertAreEqual(nodes[i++], node); } AssertAreEqual(nodes.Length, i); }
public void TestChangeStructListItemMember() { var nodeContainer = new NodeContainer(); var obj = new[] { "aa", "bb", "cc" }; var instance = new ComplexClass { Member7 = new List <Struct> { new Struct(), new Struct { Member1 = obj[0] } } }; var rootNode = nodeContainer.GetOrCreateNode(instance); var listener = new GraphNodeChangeListener(rootNode); var node = rootNode.GetChild(nameof(ComplexClass.Member7)).GetTarget(new Index(1)).GetChild(nameof(SimpleClass.Member1)); var path = new GraphNodePath(rootNode).PushMember(nameof(ComplexClass.Member7)).PushIndex(new Index(1)).PushMember(nameof(SimpleClass.Member1)); Assert.AreEqual(obj[0], node.Content.Retrieve()); TestContentChange(listener, node, ContentChangeType.ValueChange, Index.Empty, obj[0], obj[1], path, () => node.Content.Update(obj[1], Index.Empty)); Assert.AreEqual(obj[1], node.Content.Retrieve()); // TODO: would be nice to be able to keep the same boxed node! //Assert.AreEqual(node, rootNode.GetChild(nameof(ComplexClass.Member7)).GetTarget(new Index(1)).GetChild(nameof(SimpleClass.Member1))); TestContentChange(listener, node, ContentChangeType.ValueChange, Index.Empty, obj[1], obj[2], path, () => node.Content.Update(obj[2], Index.Empty)); Assert.AreEqual(obj[2], node.Content.Retrieve()); //Assert.AreEqual(node, rootNode.GetChild(nameof(ComplexClass.Member7)).GetTarget(new Index(1)).GetChild(nameof(SimpleClass.Member1))); }
public void TestChangePrimitiveList() { var nodeContainer = new NodeContainer(); var obj = new[] { new List <string> { "aa" }, new List <string> { "bb" }, new List <string> { "cc" } }; var instance = new ComplexClass { Member5 = obj[0] }; var rootNode = nodeContainer.GetOrCreateNode(instance); var listener = new GraphNodeChangeListener(rootNode); var node = rootNode.GetChild(nameof(ComplexClass.Member5)); var path = new GraphNodePath(rootNode).PushMember(nameof(ComplexClass.Member5)); Assert.AreEqual("aa", node.Content.Retrieve(new Index(0))); TestContentChange(listener, node, ContentChangeType.ValueChange, Index.Empty, obj[0], obj[1], path, () => node.Content.Update(obj[1])); Assert.AreEqual("bb", node.Content.Retrieve(new Index(0))); TestContentChange(listener, node, ContentChangeType.ValueChange, Index.Empty, obj[1], obj[2], path, () => node.Content.Update(obj[2])); Assert.AreEqual("cc", node.Content.Retrieve(new Index(0))); TestContentChange(listener, node, ContentChangeType.ValueChange, new Index(0), "cc", "dd", path, () => node.Content.Update("dd", new Index(0))); Assert.AreEqual("dd", node.Content.Retrieve(new Index(0))); }
public void TestChangeReferenceList() { var nodeContainer = new NodeContainer(); var obj = new[] { new List <SimpleClass> { new SimpleClass() }, new List <SimpleClass> { new SimpleClass() }, new List <SimpleClass> { new SimpleClass() } }; var instance = new ComplexClass { Member6 = obj[0] }; var rootNode = nodeContainer.GetOrCreateNode(instance); var listener = new GraphNodeChangeListener(rootNode); var node = rootNode.GetChild(nameof(ComplexClass.Member6)); var path = new GraphNodePath(rootNode).PushMember(nameof(ComplexClass.Member6)); Assert.AreEqual(obj[0][0], node.Content.Retrieve(new Index(0))); TestContentChange(listener, node, ContentChangeType.ValueChange, Index.Empty, obj[0], obj[1], path, () => node.Content.Update(obj[1])); Assert.AreEqual(obj[1][0], node.Content.Retrieve(new Index(0))); TestContentChange(listener, node, ContentChangeType.ValueChange, Index.Empty, obj[1], obj[2], path, () => node.Content.Update(obj[2])); Assert.AreEqual(obj[2][0], node.Content.Retrieve(new Index(0))); var newItem = new SimpleClass(); TestContentChange(listener, node, ContentChangeType.ValueChange, new Index(0), obj[2][0], newItem, path, () => node.Content.Update(newItem, new Index(0))); Assert.AreEqual(newItem, node.Content.Retrieve(new Index(0))); }
public void TestObjectWithPrimitiveList() { var nodeContainer = new NodeContainer(); var instance = new PrimitiveListClass { Member1 = 3, Member2 = new List <string> { "aaa", "bbb", "ccc" } }; var rootNode = nodeContainer.GetOrCreateNode(instance); var visitor = new TestVisitor(); visitor.Visit(rootNode); var expectedNodes = new IGraphNode[] { rootNode, rootNode[nameof(PrimitiveListClass.Member1)], rootNode[nameof(PrimitiveListClass.Member2)], rootNode[nameof(PrimitiveListClass.Member2)].Target, }; var expectedPaths = new GraphNodePath[4]; expectedPaths[0] = new GraphNodePath(rootNode); expectedPaths[1] = expectedPaths[0].Clone(); expectedPaths[1].PushMember(nameof(PrimitiveListClass.Member1)); expectedPaths[2] = expectedPaths[0].Clone(); expectedPaths[2].PushMember(nameof(PrimitiveListClass.Member2)); expectedPaths[3] = expectedPaths[2].Clone(); expectedPaths[3].PushTarget(); VerifyNodesAndPath(expectedNodes, expectedPaths, visitor); }
public void TestChangeStruct() { var nodeContainer = new NodeContainer(); var obj = new[] { new Struct { Member1 = "aa" }, new Struct { Member1 = "bb" }, new Struct { Member1 = "cc" } }; var instance = new ComplexClass { Member4 = obj[0] }; var rootNode = nodeContainer.GetOrCreateNode(instance); var listener = new GraphNodeChangeListener(rootNode); var node = rootNode.GetChild(nameof(ComplexClass.Member4)); var path = new GraphNodePath(rootNode).PushMember(nameof(ComplexClass.Member4)); Assert.AreEqual("aa", node.GetChild(nameof(Struct.Member1)).Content.Retrieve()); TestContentChange(listener, node, ContentChangeType.ValueChange, Index.Empty, obj[0], obj[1], path, () => node.Content.Update(obj[1])); Assert.AreEqual("bb", node.GetChild(nameof(Struct.Member1)).Content.Retrieve()); TestContentChange(listener, node, ContentChangeType.ValueChange, Index.Empty, obj[1], obj[2], path, () => node.Content.Update(obj[2])); Assert.AreEqual("cc", node.GetChild(nameof(Struct.Member1)).Content.Retrieve()); TestContentChange(listener, node.GetChild(nameof(Struct.Member1)), ContentChangeType.ValueChange, Index.Empty, "cc", "dd", path.PushMember(nameof(Struct.Member1)), () => node.GetChild(nameof(Struct.Member1)).Content.Update("dd")); Assert.AreEqual("dd", node.GetChild(nameof(Struct.Member1)).Content.Retrieve()); }
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 IGraphNode[] { rootNode, rootNode[nameof(SimpleClass.Member1)], rootNode[nameof(SimpleClass.Member2)], rootNode[nameof(SimpleClass.Member2)].Target, rootNode[nameof(SimpleClass.Member2)].Target[nameof(SimpleClass.Member1)], rootNode[nameof(SimpleClass.Member2)].Target[nameof(SimpleClass.Member2)], }; var expectedPaths = new GraphNodePath[6]; expectedPaths[0] = new GraphNodePath(rootNode); expectedPaths[1] = new GraphNodePath(rootNode); expectedPaths[1].PushMember(nameof(SimpleClass.Member1)); expectedPaths[2] = new GraphNodePath(rootNode); 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); }
/// <summary> /// Initializes a new instance of the <see cref="ObservableModelNode"/> class. /// </summary> /// <param name="ownerViewModel">The <see cref="ObservableViewModel"/> that owns the new <see cref="ObservableModelNode"/>.</param> /// <param name="baseName">The base name of this node. Can be null if <see cref="index"/> is not. If so a name will be automatically generated from the index.</param> /// <param name="isPrimitive">Indicate whether this node should be considered as a primitive node.</param> /// <param name="sourceNode">The model node bound to the new <see cref="ObservableModelNode"/>.</param> /// <param name="graphNodePath">The <see cref="GraphNodePath"/> corresponding to the given <see cref="sourceNode"/>.</param> /// <param name="index">The index of this content in the model node, when this node represent an item of a collection. <see cref="Index.Empty"/> must be passed otherwise</param> protected ObservableModelNode(ObservableViewModel ownerViewModel, string baseName, bool isPrimitive, IGraphNode sourceNode, GraphNodePath graphNodePath, Index index) : base(ownerViewModel, baseName, index) { if (sourceNode == null) { throw new ArgumentNullException(nameof(sourceNode)); } if (baseName == null && index == null) { throw new ArgumentException("baseName and index can't be both null."); } this.isPrimitive = isPrimitive; SourceNode = sourceNode; // By default we will always combine items of list of primitive items. CombineMode = !index.IsEmpty && isPrimitive ? CombineMode.AlwaysCombine : CombineMode.CombineOnlyForAll; SourceNodePath = graphNodePath; // Override display name if available var memberDescriptor = GetMemberDescriptor() as MemberDescriptorBase; if (memberDescriptor != null) { if (index.IsEmpty) { var displayAttribute = TypeDescriptorFactory.Default.AttributeRegistry.GetAttribute <DisplayAttribute>(memberDescriptor.MemberInfo); if (!string.IsNullOrEmpty(displayAttribute?.Name)) { DisplayName = displayAttribute.Name; } IsReadOnly = !memberDescriptor.HasSet; } } }
public void TestPushStructMember() { var obj = new Class { StructMember = { StringMember = "aa" } }; var nodeContainer = new NodeContainer(); var rootNode = nodeContainer.GetOrCreateNode(obj); var path = new GraphNodePath(rootNode); path.PushMember(nameof(Class.StructMember)); path.PushTarget(); path.PushMember(nameof(Struct.StringMember)); var structNode = rootNode[nameof(Class.StructMember)]; var targetNode = rootNode[nameof(Class.StructMember)].Target; var memberNode = rootNode[nameof(Class.StructMember)].Target[nameof(Struct.StringMember)]; var nodes = new IGraphNode[] { rootNode, structNode, targetNode, memberNode }; Assert.NotNull(targetNode); Assert.NotNull(memberNode); Assert.False(path.IsEmpty); AssertAreEqual(rootNode, path.RootNode); AssertAreEqual(memberNode, path.GetNode()); var i = 0; foreach (var node in path) { AssertAreEqual(nodes[i++], node); } AssertAreEqual(nodes.Length, i); }
public void TestChangeStructListItem() { var nodeContainer = new NodeContainer(); var obj = new[] { new Struct { Member1 = "aa" }, new Struct { Member1 = "bb" }, new Struct { Member1 = "cc" } }; var instance = new ComplexClass { Member7 = new List <Struct> { obj[0] } }; var rootNode = nodeContainer.GetOrCreateNode(instance); var listener = new GraphNodeChangeListener(rootNode); var node = rootNode.GetChild(nameof(ComplexClass.Member7)); var path = new GraphNodePath(rootNode).PushMember(nameof(ComplexClass.Member7)); Assert.AreEqual(obj[0], node.Content.Retrieve(new Index(0))); TestContentChange(listener, node, ContentChangeType.ValueChange, new Index(0), obj[0], obj[1], path, () => node.Content.Update(obj[1], new Index(0))); Assert.AreEqual(obj[1], node.Content.Retrieve(new Index(0))); TestContentChange(listener, node, ContentChangeType.ValueChange, new Index(0), obj[1], obj[2], path, () => node.Content.Update(obj[2], new Index(0))); Assert.AreEqual(obj[2], node.Content.Retrieve(new Index(0))); }
public void TestPushTargetAndMember() { var obj = new Class { ClassMember = new Class() }; var nodeContainer = new NodeContainer(); var rootNode = nodeContainer.GetOrCreateNode(obj); var path = new GraphNodePath(rootNode).PushMember(nameof(Class.ClassMember)).PushTarget().PushMember(nameof(Class.IntMember)); var targetNode = nodeContainer.GetNode(obj.ClassMember); var intNode = targetNode.GetChild(nameof(Class.IntMember)); var nodes = new[] { rootNode, rootNode.GetChild(nameof(Class.ClassMember)), targetNode, intNode }; Assert.NotNull(targetNode); Assert.NotNull(intNode); Assert.True(path.IsValid); Assert.False(path.IsEmpty); Assert.AreEqual(rootNode, path.RootNode); Assert.AreEqual(intNode, path.GetNode()); var i = 0; foreach (var node in path) { Assert.AreEqual(nodes[i++], node); } Assert.AreEqual(nodes.Length, i); }
/// <inheritdoc/> public override GraphNodePath GetNodePath() { var path = new GraphNodePath(Editor.NodeContainer.GetNode(Asset.Asset)); path.PushMember(nameof(UIAsset.Hierarchy)); path.PushTarget(); return(path); }
/// <inheritdoc /> protected override GraphNodePath GetNodePath() { var path = new GraphNodePath(Editor.Session.AssetNodeContainer.GetNode(Editor.Asset.Asset)); path.PushMember(nameof(GraphicsCompositorAsset.Cameras)); path.PushTarget(); path.PushIndex(new Index(Editor.Asset.Asset.Cameras.IndexOf(CameraSlot))); return(path); }
GraphNodePath IAssetPropertyProviderViewModel.GetAbsolutePathToRootNode() { var path = new GraphNodePath(Editor.Session.AssetNodeContainer.GetNode(Editor.Asset.Asset)); path.PushMember(nameof(SpriteSheetAsset.Sprites)); path.PushIndex(new NodeIndex(Index)); path.PushTarget(); return(path); }
/// <inheritdoc /> protected override GraphNodePath GetNodePath() { var path = new GraphNodePath(Editor.Session.AssetNodeContainer.GetNode(Editor.Asset.Asset)); path.PushMember(nameof(GraphicsCompositorAsset.SharedRenderers)); path.PushTarget(); path.PushIndex(new NodeIndex(Editor.Asset.Asset.SharedRenderers.IndexOf(sharedRenderer))); return(path); }
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 TestConstructor() { var obj = new Class(); var nodeContainer = new NodeContainer(); var rootNode = nodeContainer.GetOrCreateNode(obj); var path = new GraphNodePath(rootNode); Assert.True(path.IsEmpty); AssertAreEqual(rootNode, path.RootNode); }
public ModelNodeCommandWrapper(IViewModelServiceProvider serviceProvider, INodeCommand nodeCommand, GraphNodePath nodePath) : base(serviceProvider) { if (nodeCommand == null) { throw new ArgumentNullException(nameof(nodeCommand)); } NodePath = nodePath; NodeCommand = nodeCommand; Service = serviceProvider.Get <ObservableViewModelService>(); }
public void TestChangePrimitiveMember() { var nodeContainer = new NodeContainer(); var instance = new ComplexClass { Member1 = 3 }; var rootNode = nodeContainer.GetOrCreateNode(instance); var listener = new GraphNodeChangeListener(rootNode); var node = rootNode.GetChild(nameof(ComplexClass.Member1)); var path = new GraphNodePath(rootNode).PushMember(nameof(ComplexClass.Member1)); TestContentChange(listener, node, ContentChangeType.ValueChange, Index.Empty, 3, 4, path, () => node.Content.Update(4)); TestContentChange(listener, node, ContentChangeType.ValueChange, Index.Empty, 4, 5, path, () => node.Content.Update(5)); }
public ModelNodeCommandWrapper(IViewModelServiceProvider serviceProvider, INodeCommand nodeCommand, GraphNodePath nodePath, Index index) : base(serviceProvider) { if (nodeCommand == null) { throw new ArgumentNullException(nameof(nodeCommand)); } NodePath = nodePath; Index = index; NodeCommand = nodeCommand; }
public void TestChangeReferenceMember() { var nodeContainer = new NodeContainer(); var obj = new[] { new SimpleClass(), new SimpleClass(), new SimpleClass() }; var instance = new ComplexClass { Member2 = obj[0] }; var rootNode = nodeContainer.GetOrCreateNode(instance); var listener = new GraphNodeChangeListener(rootNode); var node = rootNode.GetChild(nameof(ComplexClass.Member2)); var path = new GraphNodePath(rootNode).PushMember(nameof(ComplexClass.Member2)); TestContentChange(listener, node, ContentChangeType.ValueChange, Index.Empty, obj[0], obj[1], path, () => node.Content.Update(obj[1])); TestContentChange(listener, node, ContentChangeType.ValueChange, Index.Empty, obj[1], obj[2], path, () => node.Content.Update(obj[2])); }
public static YamlAssetPath ConvertPath(GraphNodePath path, int inNonIdentifiableType) { var currentNode = (AssetNode)path.RootNode; var result = new YamlAssetPath(); var i = 0; foreach (var item in path.Path) { switch (item.Type) { case GraphNodePath.ElementType.Member: var member = (string)item.Value; result.PushMember(member); currentNode = (AssetNode)((IGraphNode)currentNode).TryGetChild(member); break; case GraphNodePath.ElementType.Target: if (i < path.Path.Count - 1) { currentNode = (AssetNode)((IGraphNode)currentNode).Target; } break; case GraphNodePath.ElementType.Index: var index = (Index)item.Value; if (inNonIdentifiableType > 0 || currentNode.IsNonIdentifiableCollectionContent) { result.PushIndex(index.Value); } else { var id = currentNode.IndexToId(index); // Create a new id if we don't have any so far if (id == ItemId.Empty) { id = ItemId.New(); } result.PushItemId(id); } if (i < path.Path.Count - 1) { currentNode = (AssetNode)((IGraphNode)currentNode).IndexedTarget(index); } break; default: throw new ArgumentOutOfRangeException(); } ++i; } return(result); }
/// <inheritdoc/> public override GraphNodePath GetNodePath() { var path = new GraphNodePath(Editor.NodeContainer.GetNode(Asset.Asset)); path.PushMember(nameof(EntityHierarchy.Hierarchy)); path.PushTarget(); path.PushMember(nameof(EntityHierarchy.Hierarchy.Parts)); path.PushTarget(); path.PushIndex(new NodeIndex(Id.ObjectId)); path.PushMember(nameof(EntityDesign.Entity)); path.PushTarget(); return(path); }
/// <inheritdoc/> GraphNodePath IAssetPropertyProviderViewModel.GetAbsolutePathToRootNode() { var asset = Method.Editor.Asset.Asset; var path = new GraphNodePath(Method.Editor.Session.AssetNodeContainer.GetNode(asset)); path.PushMember(nameof(VisualScriptAsset.Methods)); path.PushTarget(); path.PushIndex(new NodeIndex(asset.Methods.IndexOf(Method.Method.Method))); path.PushMember(nameof(Scripts.Method.Links)); path.PushTarget(); path.PushIndex(new NodeIndex(link.Id)); path.PushTarget(); return(path); }
public void TestObjectWithStructList() { var nodeContainer = new NodeContainer(); // We also test a null item in the list var instance = new StructListClass { Member1 = 3, Member2 = new List <Struct> { new Struct(), new Struct() } }; var rootNode = nodeContainer.GetOrCreateNode(instance); var visitor = new TestVisitor(); visitor.Visit(rootNode); var expectedNodes = new IGraphNode[] { rootNode, rootNode[nameof(StructListClass.Member1)], rootNode[nameof(StructListClass.Member2)], rootNode[nameof(StructListClass.Member2)].Target, rootNode[nameof(StructListClass.Member2)].Target.IndexedTarget(new NodeIndex(0)), rootNode[nameof(StructListClass.Member2)].Target.IndexedTarget(new NodeIndex(0))[nameof(StructListClass.Member1)], rootNode[nameof(StructListClass.Member2)].Target.IndexedTarget(new NodeIndex(0))[nameof(StructListClass.Member2)], rootNode[nameof(StructListClass.Member2)].Target.IndexedTarget(new NodeIndex(1)), rootNode[nameof(StructListClass.Member2)].Target.IndexedTarget(new NodeIndex(1))[nameof(StructListClass.Member1)], rootNode[nameof(StructListClass.Member2)].Target.IndexedTarget(new NodeIndex(1))[nameof(StructListClass.Member2)], }; var expectedPaths = new GraphNodePath[10]; expectedPaths[0] = new GraphNodePath(rootNode); expectedPaths[1] = expectedPaths[0].Clone(); expectedPaths[1].PushMember(nameof(StructListClass.Member1)); expectedPaths[2] = expectedPaths[0].Clone(); expectedPaths[2].PushMember(nameof(StructListClass.Member2)); expectedPaths[3] = expectedPaths[2].Clone(); expectedPaths[3].PushTarget(); expectedPaths[4] = expectedPaths[3].Clone(); expectedPaths[4].PushIndex(new NodeIndex(0)); expectedPaths[5] = expectedPaths[4].Clone(); expectedPaths[5].PushMember(nameof(StructListClass.Member1)); expectedPaths[6] = expectedPaths[4].Clone(); expectedPaths[6].PushMember(nameof(StructListClass.Member2)); expectedPaths[7] = expectedPaths[3].Clone(); expectedPaths[7].PushIndex(new NodeIndex(1)); expectedPaths[8] = expectedPaths[7].Clone(); expectedPaths[8].PushMember(nameof(StructListClass.Member1)); expectedPaths[9] = expectedPaths[7].Clone(); expectedPaths[9].PushMember(nameof(StructListClass.Member2)); VerifyNodesAndPath(expectedNodes, expectedPaths, visitor); }
public INodePresenter CreateNodeHierarchy(IObjectNode rootNode, GraphNodePath rootNodePath, IPropertyProviderViewModel propertyProvider) { if (rootNode == null) { throw new ArgumentNullException(nameof(rootNode)); } buildingNodes.Value = true; var rootPresenter = CreateRootPresenter(propertyProvider, rootNode); GenerateChildren(rootPresenter, rootNode, propertyProvider); RunUpdaters(rootPresenter); buildingNodes.Value = false; FinalizeTree(rootPresenter); return(rootPresenter); }
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.GetChild(nameof(ComplexClass.Member2)); var path = new GraphNodePath(rootNode).PushMember(nameof(ComplexClass.Member2)); TestContentChange(listener, node, ContentChangeType.ValueChange, Index.Empty, obj[0], obj[1], path, () => node.Content.Update(obj[1])); TestContentChange(listener, node, ContentChangeType.ValueChange, Index.Empty, obj[1], obj[2], path, () => node.Content.Update(obj[2])); }
protected override void VisitNode(IContentNode node, GraphNodePath currentPath) { var assetNode = (IAssetNode)node; bool localInNonIdentifiableType = false; if ((node.Descriptor as ObjectDescriptor)?.Attributes.OfType <NonIdentifiableCollectionItemsAttribute>().Any() ?? false) { localInNonIdentifiableType = true; inNonIdentifiableType++; } var path = ConvertPath(currentPath, inNonIdentifiableType); var memberNode = assetNode as AssetMemberNode; if (memberNode != null) { if (memberNode.IsContentOverridden()) { Result.Add(path, memberNode.GetContentOverride()); } foreach (var index in memberNode.GetOverriddenItemIndices()) { var id = memberNode.IndexToId(index); var itemPath = path.Clone(); itemPath.PushItemId(id); Result.Add(itemPath, memberNode.GetItemOverride(index)); } foreach (var index in memberNode.GetOverriddenKeyIndices()) { var id = memberNode.IndexToId(index); var itemPath = path.Clone(); itemPath.PushIndex(id); Result.Add(itemPath, memberNode.GetKeyOverride(index)); } } base.VisitNode(node, currentPath); if (localInNonIdentifiableType) { inNonIdentifiableType--; } }
public void TestEquals() { 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)).PushMember(nameof(Class.IntMember)); var path2 = new GraphNodePath(nodeContainer.GetOrCreateNode(obj)).PushMember(nameof(Class.IntMember)); AssertAreEqual(path1, path2); AssertAreEqual(path1.GetHashCode(), path2.GetHashCode()); path1 = new GraphNodePath(nodeContainer.GetOrCreateNode(obj)).PushMember(nameof(Class.ClassMember)); AssertAreNotEqual(path1, path2); AssertAreNotEqual(path1.GetHashCode(), path2.GetHashCode()); path2 = new GraphNodePath(nodeContainer.GetOrCreateNode(obj)).PushMember(nameof(Class.ClassMember)); AssertAreEqual(path1, path2); AssertAreEqual(path1.GetHashCode(), path2.GetHashCode()); path1 = new GraphNodePath(nodeContainer.GetOrCreateNode(obj)).PushMember(nameof(Class.ClassMember)).PushTarget(); AssertAreNotEqual(path1, path2); AssertAreNotEqual(path1.GetHashCode(), path2.GetHashCode()); path2 = new GraphNodePath(nodeContainer.GetOrCreateNode(obj)).PushMember(nameof(Class.ClassMember)).PushTarget(); AssertAreEqual(path1, path2); AssertAreEqual(path1.GetHashCode(), path2.GetHashCode()); path1 = new GraphNodePath(nodeContainer.GetOrCreateNode(obj)).PushMember(nameof(Class.ClassMember)).PushTarget().PushMember(nameof(Class.IntMember)); AssertAreNotEqual(path1, path2); AssertAreNotEqual(path1.GetHashCode(), path2.GetHashCode()); path2 = new GraphNodePath(nodeContainer.GetOrCreateNode(obj)).PushMember(nameof(Class.ClassMember)).PushTarget().PushMember(nameof(Class.IntMember)); AssertAreEqual(path1, path2); AssertAreEqual(path1.GetHashCode(), path2.GetHashCode()); path1 = new GraphNodePath(nodeContainer.GetOrCreateNode(obj)).PushMember(nameof(Class.ListMember)).PushIndex(new Index(0)); AssertAreNotEqual(path1, path2); AssertAreNotEqual(path1.GetHashCode(), path2.GetHashCode()); path2 = new GraphNodePath(nodeContainer.GetOrCreateNode(obj)).PushMember(nameof(Class.ListMember)).PushIndex(new Index(0)); AssertAreEqual(path1, path2); AssertAreEqual(path1.GetHashCode(), path2.GetHashCode()); path2 = new GraphNodePath(nodeContainer.GetOrCreateNode(obj)).PushMember(nameof(Class.ListMember)).PushIndex(new Index(1)); AssertAreNotEqual(path1, path2); AssertAreNotEqual(path1.GetHashCode(), path2.GetHashCode()); }
public void TestSimpleObjectInitialPath() { var nodeContainer = new NodeContainer(); var instance = new SimpleClass { Member1 = 3, Member2 = new SimpleClass() }; var rootNode = nodeContainer.GetOrCreateNode(instance); var container = new SimpleClass { Member2 = instance }; var containerNode = nodeContainer.GetOrCreateNode(container); var initialPath = new GraphNodePath(containerNode).PushMember(nameof(SimpleClass.Member2)).PushTarget(); var visitor = new TestVisitor(); visitor.Visit(rootNode, initialPath); 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(containerNode).PushMember(nameof(SimpleClass.Member2)).PushTarget(), new GraphNodePath(containerNode).PushMember(nameof(SimpleClass.Member2)).PushTarget().PushMember(nameof(SimpleClass.Member1)), new GraphNodePath(containerNode).PushMember(nameof(SimpleClass.Member2)).PushTarget().PushMember(nameof(SimpleClass.Member2)), new GraphNodePath(containerNode).PushMember(nameof(SimpleClass.Member2)).PushTarget().PushMember(nameof(SimpleClass.Member2)).PushTarget(), new GraphNodePath(containerNode).PushMember(nameof(SimpleClass.Member2)).PushTarget().PushMember(nameof(SimpleClass.Member2)).PushTarget().PushMember(nameof(SimpleClass.Member1)), new GraphNodePath(containerNode).PushMember(nameof(SimpleClass.Member2)).PushTarget().PushMember(nameof(SimpleClass.Member2)).PushTarget().PushMember(nameof(SimpleClass.Member2)), }; VerifyNodesAndPath(expectedNodes, expectedPaths, visitor); }
protected override void VisitNode(IGraphNode node, GraphNodePath currentPath) { Result.Add(Tuple.Create(node, currentPath)); base.VisitNode(node, currentPath); }
public override void Visit(IGraphNode node, GraphNodePath initialPath = null) { Result.Clear(); base.Visit(node, initialPath); }
private static void TestContentChange(GraphNodeChangeListener listener, IGraphNode contentOwner, ContentChangeType type, Index index, object oldValue, object newValue, GraphNodePath path, Action change) { var i = 0; var prepareChange = new EventHandler<GraphContentChangeEventArgs>((sender, e) => { Assert.AreEqual(0, i); VerifyListenerEvent(e, contentOwner, type, index, oldValue, newValue, path, false); ++i; }); var changing = new EventHandler<GraphContentChangeEventArgs>((sender, e) => { Assert.AreEqual(1, i); VerifyListenerEvent(e, contentOwner, type, index, oldValue, newValue, path, false); ++i; }); var changed = new EventHandler<GraphContentChangeEventArgs>((sender, e) => { Assert.AreEqual(2, i); VerifyListenerEvent(e, contentOwner, type, index, oldValue, newValue, path, true); ++i; }); var finalizeChange = new EventHandler<GraphContentChangeEventArgs>((sender, e) => { Assert.AreEqual(3, i); VerifyListenerEvent(e, contentOwner, type, index, oldValue, newValue, path, true); ++i; }); listener.PrepareChange += prepareChange; listener.Changing += changing; listener.Changed += changed; listener.FinalizeChange += finalizeChange; change(); Assert.AreEqual(4, i); listener.PrepareChange -= prepareChange; listener.Changing -= changing; listener.Changed -= changed; listener.FinalizeChange -= finalizeChange; }
public void TestPushMember() { var obj = new Class(); var nodeContainer = new NodeContainer(); var rootNode = nodeContainer.GetOrCreateNode(obj); var path = new GraphNodePath(rootNode).PushMember(nameof(Class.IntMember)); var intNode = rootNode.GetChild(nameof(Class.IntMember)); var nodes = new[] { rootNode, intNode }; Assert.NotNull(intNode); Assert.True(path.IsValid); Assert.False(path.IsEmpty); Assert.AreEqual(rootNode, path.RootNode); Assert.AreEqual(intNode, path.GetNode()); var i = 0; foreach (var node in path) { Assert.AreEqual(nodes[i++], node); } Assert.AreEqual(nodes.Length, i); }
public void TestChangePrimitiveList() { var nodeContainer = new NodeContainer(); var obj = new[] { new List<string> { "aa" }, new List<string> { "bb" }, new List<string> { "cc" } }; var instance = new ComplexClass { Member5 = obj[0] }; var rootNode = nodeContainer.GetOrCreateNode(instance); var listener = new GraphNodeChangeListener(rootNode); var node = rootNode.GetChild(nameof(ComplexClass.Member5)); var path = new GraphNodePath(rootNode).PushMember(nameof(ComplexClass.Member5)); Assert.AreEqual("aa", node.Content.Retrieve(new Index(0))); TestContentChange(listener, node, ContentChangeType.ValueChange, Index.Empty, obj[0], obj[1], path, () => node.Content.Update(obj[1])); Assert.AreEqual("bb", node.Content.Retrieve(new Index(0))); TestContentChange(listener, node, ContentChangeType.ValueChange, Index.Empty, obj[1], obj[2], path, () => node.Content.Update(obj[2])); Assert.AreEqual("cc", node.Content.Retrieve(new Index(0))); TestContentChange(listener, node, ContentChangeType.ValueChange, new Index(0), "cc", "dd", path, () => node.Content.Update("dd", new Index(0))); Assert.AreEqual("dd", node.Content.Retrieve(new Index(0))); }
public void TestChangeStructListItem() { var nodeContainer = new NodeContainer(); var obj = new[] { new Struct { Member1 = "aa" }, new Struct { Member1 = "bb" }, new Struct { Member1 = "cc" } }; var instance = new ComplexClass { Member7 = new List<Struct> { obj[0] } }; var rootNode = nodeContainer.GetOrCreateNode(instance); var listener = new GraphNodeChangeListener(rootNode); var node = rootNode.GetChild(nameof(ComplexClass.Member7)); var path = new GraphNodePath(rootNode).PushMember(nameof(ComplexClass.Member7)); Assert.AreEqual(obj[0], node.Content.Retrieve(new Index(0))); TestContentChange(listener, node, ContentChangeType.ValueChange, new Index(0), obj[0], obj[1], path, () => node.Content.Update(obj[1], new Index(0))); Assert.AreEqual(obj[1], node.Content.Retrieve(new Index(0))); TestContentChange(listener, node, ContentChangeType.ValueChange, new Index(0), obj[1], obj[2], path, () => node.Content.Update(obj[2], new Index(0))); Assert.AreEqual(obj[2], node.Content.Retrieve(new Index(0))); }
public void TestChangeStructMember() { var nodeContainer = new NodeContainer(); var obj = new[] { "aa", "bb", "cc" }; var instance = new ComplexClass { Member4 = new Struct { Member1 = obj[0] } }; var rootNode = nodeContainer.GetOrCreateNode(instance); var listener = new GraphNodeChangeListener(rootNode); var node = rootNode.GetChild(nameof(ComplexClass.Member4)).GetChild(nameof(Struct.Member1)); var path = new GraphNodePath(rootNode).PushMember(nameof(ComplexClass.Member4)).PushMember(nameof(Struct.Member1)); TestContentChange(listener, node, ContentChangeType.ValueChange, Index.Empty, obj[0], obj[1], path, () => node.Content.Update(obj[1], Index.Empty)); Assert.AreEqual(node, rootNode.GetChild(nameof(ComplexClass.Member4)).GetChild(nameof(Struct.Member1))); TestContentChange(listener, node, ContentChangeType.ValueChange, Index.Empty, obj[1], obj[2], path, () => node.Content.Update(obj[2], Index.Empty)); Assert.AreEqual(node, rootNode.GetChild(nameof(ComplexClass.Member4)).GetChild(nameof(Struct.Member1))); }
private static void VerifyListenerEvent(GraphContentChangeEventArgs e, IGraphNode contentOwner, ContentChangeType type, Index index, object oldValue, object newValue, GraphNodePath path, bool changeApplied) { Assert.NotNull(e); Assert.NotNull(contentOwner); Assert.NotNull(path); Assert.AreEqual(type, e.ChangeType); Assert.AreEqual(contentOwner.Content, e.Content); Assert.AreEqual(index, e.Index); Assert.AreEqual(newValue, e.NewValue); Assert.AreEqual(oldValue, e.OldValue); Assert.AreEqual(path, e.Path); if (type == ContentChangeType.ValueChange) { Assert.AreEqual(changeApplied ? newValue : oldValue, contentOwner.Content.Retrieve(index)); } }
public void TestPushIndex() { var obj = new Class { ListMember = { new Class(), new Class(), new Class() } }; var nodeContainer = new NodeContainer(); var rootNode = nodeContainer.GetOrCreateNode(obj); var path = new GraphNodePath(rootNode).PushMember(nameof(Class.ListMember)).PushIndex(new Index(1)); var targetNode = nodeContainer.GetNode(obj.ListMember[1]); var nodes = new[] { rootNode, rootNode.GetChild(nameof(Class.ListMember)), targetNode }; Assert.NotNull(targetNode); Assert.True(path.IsValid); Assert.False(path.IsEmpty); Assert.AreEqual(rootNode, path.RootNode); Assert.AreEqual(targetNode, path.GetNode()); var i = 0; foreach (var node in path) { Assert.AreEqual(nodes[i++], node); } Assert.AreEqual(nodes.Length, i); }
public void TestChangeReferenceListItemMember() { var nodeContainer = new NodeContainer(); var obj = new[] { 3, 4, 5 }; var instance = new ComplexClass { Member6 = new List<SimpleClass> { new SimpleClass(), new SimpleClass { Member1 = obj[0] } } }; var rootNode = nodeContainer.GetOrCreateNode(instance); var listener = new GraphNodeChangeListener(rootNode); var node = rootNode.GetChild(nameof(ComplexClass.Member6)).GetTarget(new Index(1)).GetChild(nameof(SimpleClass.Member1)); var path = new GraphNodePath(rootNode).PushMember(nameof(ComplexClass.Member6)).PushIndex(new Index(1)).PushMember(nameof(SimpleClass.Member1)); Assert.AreEqual(obj[0], node.Content.Retrieve()); TestContentChange(listener, node, ContentChangeType.ValueChange, Index.Empty, obj[0], obj[1], path, () => node.Content.Update(obj[1], Index.Empty)); Assert.AreEqual(obj[1], node.Content.Retrieve()); TestContentChange(listener, node, ContentChangeType.ValueChange, Index.Empty, obj[1], obj[2], path, () => node.Content.Update(obj[2], Index.Empty)); Assert.AreEqual(obj[2], node.Content.Retrieve()); }
/// <summary> /// Initializes a new instance of the <see cref="GraphContentChangeEventArgs"/> class. /// </summary> /// <param name="e">A <see cref="ContentChangeEventArgs"/> instance corresponding to this event.</param> /// <param name="path">The path to the node of content that has been modified.</param> public GraphContentChangeEventArgs(ContentChangeEventArgs e, GraphNodePath path) : this(e.Content, e.Index, e.ChangeType, e.OldValue, e.NewValue, path) { }
/// <summary> /// Initializes a new instance of the <see cref="GraphContentChangeEventArgs"/> class. /// </summary> /// <param name="content">The content that has changed.</param> /// <param name="index">The index in the content where the change occurred.</param> /// <param name="changeType">The type of change that occurred.</param> /// <param name="oldValue">The old value of the content.</param> /// <param name="newValue">The new value of the content.</param> /// <param name="path">The path to the node of content that has been modified.</param> public GraphContentChangeEventArgs(IContent content, Index index, ContentChangeType changeType, object oldValue, object newValue, GraphNodePath path) : base(content, index, changeType, oldValue, newValue) { Path = path; }
public void TestPushStructMember() { var obj = new Class { StructMember = { StringMember = "aa" } }; var nodeContainer = new NodeContainer(); var rootNode = nodeContainer.GetOrCreateNode(obj); var path = new GraphNodePath(rootNode).PushMember(nameof(Class.StructMember)).PushMember(nameof(Struct.StringMember)); var structNode = rootNode.TryGetChild(nameof(Class.StructMember)); var memberNode = rootNode.TryGetChild(nameof(Class.StructMember)).TryGetChild(nameof(Struct.StringMember)); var nodes = new[] { rootNode, structNode, memberNode }; Assert.NotNull(memberNode); Assert.True(path.IsValid); Assert.False(path.IsEmpty); AssertAreEqual(rootNode, path.RootNode); AssertAreEqual(memberNode, path.GetNode()); var i = 0; foreach (var node in path) { AssertAreEqual(nodes[i++], node); } AssertAreEqual(nodes.Length, i); }
public void TestChangeStructListItemMember() { var nodeContainer = new NodeContainer(); var obj = new[] { "aa", "bb", "cc" }; var instance = new ComplexClass { Member7 = new List<Struct> { new Struct(), new Struct { Member1 = obj[0] } } }; var rootNode = nodeContainer.GetOrCreateNode(instance); var listener = new GraphNodeChangeListener(rootNode); var node = rootNode.GetChild(nameof(ComplexClass.Member7)).GetTarget(new Index(1)).GetChild(nameof(SimpleClass.Member1)); var path = new GraphNodePath(rootNode).PushMember(nameof(ComplexClass.Member7)).PushIndex(new Index(1)).PushMember(nameof(SimpleClass.Member1)); Assert.AreEqual(obj[0], node.Content.Retrieve()); TestContentChange(listener, node, ContentChangeType.ValueChange, Index.Empty, obj[0], obj[1], path, () => node.Content.Update(obj[1], Index.Empty)); Assert.AreEqual(obj[1], node.Content.Retrieve()); // TODO: would be nice to be able to keep the same boxed node! //Assert.AreEqual(node, rootNode.GetChild(nameof(ComplexClass.Member7)).GetTarget(new Index(1)).GetChild(nameof(SimpleClass.Member1))); TestContentChange(listener, node, ContentChangeType.ValueChange, Index.Empty, obj[1], obj[2], path, () => node.Content.Update(obj[2], Index.Empty)); Assert.AreEqual(obj[2], node.Content.Retrieve()); //Assert.AreEqual(node, rootNode.GetChild(nameof(ComplexClass.Member7)).GetTarget(new Index(1)).GetChild(nameof(SimpleClass.Member1))); }