public CircularLinkedListNode <T> FindPair(T value1, T value2)
        {
            uint startVersion = version;
            CircularLinkedListNode <T> node = this.First;

            if (node != null)
            {
                do
                {
                    if (node.Next != null)
                    {
                        bool firstEqual  = Equals(value1, node.Value);
                        bool secondEqual = Equals(value2, node.Next.Value);
                        if (firstEqual && secondEqual)
                        {
                            return(node);
                        }
                    }
                    if (version != startVersion)
                    {
                        throw new InvalidOperationException("list modified");
                    }
                    node = node.Next;
                }while (node != null && node != this.Last.Next);
            }
            return(null);
        }
        public CircularLinkedListNode <T> FindNodePair(Func <CircularLinkedListNode <T>, CircularLinkedListNode <T>, bool> predicate)
        {
            uint startVersion = version;
            CircularLinkedListNode <T> node = this.First;

            if (node != null)
            {
                do
                {
                    if (node.Next != null)
                    {
                        if (predicate(node, node.Next))
                        {
                            return(node);
                        }
                    }
                    if (version != startVersion)
                    {
                        throw new InvalidOperationException("list modified");
                    }
                    node = node.Next;
                }while (node != null && node != this.Last.Next);
            }
            return(null);
        }
        /// <summary>
        /// Removes nodes from the arguments list and inserts them at the end of the target list.
        /// </summary>
        /// <param name="srcFirst">The first node in the source list.</param>
        /// <param name="srcLast">The last node in the source list.</param>
        public void SpliceLast(CircularLinkedListNode <T> srcFirst, CircularLinkedListNode <T> srcLast)
        {
            if (srcFirst == null)
            {
                throw new ArgumentNullException("srcFirst");
            }
            if (srcLast == null)
            {
                throw new ArgumentNullException("srcLast");
            }
            if (srcFirst.List != srcLast.List)
            {
                throw new InvalidOperationException("source nodes not in same list");
            }
            CircularLinkedList <T>     srcList    = srcFirst.List;
            CircularLinkedListNode <T> terminator = srcLast.Next;
            CircularLinkedListNode <T> node       = srcFirst;

            do
            {
                CircularLinkedListNode <T> nextNode = node.Next;
                srcList.Remove(node);
                this.AddLast(node);
                node = nextNode;
            }while (node != terminator);
        }
        public void CopyTo(T[] array, int index)
        {
            if (array == null)
            {
                throw new ArgumentNullException("array");
            }
            if ((uint)index < (uint)array.GetLowerBound(0))
            {
                throw new ArgumentOutOfRangeException("index");
            }
            if (array.Rank != 1)
            {
                throw new ArgumentException("Array is multidimensional", "array");
            }
            if (array.Length - index + array.GetLowerBound(0) < count)
            {
                throw new ArgumentException("number of items exceeds capacity");
            }

            CircularLinkedListNode <T> node = first;

            if (first == null)
            {
                return;
            }
            do
            {
                array[index] = node.Value;
                index++;
                node = node.forward;
            }while (node != first);
        }
            void IDeserializationCallback.OnDeserialization(object sender)
            {
                if (si == null)
                {
                    return;
                }

                if (list.si != null)
                {
                    ((IDeserializationCallback)list).OnDeserialization(this);
                }

                si = null;

                if (version == list.version && index != -1)
                {
                    CircularLinkedListNode <T> node = list.First;

                    for (int i = 0; i < index; i++)
                    {
                        node = node.forward;
                    }

                    current = node;
                }
            }
            public bool MoveNext()
            {
                if (list == null)
                {
                    throw new ObjectDisposedException(null);
                }
                if (version != list.version)
                {
                    throw new InvalidOperationException("list modified");
                }

                if (current == null)
                {
                    current = list.first;
                }
                else
                {
                    current = current.forward;
                    if (current == list.first)
                    {
                        current = null;
                    }
                }
                if (current == null)
                {
                    index = -1;
                    return(false);
                }
                ++index;
                return(true);
            }
Beispiel #7
0
        public void AddBeforeAndAfterTest()
        {
            CircularLinkedListNode <int> node = threeList.Find(3);

            threeList.AddAfter(node, new CircularLinkedListNode <int>(5));
            CircularLinkedListNode <int> sixNode   = threeList.AddAfter(node, 6);
            CircularLinkedListNode <int> sevenNode = threeList.AddBefore(node, 7);

            threeList.AddBefore(node, new CircularLinkedListNode <int>(8));

            Assert.AreEqual(6, sixNode.Value);
            Assert.AreEqual(7, sevenNode.Value);

            // 2 7 8 3 6 5 4
            int[] values = new int[] { 2, 7, 8, 3, 6, 5, 4 };
            int   i      = 0;

            foreach (int current in threeList)
            {
                Assert.AreEqual(values[i], current);
                i++;
            }

            CircularLinkedListNode <int> node2 = threeList.First;

            do
            {
                Assert.AreSame(threeList, node2.List);
                node2 = node2.Next;
            }while (node2 != threeList.First);
        }
Beispiel #8
0
        public void BecomeCircularTest()
        {
            threeList.IsCircular = true;

            CircularLinkedListNode <int> node = threeList.First;

            Assert.AreEqual(2, node.Value);
            CircularLinkedListNode <int> previous = node.Previous;

            Assert.AreEqual(4, previous.Value);

            node = node.Next;
            Assert.IsNotNull(node);
            Assert.AreEqual(3, node.Value);

            node = node.Next;
            Assert.IsNotNull(node);
            Assert.AreEqual(4, node.Value);
            Assert.AreSame(previous, node);

            node = node.Next;
            Assert.IsNotNull(node);
            Assert.AreEqual(2, node.Value);
            Assert.AreSame(node, threeList.First);
        }
Beispiel #9
0
        public void RemoveTest()
        {
            Assert.IsTrue(threeList.Remove(3));
            Assert.AreEqual(2, threeList.Count);

            int[] values = { 2, 4 };
            int   i      = 0;

            foreach (int current in threeList)
            {
                Assert.AreEqual(values[i], current);
                i++;
            }
            Assert.IsFalse(threeList.Remove(5));

            CircularLinkedListNode <string> node = stringList.Find("baz");

            stringList.Remove(node);

            Assert.IsNull(node.List);
            Assert.IsNull(node.Previous);
            Assert.IsNull(node.Next);

            string[] values2 = { "foo", "bar" };
            i = 0;
            foreach (string current in stringList)
            {
                Assert.AreEqual(values2[i], current);
                i++;
            }
        }
        internal void Detach()
        {
            back.forward = forward;
            forward.back = back;

            forward   = back = null;
            container = null;
        }
Beispiel #11
0
 public void AddAfter(CircularLinkedListNode <T> node, CircularLinkedListNode <T> newNode)
 {
     VerifyReferencedNode(node);
     VerifyBlankNode(newNode);
     newNode.InsertBetween(node, node.forward, this);
     count++;
     version++;
 }
 internal void InsertBetween(CircularLinkedListNode <T> previousNode, CircularLinkedListNode <T> nextNode, CircularLinkedList <T> list)
 {
     previousNode.forward = this;
     nextNode.back        = this;
     this.forward         = nextNode;
     this.back            = previousNode;
     this.container       = list;
 }
Beispiel #13
0
 internal Enumerator(SerializationInfo info, StreamingContext context)
 {
     si      = info;
     list    = (CircularLinkedList <T>)si.GetValue(ListKey, typeof(CircularLinkedList <T>));
     index   = si.GetInt32(IndexKey);
     version = si.GetUInt32(VersionKey);
     current = null;
 }
Beispiel #14
0
        public CircularLinkedListNode <T> AddAfter(CircularLinkedListNode <T> node, T value)
        {
            VerifyReferencedNode(node);
            CircularLinkedListNode <T> newNode = new CircularLinkedListNode <T>(this, value, node, node.forward);

            count++;
            version++;
            return(newNode);
        }
 internal CircularLinkedListNode(CircularLinkedList <T> list, T value, CircularLinkedListNode <T> previousNode, CircularLinkedListNode <T> nextNode)
 {
     container            = list;
     item                 = value;
     this.back            = previousNode;
     this.forward         = nextNode;
     previousNode.forward = this;
     nextNode.back        = this;
 }
Beispiel #16
0
        public void FindPredicateNodePairNegativeTest()
        {
            CircularLinkedListNode <int> pairNode = threeList.FindNodePair(delegate(CircularLinkedListNode <int> a, CircularLinkedListNode <int> b)
            {
                return(a.Value == 3 && b.Value == 2);
            });

            Assert.AreEqual(null, pairNode);
        }
Beispiel #17
0
        public void FindPredicateNegativeTest()
        {
            CircularLinkedListNode <int> found = threeList.Find(delegate(int a)
            {
                return(a == 5);
            });

            Assert.AreEqual(null, found);
        }
Beispiel #18
0
        public void FindPredicatePairNegativeTest()
        {
            CircularLinkedListNode <int> pairNode = threeList.FindPair(delegate(int a, int b)
            {
                return(a == 3 && b == 2);
            });

            Assert.AreEqual(null, pairNode);
        }
Beispiel #19
0
        public void FindPredicatePairPositiveTest()
        {
            CircularLinkedListNode <int> pairNode = threeList.FindPair(delegate(int a, int b)
            {
                return(a == 3 && b == 4);
            });

            Assert.AreEqual(threeList.Last, pairNode.Next);
        }
Beispiel #20
0
        public void FindPredicatePositiveTest()
        {
            CircularLinkedListNode <int> found = threeList.Find(delegate(int a)
            {
                return(a == 4);
            });

            Assert.AreEqual(threeList.Last, found);
        }
Beispiel #21
0
        public void FindPredicateNodePairPositiveTest()
        {
            CircularLinkedListNode <int> pairNode = threeList.FindNodePair(delegate(CircularLinkedListNode <int> a, CircularLinkedListNode <int> b)
            {
                return(a.Value == 3 && b.Value == 4);
            });

            Assert.AreEqual(threeList.Last, pairNode.Next);
        }
Beispiel #22
0
 public void Dispose()
 {
     if (list == null)
     {
         throw new ObjectDisposedException(null);
     }
     current = null;
     list    = null;
 }
Beispiel #23
0
            internal Enumerator(CircularLinkedList <T> parent)
            {
#if !NET_2_1
                si = null;
#endif
                this.list = parent;
                current   = null;
                index     = -1;
                version   = parent.version;
            }
Beispiel #24
0
        public bool Remove(T value)
        {
            CircularLinkedListNode <T> node = Find(value);

            if (node == null)
            {
                return(false);
            }
            Remove(node);
            return(true);
        }
Beispiel #25
0
        static void VerifyBlankNode(CircularLinkedListNode <T> newNode)
        {
            if (newNode == null)
            {
                throw new ArgumentNullException("newNode");
            }

            if (newNode.List != null)
            {
                throw new InvalidOperationException();
            }
        }
Beispiel #26
0
        void VerifyReferencedNode(CircularLinkedListNode <T> node)
        {
            if (node == null)
            {
                throw new ArgumentNullException("node");
            }

            if (node.List != this)
            {
                throw new InvalidOperationException();
            }
        }
Beispiel #27
0
        public void AddBefore(CircularLinkedListNode <T> node, CircularLinkedListNode <T> newNode)
        {
            VerifyReferencedNode(node);
            VerifyBlankNode(newNode);
            newNode.InsertBetween(node.back, node, this);
            count++;
            version++;

            if (node == first)
            {
                first = newNode;
            }
        }
Beispiel #28
0
        public CircularLinkedListNode <T> AddBefore(CircularLinkedListNode <T> node, T value)
        {
            VerifyReferencedNode(node);
            CircularLinkedListNode <T> newNode = new CircularLinkedListNode <T>(this, value, node.back, node);

            count++;
            version++;

            if (node == first)
            {
                first = newNode;
            }
            return(newNode);
        }
Beispiel #29
0
            void IEnumerator.Reset()
            {
                if (list == null)
                {
                    throw new ObjectDisposedException(null);
                }
                if (version != list.version)
                {
                    throw new InvalidOperationException("list modified");
                }

                current = null;
                index   = -1;
            }
Beispiel #30
0
 public void AddLast(CircularLinkedListNode <T> node)
 {
     VerifyBlankNode(node);
     if (first == null)
     {
         node.SelfReference(this);
         first = node;
     }
     else
     {
         node.InsertBetween(first.back, first, this);
     }
     count++;
     version++;
 }