/// <summary> /// Checks if a index collection is contained is a list of index collection. /// . Properties must be different. /// . They must not share an index. /// </summary> /// <param name="collection">The collection to check.</param> /// <param name="collectionList">The list of collections already accumulated.</param> public static bool IsCollectionSeparate(IReadOnlyIndexCollection collection, ReadOnlyIndexCollectionReadOnlyList collectionList) { bool Result = true; foreach (IReadOnlyBrowsingChildIndex Index0 in collection.NodeIndexList) { foreach (IReadOnlyIndexCollection Item in collectionList) { if (Item.PropertyName == collection.PropertyName) { Result = false; } foreach (IReadOnlyBrowsingChildIndex Index1 in Item.NodeIndexList) { if (Index0.Equals(Index1)) { Result = false; } } } } return(Result); }
public virtual void CheckConsistency() { ReadOnlyIndexCollectionList InternalList = InternalIndexCollectionList; ReadOnlyIndexCollectionReadOnlyList PublicList = IndexCollectionList; for (int i = 0; i < InternalList.Count; i++) { IReadOnlyIndexCollection InternalItem = InternalList[i]; Debug.Assert(PublicList.Contains(InternalItem)); Debug.Assert(PublicList.IndexOf(InternalItem) >= 0); IReadOnlyIndexCollection PublicItem = PublicList[i]; Debug.Assert(InternalList.Contains(PublicItem)); Debug.Assert(InternalList.IndexOf(PublicItem) >= 0); if (i == 0) { Debug.Assert(!((ICollection <IReadOnlyIndexCollection>)InternalList).IsReadOnly); InternalList.Remove(InternalItem); InternalList.Insert(0, InternalItem); IEnumerable <IReadOnlyIndexCollection> AsEnumerable = InternalList; foreach (IReadOnlyIndexCollection Item in AsEnumerable) { Debug.Assert(Item == InternalItem); break; } } } }
/// <summary> /// Adds a collection of indexes to <see cref="IndexCollectionList"/>: /// . For placeholder node and optional nodes, the collection is just one index. /// . For list of nodes, the collection contains as many indexes as nodes. /// . For block lists, the collection contains as many indexes as nodes. The first index of each block is a new block index, and others existing block indexes. /// </summary> /// <param name="collection">The collection to add.</param> public virtual void AddIndexCollection(IReadOnlyIndexCollection collection) { Debug.Assert(IsCollectionSeparate(collection, IndexCollectionList)); InternalIndexCollectionList.Add(collection); Debug.Assert(collection.IsEmpty || !IsCollectionSeparate(collection, IndexCollectionList)); }
bool ICollection <IReadOnlyIndexCollection> .Contains(IReadOnlyIndexCollection value) { return(Contains((IFrameIndexCollection)value)); }
void ICollection <IReadOnlyIndexCollection> .Add(IReadOnlyIndexCollection item) { Add((IFrameIndexCollection)item); }
void IList <IReadOnlyIndexCollection> .Insert(int index, IReadOnlyIndexCollection item) { Insert(index, (IFrameIndexCollection)item); }
int IList <IReadOnlyIndexCollection> .IndexOf(IReadOnlyIndexCollection value) { return(IndexOf((IFrameIndexCollection)value)); }
/// <summary> /// Creates a IxxxOptionalInner{IxxxBrowsingOptionalNodeIndex} object. /// </summary> private protected override IReadOnlyOptionalInner <IReadOnlyBrowsingOptionalNodeIndex> CreateOptionalInner(IReadOnlyNodeState owner, IReadOnlyIndexCollection <IReadOnlyBrowsingOptionalNodeIndex> nodeIndexCollection) { ControllerTools.AssertNoOverride(this, Type.FromTypeof <FocusController>()); return(new FocusOptionalInner <IFocusBrowsingOptionalNodeIndex>((IFocusNodeState)owner, nodeIndexCollection.PropertyName)); }
private protected virtual IReadOnlyInner BuildInner(IReadOnlyNodeState parentState, IReadOnlyIndexCollection nodeIndexCollection) { IReadOnlyInner Result = null; switch (nodeIndexCollection) { case IReadOnlyIndexCollection <IReadOnlyBrowsingPlaceholderNodeIndex> AsPlaceholderNodeIndexCollection: Result = (IReadOnlyPlaceholderInner)CreatePlaceholderInner(parentState, AsPlaceholderNodeIndexCollection); break; case IReadOnlyIndexCollection <IReadOnlyBrowsingOptionalNodeIndex> AsOptionalNodeIndexCollection: Result = (IReadOnlyOptionalInner)CreateOptionalInner(parentState, AsOptionalNodeIndexCollection); break; case IReadOnlyIndexCollection <IReadOnlyBrowsingListNodeIndex> AsListNodeIndexCollection: Stats.ListCount++; Result = (IReadOnlyListInner)CreateListInner(parentState, AsListNodeIndexCollection); break; case IReadOnlyIndexCollection <IReadOnlyBrowsingBlockNodeIndex> AsBlockNodeIndexCollection: Stats.BlockListCount++; IReadOnlyBlockListInner Inner = (IReadOnlyBlockListInner)CreateBlockListInner(parentState, AsBlockNodeIndexCollection); NotifyBlockListInnerCreated(Inner as IReadOnlyBlockListInner); Result = Inner; break; } Debug.Assert(Result != null); return(Result); }
/// <summary> /// Creates a IxxxBlockListInner{IxxxBrowsingBlockNodeIndex} object. /// </summary> private protected override IReadOnlyBlockListInner <IReadOnlyBrowsingBlockNodeIndex> CreateBlockListInner(IReadOnlyNodeState owner, IReadOnlyIndexCollection <IReadOnlyBrowsingBlockNodeIndex> nodeIndexCollection) { ControllerTools.AssertNoOverride(this, Type.FromTypeof <LayoutController>()); return(new LayoutBlockListInner <ILayoutBrowsingBlockNodeIndex>((ILayoutNodeState)owner, nodeIndexCollection.PropertyName)); }
/// <summary> /// Creates a IxxxListInner{IxxxBrowsingListNodeIndex} object. /// </summary> private protected override IReadOnlyListInner <IReadOnlyBrowsingListNodeIndex> CreateListInner(IReadOnlyNodeState owner, IReadOnlyIndexCollection <IReadOnlyBrowsingListNodeIndex> nodeIndexCollection) { ControllerTools.AssertNoOverride(this, typeof(LayoutController)); return(new LayoutListInner <ILayoutBrowsingListNodeIndex, LayoutBrowsingListNodeIndex>((ILayoutNodeState)owner, nodeIndexCollection.PropertyName)); }
private protected virtual void BrowseChildrenOfNode(IReadOnlyBrowseContext browseNodeContext, INode node) { IList <string> PropertyNames = NodeTreeHelper.EnumChildNodeProperties(node); foreach (string PropertyName in PropertyNames) { INode ChildNode; Type ChildInterfaceType, ChildNodeType; IReadOnlyList <INode> ChildNodeList; IReadOnlyList <INodeTreeBlock> ChildBlockList; bool IsHandled = false; if (NodeTreeHelperChild.IsChildNodeProperty(node, PropertyName, out ChildNodeType)) { NodeTreeHelperChild.GetChildNode(node, PropertyName, out ChildNode); Debug.Assert(ChildNode != null); IReadOnlyBrowsingPlaceholderNodeIndex ChildNodeIndex = CreateChildNodeIndex(browseNodeContext, node, PropertyName, ChildNode); // Create a collection containing one index for this child node. IReadOnlyIndexCollection IndexCollection = CreatePlaceholderIndexCollection(browseNodeContext, PropertyName, ChildNodeIndex); browseNodeContext.AddIndexCollection(IndexCollection); IsHandled = true; } else if (NodeTreeHelperOptional.IsOptionalChildNodeProperty(node, PropertyName, out ChildNodeType)) { IReadOnlyBrowsingOptionalNodeIndex OptionalNodeIndex = CreateOptionalNodeIndex(browseNodeContext, node, PropertyName); // Create a collection containing one index for this optional node. IReadOnlyIndexCollection IndexCollection = CreateOptionalIndexCollection(browseNodeContext, PropertyName, OptionalNodeIndex); browseNodeContext.AddIndexCollection(IndexCollection); IsHandled = true; } else if (NodeTreeHelperList.IsNodeListProperty(node, PropertyName, out ChildNodeType)) { NodeTreeHelperList.GetChildNodeList(node, PropertyName, out ChildNodeList); Debug.Assert(ChildNodeList != null); // Create a collection containing indexes for each children. IReadOnlyIndexCollection IndexCollection = BrowseNodeList(browseNodeContext, node, PropertyName, ChildNodeList); browseNodeContext.AddIndexCollection(IndexCollection); IsHandled = true; } else if (NodeTreeHelperBlockList.IsBlockListProperty(node, PropertyName, out ChildInterfaceType, out ChildNodeType)) { NodeTreeHelperBlockList.GetChildBlockList(node, PropertyName, out ChildBlockList); Debug.Assert(ChildBlockList != null); // Create a collection containing indexes for each child blocks and their children. IReadOnlyIndexCollection IndexCollection = BrowseNodeBlockList(browseNodeContext, node, PropertyName, ChildBlockList); browseNodeContext.AddIndexCollection(IndexCollection); IsHandled = true; } else if (NodeTreeHelper.IsBooleanProperty(node, PropertyName)) { browseNodeContext.AddValueProperty(PropertyName, ValuePropertyType.Boolean); IsHandled = true; } else if (NodeTreeHelper.IsEnumProperty(node, PropertyName)) { browseNodeContext.AddValueProperty(PropertyName, ValuePropertyType.Enum); IsHandled = true; } else if (NodeTreeHelper.IsStringProperty(node, PropertyName)) { browseNodeContext.AddValueProperty(PropertyName, ValuePropertyType.String); IsHandled = true; } else if (NodeTreeHelper.IsGuidProperty(node, PropertyName)) { browseNodeContext.AddValueProperty(PropertyName, ValuePropertyType.Guid); IsHandled = true; } else if (NodeTreeHelper.IsDocumentProperty(node, PropertyName)) { IsHandled = true; // Ignore the doc node. } Debug.Assert(IsHandled); } }
void ICollection <IReadOnlyIndexCollection> .Add(IReadOnlyIndexCollection item) { Add((IWriteableIndexCollection)item); }
/// <summary> /// Creates a IxxxBlockListInner{IxxxBrowsingBlockNodeIndex} object. /// </summary> private protected override IReadOnlyBlockListInner <IReadOnlyBrowsingBlockNodeIndex> CreateBlockListInner(IReadOnlyNodeState owner, IReadOnlyIndexCollection <IReadOnlyBrowsingBlockNodeIndex> nodeIndexCollection) { ControllerTools.AssertNoOverride(this, typeof(FocusController)); return(new FocusBlockListInner <IFocusBrowsingBlockNodeIndex, FocusBrowsingBlockNodeIndex>((IFocusNodeState)owner, nodeIndexCollection.PropertyName)); }
/// <summary> /// Creates a IxxxOptionalInner{IxxxBrowsingOptionalNodeIndex} object. /// </summary> private protected override IReadOnlyOptionalInner <IReadOnlyBrowsingOptionalNodeIndex> CreateOptionalInner(IReadOnlyNodeState owner, IReadOnlyIndexCollection <IReadOnlyBrowsingOptionalNodeIndex> nodeIndexCollection) { ControllerTools.AssertNoOverride(this, typeof(FrameController)); return(new FrameOptionalInner <IFrameBrowsingOptionalNodeIndex, FrameBrowsingOptionalNodeIndex>((IFrameNodeState)owner, nodeIndexCollection.PropertyName)); }
void ICollection <IReadOnlyIndexCollection> .Add(IReadOnlyIndexCollection item) { Add((ILayoutIndexCollection)item); }
/// <summary> /// Creates a IxxxPlaceholderInner{IxxxBrowsingPlaceholderNodeIndex} object. /// </summary> private protected virtual IReadOnlyPlaceholderInner <IReadOnlyBrowsingPlaceholderNodeIndex> CreatePlaceholderInner(IReadOnlyNodeState owner, IReadOnlyIndexCollection <IReadOnlyBrowsingPlaceholderNodeIndex> nodeIndexCollection) { ControllerTools.AssertNoOverride(this, Type.FromTypeof <ReadOnlyController>()); return(new ReadOnlyPlaceholderInner <IReadOnlyBrowsingPlaceholderNodeIndex>(owner, nodeIndexCollection.PropertyName)); }
bool ICollection <IReadOnlyIndexCollection> .Remove(IReadOnlyIndexCollection item) { return(Remove((IFrameIndexCollection)item)); }
/// <summary> /// Creates a IxxxListInner{IxxxBrowsingListNodeIndex} object. /// </summary> private protected override IReadOnlyListInner <IReadOnlyBrowsingListNodeIndex> CreateListInner(IReadOnlyNodeState owner, IReadOnlyIndexCollection <IReadOnlyBrowsingListNodeIndex> nodeIndexCollection) { ControllerTools.AssertNoOverride(this, Type.FromTypeof <FrameController>()); return(new FrameListInner <IFrameBrowsingListNodeIndex>((IFrameNodeState)owner, nodeIndexCollection.PropertyName)); }
int IReadOnlyIndexCollectionReadOnlyList.IndexOf(IReadOnlyIndexCollection value) { return(IndexOf((IWriteableIndexCollection)value)); }
bool IReadOnlyIndexCollectionReadOnlyList.Contains(IReadOnlyIndexCollection value) { return(Contains((IFocusIndexCollection)value)); }
/// <summary> /// Creates a IxxxPlaceholderInner{IxxxBrowsingPlaceholderNodeIndex} object. /// </summary> private protected override IReadOnlyPlaceholderInner <IReadOnlyBrowsingPlaceholderNodeIndex> CreatePlaceholderInner(IReadOnlyNodeState owner, IReadOnlyIndexCollection <IReadOnlyBrowsingPlaceholderNodeIndex> nodeIndexCollection) { ControllerTools.AssertNoOverride(this, Type.FromTypeof <WriteableController>()); return(new WriteablePlaceholderInner <IWriteableBrowsingPlaceholderNodeIndex>((IWriteableNodeState)owner, nodeIndexCollection.PropertyName)); }
int IReadOnlyIndexCollectionReadOnlyList.IndexOf(IReadOnlyIndexCollection value) { return(IndexOf((IFocusIndexCollection)value)); }
bool IReadOnlyIndexCollectionReadOnlyList.Contains(IReadOnlyIndexCollection value) { return(Contains((IWriteableIndexCollection)value)); }