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}");
}
}
