/// <summary> /// Appends the passed in bucket after this bucket in the list. /// </summary> /// <param name="toAppend">To append.</param> public void AppendAfter(ListBucket <T> toAppend) { if (toAppend == null) { return; } toAppend.Next = this.Next; toAppend.Previous = this; this.Next = toAppend; if (toAppend.Next != null) { toAppend.Next.Previous = toAppend; } }
/// <summary> /// Inserts the passed in bucket before this bucket in the list /// </summary> /// <param name="toInsert">To insert.</param> public void InsertBefore(ListBucket <T> toInsert) { if (toInsert == null) { return; } toInsert.Previous = this.Previous; toInsert.Next = this; this.Previous = toInsert; if (toInsert.Previous != null) { toInsert.Previous.Next = toInsert; } }
/// <summary> /// Finds the bucket with the specified contents using the comparer func specified. /// </summary> /// <param name="contents">The contents.</param> /// <param name="compareFunc">The compare func.</param> /// <returns> /// the bucket with the contents or null if not found. /// </returns> /// <remarks>Uses a linear search</remarks> public ListBucket <T> Find(T contents, Func <T, T, bool> compareFunc) { ListBucket <T> toReturn = null; ListBucket <T> currentBucket = _head; while (currentBucket != null) { if (compareFunc(contents, currentBucket.Contents)) { toReturn = currentBucket; break; } currentBucket = currentBucket.Next; } return(toReturn); }
/// <summary> /// Concats the specified list after this list in an O(1) operation. /// </summary> /// <param name="toConcat">To concat.</param> /// <remarks>After the concat operation, the buckets in toConcat are referenced by this list. It's not recommended to keep on /// working with toConcat. Instead use this instance, as all data of toConcat is now part of this instance</remarks> public void Concat(LinkedBucketList <T> toConcat) { if (toConcat == null) { return; } if (_head == null) { _head = toConcat.Head; _tail = toConcat.Tail; } else { _tail.AppendAfter(toConcat.Head); } _count += toConcat.Count; }
/// <summary> /// Appends the specified bucket to the list, after the last element as a new tail. /// </summary> /// <param name="toAppend">To append.</param> public void AppendTail(ListBucket <T> toAppend) { if (toAppend == null) { return; } if (_head == null) { _head = toAppend; } else { _tail.AppendAfter(toAppend); } _tail = toAppend; _count++; }
/// <summary> /// Inserts the specified bucket as the new head in the list. /// </summary> /// <param name="toInsert">To insert.</param> public void InsertHead(ListBucket <T> toInsert) { if (toInsert == null) { return; } if (_tail == null) { _tail = toInsert; } else { _head.InsertBefore(toInsert); } _head = toInsert; _count++; }
/// <summary> /// Removes the specified bucket from the list. /// </summary> /// <param name="toRemove">To remove.</param> /// <remarks>Routine assumes the passed in bucket is in the linked bucket list managed by this instance</remarks> /// <returns>true if remove took place, otherwise false</returns> public bool Remove(ListBucket <T> toRemove) { if (toRemove == null) { return(false); } if (_head == toRemove) { _head = toRemove.Next; } if (_tail == toRemove) { _tail = toRemove.Previous; } toRemove.RemoveFromList(); _count--; return(true); }
/// <summary> /// Inserts the specified node toInsert before the node toInsertBefore. /// </summary> /// <param name="toInsert">To insert into the list.</param> /// <param name="toInsertBefore">the node to insert before. Has to be in the list</param> public void InsertBefore(ListBucket <T> toInsert, ListBucket <T> toInsertBefore) { if (toInsert == null) { return; } if (toInsertBefore == null) { if (_count > 0) { throw new ArgumentException("toInsertBefore can't be null when this LinkedBucketList has 1 or more elements"); } InsertHead(toInsert); } else { toInsertBefore.InsertBefore(toInsert); _count++; if (toInsertBefore == _head) { _head = toInsert; } } }
/// <summary> /// Inserts the specified node toInsert after the node toInsertAfter. /// </summary> /// <param name="toInsert">To insert into the list.</param> /// <param name="toInsertAfter">the node to insert after. Has to be in the list</param> public void InsertAfter(ListBucket <T> toInsert, ListBucket <T> toInsertAfter) { if (toInsert == null) { return; } if (toInsertAfter == null) { if (_count > 0) { throw new ArgumentException("toInsertAfter can't be null when this LinkedBucketList has 1 or more elements"); } InsertHead(toInsert); } else { toInsertAfter.AppendAfter(toInsert); _count++; if (toInsertAfter == _tail) { _tail = toInsert; } } }