private IIterator <ObjectId> SwapFetchQueue() { var r = new LinkedListIterator <ObjectId>(_workQueue); _workQueue = new LinkedList <ObjectId>(); return(r); }
public void RemoveAtIndex(int index) { if (index > Length - 1) { throw new IndexOutOfRangeException(); } else if (index == Length - 1) { Pop(); } else if (index == 0) { RemoveFirst(); } else { LinkedListIterator <T> iter = this.Iterator(); while (iter.CurrentIndex < index) { iter.Next(); } iter.Remove(); Length--; } }
public void EmptyList() { var list = new LinkedList <int>(); var iter = new LinkedListIterator <int>(list); AssertEndOfListHasBeenReached(iter); AssertHelper.Throws <IndexOutOfRangeException>(iter.remove); }
public void EmptyList() { var list = new LinkedList<int>(); var iter = new LinkedListIterator<int>(list); AssertEndOfListHasBeenReached(iter); AssertHelper.Throws<IndexOutOfRangeException>(iter.remove); }
public T Get(int index) { LinkedListIterator <T> itr = Iterator(); T item = default(T); while (itr.CurrentIndex < index && itr.HasNext()) { item = itr.Next(); } return(item); }
public void Remove(T item) { LinkedListIterator <T> iter = this.Iterator(); while (iter.HasNext()) { if (iter.Next().Equals(item)) { iter.Remove(); Length--; } } }
// Insert in sorted order. // x is the item to insert. public void Insert(AnyType x) { LinkedListIterator <AnyType> prev = Zeroth( ); LinkedListIterator <AnyType> curr = First( ); while (curr.IsValid( ) && x.CompareTo(curr.Retrieve( )) > 0) { prev.Advance( ); curr.Advance( ); } base.Insert(x, prev); }
public T[] ToArray() { T[] array = new T[Length]; LinkedListIterator <T> iter = this.Iterator(); int index = 0; while (iter.HasNext()) { array[index] = iter.Next(); index++; } return(array); }
private Event PeekEvent() { return(locker.Synchronized(() => { LinkedListIterator <Event> i = iterator++; Event message = i.Value; LinkedListNode <Event> node = i.Node; if (node != null) { events.Remove(node); iterator.Remove(node); } return message; })); }
public bool Contains(T item) { bool contains = false; LinkedListIterator <T> iter = this.Iterator(); while (iter.HasNext()) { if (iter.Next().Equals(item)) { contains = true; break; } } return(contains); }
public override string ToString() { string str = ""; LinkedListIterator <T> iter = this.Iterator(); while (iter.HasNext()) { str += $"{iter.Next()}, "; if (iter.CurrentIndex >= Length) { break; } } return($"[{str}]"); }
// Simple print method public static void PrintList <AnyType>(LinkedList <AnyType> theList) { if (theList.IsEmpty( )) { Console.WriteLine("Empty list"); } else { LinkedListIterator <AnyType> itr = theList.First( ); for ( ; itr.IsValid( ); itr.Advance( )) { Console.Write(itr.Retrieve( ) + " "); } } Console.WriteLine( ); }
// ******************************** // // Private Helper Methods // // ******************************** // /// <summary> /// Gets a node on an index; /// </summary> /// <param name="index">index of node to get.</param> /// <returns></returns> private Node GetNode(int index) { if (index > Length) { throw new IndexOutOfRangeException(); } LinkedListIterator <T> itr = Iterator(); while (index >= itr.CurrentIndex) { if (!itr.HasNext()) { throw new IndexOutOfRangeException(); } else { itr.Next(); } } return(itr.CurrentNode); }
public void FilledList_NavigateForwardAndRemoval() { var list = new LinkedList<int>(); list.AddLast(1); list.AddLast(2); list.AddLast(3); var iter = new LinkedListIterator<int>(list); Assert.AreEqual(3, list.Count); Assert.IsTrue(iter.hasNext()); Assert.AreEqual(1, iter.next()); iter.remove(); Assert.IsTrue(iter.hasNext()); Assert.AreEqual(2, iter.next()); Assert.IsTrue(iter.hasNext()); Assert.AreEqual(3, iter.next()); Assert.AreEqual(2, list.Count); AssertEndOfListHasBeenReached(iter); }
static void Main(string[] args) { Iterator <int> collection1 = new LinkedListIterator <int>(new Node <int>(1, new Node <int>(2, new Node <int>(3, new Empty <int>())))); PrintCollection(collection1); Iterator <int> collection2 = new ArrayIterator <int>(new int[] { 9, 10, 11, -1 }); PrintCollection(collection2); int[][] tmp_collection3 = new int[3][]; tmp_collection3[0] = new int[] { 3, 2, 1 }; tmp_collection3[1] = new int[] { 2, 1, 3 }; tmp_collection3[2] = new int[] { 1, 3, 2 }; Iterator <int> collection3 = new MatrixIterator <int>(tmp_collection3, 3, 3); PrintCollection(collection3); Iterator <int> collection4 = new NaturalNumbers(); PrintCollection(collection4); }
public void Set(int index, T item) { if (index > Length || index < 0) { throw new IndexOutOfRangeException(); } Node newNode = new Node(item); LinkedListIterator <T> iterator = this.Iterator(); if (index == 0) { // empty linked list if (!iterator.HasNext()) { HeaderNode.Next = newNode; TailNode = newNode; } else // Add newNode to first item { newNode.Next = HeaderNode.Next; HeaderNode.Next = newNode; } } else if (index == Length) { Push(item); } // Add item somewhere in the middle. else { while (iterator.HasNext() && iterator.CurrentIndex < index) { iterator.Next(); } iterator.Data = item; } }
public void FilledList_NavigateForwardAndRemoval() { var list = new LinkedList <int>(); list.AddLast(1); list.AddLast(2); list.AddLast(3); var iter = new LinkedListIterator <int>(list); Assert.AreEqual(3, list.Count); Assert.IsTrue(iter.hasNext()); Assert.AreEqual(1, iter.next()); iter.remove(); Assert.IsTrue(iter.hasNext()); Assert.AreEqual(2, iter.next()); Assert.IsTrue(iter.hasNext()); Assert.AreEqual(3, iter.next()); Assert.AreEqual(2, list.Count); AssertEndOfListHasBeenReached(iter); }
private static void AssertEndOfListHasBeenReached(LinkedListIterator<int> iter) { Assert.IsFalse(iter.hasNext()); AssertHelper.Throws<IndexOutOfRangeException>(() => iter.next()); }
private bool DownloadPackedObject(ProgressMonitor monitor, AnyObjectId id) { // Search for the object in a remote pack whose index we have, // but whose pack we do not yet have. // var iter = new LinkedListIterator<RemotePack>(_unfetchedPacks); while (iter.hasNext() && !monitor.IsCancelled) { RemotePack pack = iter.next(); try { pack.OpenIndex(monitor); } catch (IOException err) { // If the index won't open its either not found or // its a format we don't recognize. In either case // we may still be able to obtain the object from // another source, so don't consider it a failure. // RecordError(id, err); iter.remove(); continue; } if (monitor.IsCancelled) { // If we were cancelled while the index was opening // the open may have aborted. We can't search an // unopen index. // return false; } if (!pack.Index.HasObject(id)) { // Not in this pack? Try another. // continue; } // It should be in the associated pack. Download that // and attach it to the local repository so we can use // all of the contained objects. // try { pack.DownloadPack(monitor); } catch (IOException err) { // If the pack failed to download, index correctly, // or open in the local repository we may still be // able to obtain this object from another pack or // an alternate. // RecordError(id, err); continue; } finally { // If the pack was good its in the local repository // and Repository.hasObject(id) will succeed in the // future, so we do not need this data anymore. If // it failed the index and pack are unusable and we // shouldn't consult them again. // pack.TmpIdx.DeleteFile(); iter.remove(); } if (!_local.HasObject(id)) { // What the hell? This pack claimed to have // the object, but after indexing we didn't // actually find it in the pack. // RecordError(id, new FileNotFoundException("Object " + id.Name + " not found in " + pack.PackName + ".")); continue; } // Complete any other objects that we can. // IIterator<ObjectId> pending = SwapFetchQueue(); while (pending.hasNext()) { ObjectId p = pending.next(); if (pack.Index.HasObject(p)) { pending.remove(); Process(p); } else _workQueue.AddLast(p); } return true; } return false; }
private IIterator<ObjectId> SwapFetchQueue() { var r = new LinkedListIterator<ObjectId>(_workQueue); _workQueue = new LinkedList<ObjectId>(); return r; }
public override void Close() { IOException err = null; for (var i = new LinkedListIterator<Stream>(_streams); i.hasNext(); ) { try { i.next().Dispose(); } catch (IOException closeError) { err = closeError; } i.remove(); } if (err != null) throw err; }
private static void AssertEndOfListHasBeenReached(LinkedListIterator <int> iter) { Assert.IsFalse(iter.hasNext()); AssertHelper.Throws <IndexOutOfRangeException>(() => iter.next()); }
private bool DownloadPackedObject(ProgressMonitor monitor, AnyObjectId id) { // Search for the object in a remote pack whose index we have, // but whose pack we do not yet have. // var iter = new LinkedListIterator <RemotePack>(_unfetchedPacks); while (iter.hasNext() && !monitor.IsCancelled) { RemotePack pack = iter.next(); try { pack.OpenIndex(monitor); } catch (IOException err) { // If the index won't open its either not found or // its a format we don't recognize. In either case // we may still be able to obtain the object from // another source, so don't consider it a failure. // RecordError(id, err); iter.remove(); continue; } if (monitor.IsCancelled) { // If we were cancelled while the index was opening // the open may have aborted. We can't search an // unopen index. // return(false); } if (!pack.Index.HasObject(id)) { // Not in this pack? Try another. // continue; } // It should be in the associated pack. Download that // and attach it to the local repository so we can use // all of the contained objects. // try { pack.DownloadPack(monitor); } catch (IOException err) { // If the pack failed to download, index correctly, // or open in the local repository we may still be // able to obtain this object from another pack or // an alternate. // RecordError(id, err); continue; } finally { // If the pack was good its in the local repository // and Repository.hasObject(id) will succeed in the // future, so we do not need this data anymore. If // it failed the index and pack are unusable and we // shouldn't consult them again. // pack.TmpIdx.DeleteFile(); iter.remove(); } if (!_local.HasObject(id)) { // What the hell? This pack claimed to have // the object, but after indexing we didn't // actually find it in the pack. // RecordError(id, new FileNotFoundException("Object " + id.Name + " not found in " + pack.PackName + ".")); continue; } // Complete any other objects that we can. // IIterator <ObjectId> pending = SwapFetchQueue(); while (pending.hasNext()) { ObjectId p = pending.next(); if (pack.Index.HasObject(p)) { pending.remove(); Process(p); } else { _workQueue.AddLast(p); } } return(true); } return(false); }
public TimerScheduler() { _m = new Dictionary <Timer, LinkedListNode <Timer> >(); _s = new LinkedList <Timer>(); _i = new LinkedListIterator <Timer>(this, _s); }
private void handleFileSwap(LinkedListIterator<FileSystemEventArgs> renameIterator, LinkedListIterator<FileSystemEventArgs> deleteIterator) { FileSystemEventArgs delete = deleteIterator.Current; Utils.LinkedListIterator<FileSystemEventArgs> innerIterator = renameIterator.Clone(); while (innerIterator.hasNext()) { FileSystemEventArgs nextChange = innerIterator.Next(); if(nextChange == delete) { return; } RenamedEventArgs erlierRename = renameIterator.Current as RenamedEventArgs; RenamedEventArgs rename = nextChange as RenamedEventArgs; if (rename != null && Object.Equals(erlierRename.OldFullPath, rename.FullPath)) { //this is a file swap! renameIterator.Remove(); innerIterator.Remove(); deleteIterator.Current = new FileSystemEventArgs( WatcherChangeTypes.Changed, Path.GetDirectoryName(erlierRename.OldFullPath), Path.GetFileName(erlierRename.OldFullPath)); //remove any events related to temporary swap file (rename.OldFullPath) string tmpFileFullPath = rename.OldFullPath; Utils.LinkedListIterator<FileSystemEventArgs> tmpIterator = renameIterator.Clone(); while (tmpIterator.HasPrevious()) { FileSystemEventArgs e = tmpIterator.Previous(); if(Object.Equals(e.FullPath, tmpFileFullPath)) { if(e.ChangeType == WatcherChangeTypes.Renamed){ handleRenamed(tmpIterator); if (tmpIterator.Current != null && tmpIterator.Current.ChangeType == WatcherChangeTypes.Renamed) { tmpFileFullPath = ((RenamedEventArgs)tmpIterator.Current).OldFullPath; } } if (tmpIterator.Current != null) { tmpIterator.Remove(); } } } } } }
// Insert after p. // x is the item to insert. // p is this parameter is ignored. public override void Insert(AnyType x, LinkedListIterator <AnyType> p) { Insert(x); }
public EventLooper() { locker = new Locker(); iterator = new LinkedListIterator <Event>(this, events); }
static void Main(string[] args) { ICustomCollection <Hero> zone1List = generateZone1(); ICustomCollection <Hero> zone2List = generateZone2(); ICustomCollection <Hero> zone3List = generateZone3(); Console.WriteLine("\n\n--------- First list---------\n\n"); IEnumerable <Hero> linkedListIterator = new LinkedListIterator(zone1List); foreach (var item in linkedListIterator) { Console.WriteLine($"Name: {item.HeroName}, Class: {item.HeroClass}"); } Console.WriteLine("\n\n--------- Second list---------\n\n"); IEnumerable <Hero> reversedListIterator = new ReversedArrayListIterator(zone2List); foreach (var item in reversedListIterator) { Console.WriteLine($"Name: {item.HeroName}, Class: {item.HeroClass}"); } Console.WriteLine("\n\n--------- Concatenated list: PvP pairs ---------\n\n"); var concatenatedList = linkedListIterator.Concat(reversedListIterator); /* * * foreach (var item in concatenatedList) * { * foreach(var item2 in concatenatedList) * { * Console.Write($"{{{item.HeroName}, {item2.HeroName}}}\t"); * } * * Console.WriteLine(); * Console.WriteLine(); * } * */ Console.WriteLine("\n\n--------- Concrete hero class linked list ---------\n\n"); var heroClassIterator = new HeroClassIterator(linkedListIterator, HeroClass.Mage); foreach (var item in heroClassIterator) { Console.WriteLine($"{item.HeroClass} hero: {item.HeroName}"); } Console.WriteLine("\n\n--------- Concrete hero class array list ---------\n\n"); var heroClassArrayListIterator = new HeroClassIterator(reversedListIterator, HeroClass.Mage); foreach (var item in heroClassArrayListIterator) { Console.WriteLine($"{item.HeroClass} hero: {item.HeroName}"); } }