private protected virtual void InsertInStateList(int index, IReadOnlyPlaceholderNodeState nodeState) { Debug.Assert(index >= 0 && index <= _StateList.Count); Debug.Assert(nodeState.ParentIndex is IReadOnlyBrowsingListNodeIndex); _StateList.Insert(index, nodeState); }
private protected virtual void InsertState(int index, IReadOnlyPlaceholderNodeState state) { Debug.Assert(index >= 0 && index <= _StateList.Count); Debug.Assert(state.ParentIndex is IReadOnlyBrowsingExistingBlockNodeIndex); _StateList.Insert(index, state); }
/// <summary> /// Checks if a state is the child of another. This method returns true if <paramref name="parentState"/> and <paramref name="state"/> are the same. /// </summary> /// <param name="parentState">The parent state.</param> /// <param name="state">The state to check.</param> /// <param name="firstIndex">The first index in the chain leading from the parent to the child. Null if they are the same.</param> /// <returns>True if <paramref name="parentState"/> is <paramref name="state"/> or a parent; Otherwise, false.</returns> public virtual bool IsChildState(IReadOnlyNodeState parentState, IReadOnlyNodeState state, out IReadOnlyIndex firstIndex) { firstIndex = null; while (state != null) { if (state == parentState) { return(true); } if (state is IReadOnlyPatternState AsPatternState) { IReadOnlyBlockState BlockState = AsPatternState.ParentBlockState; Debug.Assert(BlockState.StateList.Count > 0); IReadOnlyPlaceholderNodeState FirstState = BlockState.StateList[0]; firstIndex = FirstState.ParentIndex; } else if (state is IReadOnlySourceState AsSourceState) { IReadOnlyBlockState BlockState = AsSourceState.ParentBlockState; Debug.Assert(BlockState.StateList.Count > 0); IReadOnlyPlaceholderNodeState FirstState = BlockState.StateList[0]; firstIndex = FirstState.ParentIndex; } else { firstIndex = state.ParentIndex; } state = state.ParentState; } return(false); }
private protected virtual void MoveState(int index, int direction) { Debug.Assert(index >= 0 && index < _StateList.Count); Debug.Assert(index + direction >= 0 && index + direction < _StateList.Count); IReadOnlyPlaceholderNodeState NodeState = _StateList[index]; _StateList.RemoveAt(index); _StateList.Insert(index + direction, NodeState); }
/// <summary> /// Initializes a newly created state for the node in the inner. /// </summary> /// <param name="nodeIndex">Index of the node.</param> /// <returns>The created node state.</returns> private protected virtual IReadOnlyPlaceholderNodeState InitChildState(IReadOnlyBrowsingPlaceholderNodeIndex nodeIndex) { Debug.Assert(nodeIndex.PropertyName == PropertyName); Debug.Assert(ChildState == null); IReadOnlyPlaceholderNodeState State = CreateNodeState(nodeIndex); SetChildState(State); return(State); }
private protected virtual void CloneChildren(INode parentNode, IBlock parentBlock) { for (int i = 0; i < StateList.Count; i++) { IReadOnlyPlaceholderNodeState ChildState = StateList[i]; INode ChildNodeClone = ChildState.CloneNode(); Debug.Assert(ChildNodeClone != null); NodeTreeHelperBlockList.InsertIntoBlock(parentBlock, i, ChildNodeClone); } }
private protected virtual void SetRoot(IReadOnlyRootNodeIndex rootIndex) { Debug.Assert(!IsInitialized); // Must be called during initialization IReadOnlyPlaceholderNodeState State = CreateRootNodeState(rootIndex); RootIndex = rootIndex; RootState = State; AddState(RootIndex, State); // Recursively build all states, starting from the root. BuildStateTable(null, null, rootIndex, State); }
/// <summary> /// Initializes a newly created state for a node in the inner. /// </summary> /// <param name="nodeIndex">Index of the node.</param> /// <returns>The created node state.</returns> private protected virtual IReadOnlyNodeState InitChildState(IReadOnlyBrowsingListNodeIndex nodeIndex) { Debug.Assert(nodeIndex.PropertyName == PropertyName); int Index = ((TIndex)nodeIndex).Index; Debug.Assert(Index == StateList.Count); IReadOnlyPlaceholderNodeState State = CreateNodeState(nodeIndex); InsertInStateList(Index, State); return(State); }
/// <inheritdoc/> public override void CloneChildren(Node parentNode) { NodeTreeHelperList.ClearChildNodeList(parentNode, PropertyName); for (int i = 0; i < StateList.Count; i++) { IReadOnlyPlaceholderNodeState ChildState = StateList[i]; // Clone all children recursively. Node ChildNodeClone = ChildState.CloneNode(); Debug.Assert(ChildNodeClone != null); NodeTreeHelperList.InsertIntoList(parentNode, PropertyName, i, ChildNodeClone); } }
/// <summary> /// Initializes a newly created state for a node in the inner. /// </summary> /// <param name="existingNodeIndex">Index of the node.</param> /// <returns>The created node state.</returns> private protected virtual IReadOnlyPlaceholderNodeState InitChildState(IReadOnlyBrowsingExistingBlockNodeIndex existingNodeIndex) { Debug.Assert(existingNodeIndex.PropertyName == PropertyName); int BlockIndex = existingNodeIndex.BlockIndex; int Index = existingNodeIndex.Index; Debug.Assert(BlockIndex < BlockStateList.Count); IReadOnlyPlaceholderNodeState State = CreateNodeState(existingNodeIndex); IReadOnlyBlockState CurrentBlock = BlockStateList[BlockIndex]; ((IReadOnlyBlockState <IReadOnlyInner <IReadOnlyBrowsingChildIndex> >)CurrentBlock).InitNodeState(State); return(State); }
public static void ReadOnlyClone() { ControllerTools.ResetExpectedName(); Main RootNode = CreateRoot(ValueGuid0, Imperfections.None); IReadOnlyRootNodeIndex RootIndex = new ReadOnlyRootNodeIndex(RootNode); Assert.That(RootIndex != null); ReadOnlyController Controller = ReadOnlyController.Create(RootIndex); Assert.That(Controller != null); IReadOnlyPlaceholderNodeState RootState = Controller.RootState; Assert.That(RootState != null); BaseNode.Node ClonedNode = RootState.CloneNode(); Assert.That(BaseNodeHelper.NodeTreeDiagnostic.IsValid(ClonedNode)); IReadOnlyRootNodeIndex CloneRootIndex = new ReadOnlyRootNodeIndex(ClonedNode); Assert.That(CloneRootIndex != null); ReadOnlyController CloneController = ReadOnlyController.Create(CloneRootIndex); Assert.That(CloneController != null); IReadOnlyPlaceholderNodeState CloneRootState = Controller.RootState; Assert.That(CloneRootState != null); ReadOnlyNodeStateReadOnlyList AllChildren = RootState.GetAllChildren(); ReadOnlyNodeStateReadOnlyList CloneAllChildren = CloneRootState.GetAllChildren(); Assert.That(AllChildren.Count == CloneAllChildren.Count); }
bool ICollection <IReadOnlyPlaceholderNodeState> .Contains(IReadOnlyPlaceholderNodeState value) { return(Contains((ILayoutPlaceholderNodeState)value)); }
bool ICollection <IReadOnlyPlaceholderNodeState> .Remove(IReadOnlyPlaceholderNodeState item) { return(Remove((ILayoutPlaceholderNodeState)item)); }
void IList <IReadOnlyPlaceholderNodeState> .Insert(int index, IReadOnlyPlaceholderNodeState item) { Insert(index, (ILayoutPlaceholderNodeState)item); }
void ICollection <IReadOnlyPlaceholderNodeState> .Add(IReadOnlyPlaceholderNodeState item) { Add((ILayoutPlaceholderNodeState)item); }
/// <summary> /// Initializes a new instance of the <see cref="ReadOnlyPlaceholderNodeStateView"/> class. /// </summary> /// <param name="controllerView">The controller view to which this object belongs.</param> /// <param name="state">The child node state.</param> public ReadOnlyPlaceholderNodeStateView(IReadOnlyControllerView controllerView, IReadOnlyPlaceholderNodeState state) : base(controllerView, state) { }
int IList <IReadOnlyPlaceholderNodeState> .IndexOf(IReadOnlyPlaceholderNodeState value) { return(IndexOf((ILayoutPlaceholderNodeState)value)); }
int IReadOnlyPlaceholderNodeStateReadOnlyList.IndexOf(IReadOnlyPlaceholderNodeState value) { return(IndexOf((IWriteablePlaceholderNodeState)value)); }
/// <summary> /// Initializes the state for a node of the block. /// </summary> /// <param name="state">The state to initialize.</param> public virtual void InitNodeState(IReadOnlyPlaceholderNodeState state) { Debug.Assert(state != null); InsertState(StateList.Count, state); }
public static void ReadOnlyProperties() { ControllerTools.ResetExpectedName(); Main RootNode; IReadOnlyRootNodeIndex RootIndex0; IReadOnlyRootNodeIndex RootIndex1; RootNode = CreateRoot(ValueGuid0, Imperfections.None); Assert.That(BaseNodeHelper.NodeTreeDiagnostic.IsValid(RootNode)); RootIndex0 = new ReadOnlyRootNodeIndex(RootNode); Assert.That(RootIndex0.Node == RootNode); Assert.That(RootIndex0.IsEqual(CompareEqual.New(), RootIndex0)); RootIndex1 = new ReadOnlyRootNodeIndex(RootNode); Assert.That(RootIndex1.Node == RootNode); Assert.That(CompareEqual.CoverIsEqual(RootIndex0, RootIndex1)); ReadOnlyController Controller0 = ReadOnlyController.Create(RootIndex0); Assert.That(Controller0.RootIndex == RootIndex0); Stats Stats = Controller0.Stats; Assert.That(Stats.NodeCount >= 0); Assert.That(Stats.PlaceholderNodeCount >= 0); Assert.That(Stats.OptionalNodeCount >= 0); Assert.That(Stats.AssignedOptionalNodeCount >= 0); Assert.That(Stats.ListCount >= 0); Assert.That(Stats.BlockListCount >= 0); Assert.That(Stats.BlockCount >= 0); IReadOnlyPlaceholderNodeState RootState = Controller0.RootState; Assert.That(RootState.ParentIndex == RootIndex0); Assert.That(Controller0.Contains(RootIndex0)); Assert.That(Controller0.IndexToState(RootIndex0) == RootState); Assert.That(RootState.InnerTable.Count == 8); Assert.That(RootState.InnerTable.ContainsKey(nameof(Main.PlaceholderTree))); Assert.That(RootState.InnerTable.ContainsKey(nameof(Main.PlaceholderLeaf))); Assert.That(RootState.InnerTable.ContainsKey(nameof(Main.UnassignedOptionalLeaf))); Assert.That(RootState.InnerTable.ContainsKey(nameof(Main.EmptyOptionalLeaf))); Assert.That(RootState.InnerTable.ContainsKey(nameof(Main.AssignedOptionalTree))); Assert.That(RootState.InnerTable.ContainsKey(nameof(Main.AssignedOptionalLeaf))); Assert.That(RootState.InnerTable.ContainsKey(nameof(Main.LeafBlocks))); Assert.That(RootState.InnerTable.ContainsKey(nameof(Main.LeafPath))); IReadOnlyPlaceholderInner MainPlaceholderTreeInner = (IReadOnlyPlaceholderInner)RootState.PropertyToInner(nameof(Main.PlaceholderTree)); Assert.That(MainPlaceholderTreeInner != null); if (MainPlaceholderTreeInner != null) { Assert.That(MainPlaceholderTreeInner.InterfaceType.IsTypeof <Tree>()); Assert.That(MainPlaceholderTreeInner.ChildState != null); Assert.That(MainPlaceholderTreeInner.ChildState?.ParentInner == MainPlaceholderTreeInner); } IReadOnlyPlaceholderInner MainPlaceholderLeafInner = (IReadOnlyPlaceholderInner)RootState.PropertyToInner(nameof(Main.PlaceholderLeaf)); Assert.That(MainPlaceholderLeafInner != null); if (MainPlaceholderLeafInner != null) { Assert.That(MainPlaceholderLeafInner.InterfaceType.IsTypeof <Leaf>()); Assert.That(MainPlaceholderLeafInner.ChildState != null); Assert.That(MainPlaceholderLeafInner.ChildState?.ParentInner == MainPlaceholderLeafInner); } IReadOnlyOptionalInner MainUnassignedOptionalInner = (IReadOnlyOptionalInner)RootState.PropertyToInner(nameof(Main.UnassignedOptionalLeaf)); Assert.That(MainUnassignedOptionalInner != null); if (MainUnassignedOptionalInner != null) { Assert.That(MainUnassignedOptionalInner.InterfaceType.IsTypeof <Leaf>()); Assert.That(!MainUnassignedOptionalInner.IsAssigned); Assert.That(MainUnassignedOptionalInner.ChildState != null); Assert.That(MainUnassignedOptionalInner.ChildState?.ParentInner == MainUnassignedOptionalInner); } IReadOnlyOptionalInner MainAssignedOptionalTreeInner = (IReadOnlyOptionalInner)RootState.PropertyToInner(nameof(Main.AssignedOptionalTree)); Assert.That(MainAssignedOptionalTreeInner != null); if (MainAssignedOptionalTreeInner != null) { Assert.That(MainAssignedOptionalTreeInner.InterfaceType.IsTypeof <Tree>()); Assert.That(MainAssignedOptionalTreeInner.IsAssigned); } IReadOnlyNodeState AssignedOptionalTreeState = MainAssignedOptionalTreeInner.ChildState; Assert.That(AssignedOptionalTreeState != null); if (AssignedOptionalTreeState != null) { Assert.That(AssignedOptionalTreeState.ParentInner == MainAssignedOptionalTreeInner); Assert.That(AssignedOptionalTreeState.ParentState == RootState); } ReadOnlyNodeStateReadOnlyList AssignedOptionalTreeAllChildren = AssignedOptionalTreeState.GetAllChildren(); Assert.That(AssignedOptionalTreeAllChildren.Count == 2, $"New count: {AssignedOptionalTreeAllChildren.Count}"); IReadOnlyOptionalInner MainAssignedOptionalLeafInner = (IReadOnlyOptionalInner)RootState.PropertyToInner(nameof(Main.AssignedOptionalLeaf)); Assert.That(MainAssignedOptionalLeafInner != null); if (MainAssignedOptionalLeafInner != null) { Assert.That(MainAssignedOptionalLeafInner.InterfaceType.IsTypeof <Leaf>()); Assert.That(MainAssignedOptionalLeafInner.IsAssigned); Assert.That(MainAssignedOptionalLeafInner.ChildState != null); Assert.That(MainAssignedOptionalLeafInner.ChildState.ParentInner == MainAssignedOptionalLeafInner); } IReadOnlyBlockListInner MainLeafBlocksInner = (IReadOnlyBlockListInner)RootState.PropertyToInner(nameof(Main.LeafBlocks)); Assert.That(MainLeafBlocksInner != null); if (MainLeafBlocksInner != null) { Assert.That(!MainLeafBlocksInner.IsNeverEmpty); Assert.That(!MainLeafBlocksInner.IsEmpty); Assert.That(!MainLeafBlocksInner.IsSingle); Assert.That(MainLeafBlocksInner.InterfaceType.IsTypeof <Leaf>()); Assert.That(MainLeafBlocksInner.BlockType.IsTypeof <BaseNode.IBlock <Leaf> >()); Assert.That(MainLeafBlocksInner.ItemType.IsTypeof <Leaf>()); Assert.That(MainLeafBlocksInner.Count == 4); Assert.That(MainLeafBlocksInner.BlockStateList != null); Assert.That(MainLeafBlocksInner.BlockStateList.Count == 3); Assert.That(MainLeafBlocksInner.AllIndexes().Count == MainLeafBlocksInner.Count); } IReadOnlyBlockState LeafBlock = MainLeafBlocksInner.BlockStateList[0]; Assert.That(LeafBlock != null); if (LeafBlock != null) { Assert.That(LeafBlock.StateList != null); Assert.That(LeafBlock.StateList.Count == 1); Assert.That(MainLeafBlocksInner.FirstNodeState == LeafBlock.StateList[0]); Assert.That(MainLeafBlocksInner.IndexAt(0, 0) == MainLeafBlocksInner.FirstNodeState.ParentIndex); Assert.That(LeafBlock.Comment == ""); } IReadOnlyPlaceholderInner PatternInner = (IReadOnlyPlaceholderInner)LeafBlock.PropertyToInner(nameof(BaseNode.IBlock.ReplicationPattern)); Assert.That(PatternInner != null); IReadOnlyPlaceholderInner SourceInner = (IReadOnlyPlaceholderInner)LeafBlock.PropertyToInner(nameof(BaseNode.IBlock.SourceIdentifier)); Assert.That(SourceInner != null); IReadOnlyPatternState PatternState = LeafBlock.PatternState; Assert.That(PatternState != null); if (PatternState != null) { Assert.That(PatternState.ParentInner == PatternInner); Assert.That(PatternState.ParentIndex == LeafBlock.PatternIndex); } IReadOnlySourceState SourceState = LeafBlock.SourceState; Assert.That(SourceState != null); if (SourceState != null) { Assert.That(SourceState.ParentInner == SourceInner); Assert.That(SourceState.ParentIndex == LeafBlock.SourceIndex); } Assert.That(MainLeafBlocksInner.FirstNodeState == LeafBlock.StateList[0]); IReadOnlyListInner MainLeafPathInner = (IReadOnlyListInner)RootState.PropertyToInner(nameof(Main.LeafPath)); Assert.That(MainLeafPathInner != null); if (MainLeafPathInner != null) { Assert.That(!MainLeafPathInner.IsNeverEmpty); Assert.That(MainLeafPathInner.InterfaceType.IsTypeof <Leaf>()); Assert.That(MainLeafPathInner.Count == 2); Assert.That(MainLeafPathInner.StateList != null); Assert.That(MainLeafPathInner.StateList?.Count == 2); Assert.That(MainLeafPathInner.FirstNodeState == MainLeafPathInner.StateList[0]); Assert.That(MainLeafPathInner.IndexAt(0) == MainLeafPathInner.FirstNodeState.ParentIndex); Assert.That(MainLeafPathInner.AllIndexes().Count == MainLeafPathInner.Count); } ReadOnlyNodeStateReadOnlyList AllChildren = RootState.GetAllChildren(); Assert.That(AllChildren.Count == 19, $"New count: {AllChildren.Count}"); IReadOnlyPlaceholderInner PlaceholderInner = (IReadOnlyPlaceholderInner)RootState.InnerTable[nameof(Main.PlaceholderLeaf)]; Assert.That(PlaceholderInner != null); IReadOnlyBrowsingPlaceholderNodeIndex PlaceholderNodeIndex = (IReadOnlyBrowsingPlaceholderNodeIndex)PlaceholderInner.ChildState.ParentIndex; Assert.That(PlaceholderNodeIndex != null); Assert.That(Controller0.Contains(PlaceholderNodeIndex)); IReadOnlyOptionalInner UnassignedOptionalInner = (IReadOnlyOptionalInner)RootState.InnerTable[nameof(Main.UnassignedOptionalLeaf)]; Assert.That(UnassignedOptionalInner != null); IReadOnlyBrowsingOptionalNodeIndex UnassignedOptionalNodeIndex = UnassignedOptionalInner.ChildState.ParentIndex; Assert.That(UnassignedOptionalNodeIndex != null); Assert.That(Controller0.Contains(UnassignedOptionalNodeIndex)); Assert.That(Controller0.IsAssigned(UnassignedOptionalNodeIndex) == false); IReadOnlyOptionalInner AssignedOptionalInner = (IReadOnlyOptionalInner)RootState.InnerTable[nameof(Main.AssignedOptionalLeaf)]; Assert.That(AssignedOptionalInner != null); IReadOnlyBrowsingOptionalNodeIndex AssignedOptionalNodeIndex = AssignedOptionalInner.ChildState.ParentIndex; Assert.That(AssignedOptionalNodeIndex != null); Assert.That(Controller0.Contains(AssignedOptionalNodeIndex)); Assert.That(Controller0.IsAssigned(AssignedOptionalNodeIndex) == true); int Min, Max; object ReadValue; RootState.PropertyToValue(nameof(Main.ValueBoolean), out ReadValue, out Min, out Max); bool ReadAsBoolean = ((int)ReadValue) != 0; Assert.That(ReadAsBoolean == true); Assert.That(Controller0.GetDiscreteValue(RootIndex0, nameof(Main.ValueBoolean), out Min, out Max) == (ReadAsBoolean ? 1 : 0)); Assert.That(Min == 0); Assert.That(Max == 1); RootState.PropertyToValue(nameof(Main.ValueEnum), out ReadValue, out Min, out Max); BaseNode.CopySemantic ReadAsEnum = (BaseNode.CopySemantic)(int) ReadValue; Assert.That(ReadAsEnum == BaseNode.CopySemantic.Value); Assert.That(Controller0.GetDiscreteValue(RootIndex0, nameof(Main.ValueEnum), out Min, out Max) == (int)ReadAsEnum); Assert.That(Min == 0); Assert.That(Max == 2); RootState.PropertyToValue(nameof(Main.ValueString), out ReadValue, out Min, out Max); string ReadAsString = ReadValue as string; Assert.That(ReadAsString == "s"); Assert.That(Controller0.GetStringValue(RootIndex0, nameof(Main.ValueString)) == ReadAsString); RootState.PropertyToValue(nameof(Main.ValueGuid), out ReadValue, out Min, out Max); Guid ReadAsGuid = (Guid)ReadValue; Assert.That(ReadAsGuid == ValueGuid0); Assert.That(Controller0.GetGuidValue(RootIndex0, nameof(Main.ValueGuid)) == ReadAsGuid); ReadOnlyController Controller1 = ReadOnlyController.Create(RootIndex0); Assert.That(Controller0.IsEqual(CompareEqual.New(), Controller0)); Assert.That(CompareEqual.CoverIsEqual(Controller0, Controller1)); }
bool IReadOnlyPlaceholderNodeStateReadOnlyList.Contains(IReadOnlyPlaceholderNodeState value) { return(Contains((IWriteablePlaceholderNodeState)value)); }
bool IReadOnlyPlaceholderNodeStateReadOnlyList.Contains(IReadOnlyPlaceholderNodeState value) { return(Contains((ILayoutPlaceholderNodeState)value)); }
private protected virtual void SetChildState(IReadOnlyPlaceholderNodeState childState) { Debug.Assert(childState != null); ChildState = childState; }
int IReadOnlyPlaceholderNodeStateReadOnlyList.IndexOf(IReadOnlyPlaceholderNodeState value) { return(IndexOf((IFocusPlaceholderNodeState)value)); }
/// <summary> /// Creates a IxxxPlaceholderNodeStateView object. /// </summary> private protected override ReadOnlyPlaceholderNodeStateView CreatePlaceholderNodeStateView(IReadOnlyPlaceholderNodeState state) { ControllerTools.AssertNoOverride(this, Type.FromTypeof <WriteableControllerView>()); return(new WriteablePlaceholderNodeStateView(this, (IWriteablePlaceholderNodeState)state)); }
/// <summary> /// Inserts a new node in a block. /// </summary> /// <param name="nodeIndex">Index of the node to insert.</param> /// <param name="index">Position of the inserted node in the block.</param> /// <param name="childState">Node state.</param> public virtual void Insert(IWriteableBrowsingBlockNodeIndex nodeIndex, int index, IReadOnlyPlaceholderNodeState childState) { Debug.Assert(index >= 0 && index <= StateList.Count); InsertState(index, childState); }
private protected virtual void SetChildState(IReadOnlyPlaceholderNodeState childState) { ChildState = childState; }
/// <summary> /// Initializes the state for a node of the block. /// </summary> /// <param name="state">The state to initialize.</param> public virtual void InitNodeState(IReadOnlyPlaceholderNodeState state) { InsertState(StateList.Count, state); }
/// <summary> /// Creates a IxxxPlaceholderNodeStateView object. /// </summary> private protected virtual IReadOnlyPlaceholderNodeStateView CreatePlaceholderNodeStateView(IReadOnlyPlaceholderNodeState state) { ControllerTools.AssertNoOverride(this, typeof(ReadOnlyControllerView)); return(new ReadOnlyPlaceholderNodeStateView(this, state)); }
void ICollection <IReadOnlyPlaceholderNodeState> .Add(IReadOnlyPlaceholderNodeState item) { Add((IWriteablePlaceholderNodeState)item); }