/// <summary> /// Adds the value after the last child of parent. /// </summary> public void AddAsChildOf(TKey key, TValue value, TKey parentKey) { NestedSetData <TValue> parentData = _values[parentKey]; NestedSetData <TValue> newData = new NestedSetData <TValue> { Left = parentData.Right, Right = parentData.Right + 1, Value = value }; for (int i = parentData.Right; i < _positionCache.Length; i++) { NestedSetData <TValue> workingData = _values[_positionCache[i]]; if (workingData.Left == i) // Messy but I couldn't think of a better way. { workingData.Left += 2; } else { workingData.Right += 2; } // Replace the value _values.Remove(_positionCache[i]); _values.Add(_positionCache[i], workingData); } _values.Add(key, newData); Rebuild(); }
public IEnumerable <T> GetChildren(T key) { NestedSetData parentData = _values[key]; for (int i = parentData.Left + 1; i < parentData.Right; i++) { yield return(_positionCache[i]); } }
public bool Remove(T item, NestedSetRemoveChildAction childAction) { // Does the item have child items? int correctionRequired = -2; if (_values[item].Left + 1 < _values[item].Right) { // Yes. What do we do? if (childAction == NestedSetRemoveChildAction.ThrowException) { throw new NotSupportedException("Unable to remove item due to child items."); } if (childAction == NestedSetRemoveChildAction.ReturnFalse) { return(false); } if (childAction == NestedSetRemoveChildAction.RecursiveDelete) { correctionRequired = _values[item].Left - _values[item].Right - 1; for (int i = _values[item].Left + 1; i < _values[item].Right; i++) { _values.Remove(_positionCache[i]); } } else if (childAction == NestedSetRemoveChildAction.MoveUpGeneration) { for (int i = _values[item].Left + 1; i < _values[item].Right; i++) { NestedSetData workingData = _values[_positionCache[i]]; workingData.Left -= 1; workingData.Right -= 1; // Replace the value _values.Remove(_positionCache[i]); _values.Add(_positionCache[i], workingData); } } } for (int i = _values[item].Right + 1; i < _positionCache.Length; i++) { NestedSetData workingData = _values[_positionCache[i]]; workingData.Left += correctionRequired; workingData.Right += correctionRequired; // Replace the value _values.Remove(_positionCache[i]); _values.Add(_positionCache[i], workingData); } Rebuild(); return(true); }
public ICollection <TValue> GetChildren(TKey key) { NestedSetData <TValue> parentData = _values[key]; HashSet <TValue> children = new HashSet <TValue>(); for (int i = parentData.Left + 1; i < parentData.Right; i++) { children.Add(_values[_positionCache[i]].Value); } return(children); }
/// <summary> /// Gets or sets the element with the specified key. /// </summary> /// <returns> /// The element with the specified key. /// </returns> /// <param name="key">The key of the element to get or set.</param><exception cref="T:System.ArgumentNullException"><paramref name="key"/> is null.</exception><exception cref="T:System.Collections.Generic.KeyNotFoundException">The property is retrieved and <paramref name="key"/> is not found.</exception><exception cref="T:System.NotSupportedException">The property is set and the <see cref="T:System.Collections.Generic.IDictionary`2"/> is read-only.</exception> public TValue this[TKey key] { get { return(_values[key].Value); } set { if (!_values.ContainsKey(key)) { throw new NotSupportedException("Adding values is not supported using indexers. Use the supplied methods instead. Existing values may be changed with indexers however."); } NestedSetData <TValue> tempValue = _values[key]; tempValue.Value = value; _values[key] = tempValue; } }
public void AddLeftOf(T value, T sibling) { for (int i = _values[sibling].Left; i < _positionCache.Length; i++) { NestedSetData workingData = _values[_positionCache[i]]; workingData.Left += 2; workingData.Right += 2; // Replace the value _values.Remove(_positionCache[i]); _values.Add(_positionCache[i], workingData); } _values.Add(value, new NestedSetData { Left = _values[sibling].Right + 1, Right = _values[sibling].Right + 2 }); Rebuild(); }
/// <summary> /// Adds the value after the last child of parent. /// </summary> public void AddAsChildOf(T value, T parent) { for (int i = _values[parent].Right; i < _positionCache.Length; i++) { NestedSetData workingData = _values[_positionCache[i]]; workingData.Left += 2; workingData.Right += 2; // Replace the value _values.Remove(_positionCache[i]); _values.Add(_positionCache[i], workingData); } _values.Add(value, new NestedSetData { Left = _values[parent].Right - 2, Right = _values[parent].Right - 1 }); Rebuild(); }