[Test] public void Mismatch_RandomIterator()
{
array1[7]++;
ListIterator <int> cmpIter = IteratorUtil.Begin(array2);
cmpIter.MoveNext();
cmpIter.MoveNext();
RandomAccessIterator <int> beginR = IteratorUtil.Begin(array1);
RandomAccessIterator <int> endR = IteratorUtil.End(array1);
RandomAccessIterator <int> cmpR = cmpIter;
Pair <RandomAccessIterator <int>, RandomAccessIterator <int> > pR = Algorithm.Mismatch(beginR, endR, cmpR);
Assert.AreEqual(7, pR.First.Position);
Assert.AreEqual(array1[7], pR.First.Read());
Assert.IsInstanceOfType(typeof(ListIterator <int>), pR.First);
Assert.AreEqual(9, pR.Second.Position);
Assert.AreEqual(array2[9], pR.Second.Read());
Assert.IsInstanceOfType(typeof(ListIterator <int>), pR.Second);
pR = Algorithm.Mismatch(beginR, endR, cmpR, EqualityComparer <int> .Default);
Assert.AreEqual(7, pR.First.Position);
Assert.AreEqual(array1[7], pR.First.Read());
Assert.IsInstanceOfType(typeof(ListIterator <int>), pR.First);
Assert.AreEqual(9, pR.Second.Position);
Assert.AreEqual(array2[9], pR.Second.Read());
Assert.IsInstanceOfType(typeof(ListIterator <int>), pR.Second);
}
[Test] public void FindIf_IntIterator()
{
int[] array = Constants.TEST_INT_ARRAY;
ListIterator <int> iter = Algorithm.FindIf(IteratorUtil.Begin(array), IteratorUtil.End(array), IsMinus1);
Assert.AreEqual(8, iter.Position);
iter = Algorithm.FindIf(IteratorUtil.Begin(array), IteratorUtil.End(array), Never);
Assert.IsNull(iter);
// Assert.IsTrue(IteratorUtil.End(array).Equals(iter));
RandomAccessIterator <int> beginR = IteratorUtil.Begin(array);
RandomAccessIterator <int> endR = IteratorUtil.End(array);
RandomAccessIterator <int> iterR = Algorithm.FindIf(beginR, endR, IsMinus1);
Assert.AreEqual(8, ((ListIterator <int>)iterR).Position);
ForwardIterator <int> beginF = IteratorUtil.Begin(array);
ForwardIterator <int> endF = IteratorUtil.End(array);
ForwardIterator <int> iterF = Algorithm.FindIf(beginF, endF, IsMinus1);
Assert.AreEqual(8, ((ListIterator <int>)iterF).Position);
InputIterator <int> beginI = IteratorUtil.Begin(array);
InputIterator <int> endI = IteratorUtil.End(array);
InputIterator <int> iterI = Algorithm.FindIf(beginI, endI, IsMinus1);
Assert.AreEqual(8, ((ListIterator <int>)iterI).Position);
}
Mismatch <T>(RandomAccessIterator <T> begin, RandomAccessIterator <T> end, RandomAccessIterator <T> cmpBegin)
where T : IEquatable <T>
{
Pair <InputIterator <T>, InputIterator <T> > result = Mismatch((InputIterator <T>)begin, (InputIterator <T>)end, (InputIterator <T>)cmpBegin);
return(new Pair <RandomAccessIterator <T>, RandomAccessIterator <T> >((RandomAccessIterator <T>)result.First, (RandomAccessIterator <T>)result.Second));
}
public void Insert(ListIterator <T> pos, RandomAccessIterator <T> begin, RandomAccessIterator <T> end)
{
Capacity = Count + IteratorUtil.Distance(begin, end);
int index = pos.Position;
InsertRange(index, IteratorUtil.CreateEnumerator(begin, end));
}
[Test] public void Unique_RandomAccessIterator_Predicate()
{
RandomAccessIterator <int> begin = IteratorUtil.Begin(src);
RandomAccessIterator <int> end = IteratorUtil.End(src);
RandomAccessIterator <int> result = Algorithm.Unique(begin, end, delegate(int lhs, int rhs) { return(lhs == rhs); });
VerifyOutput();
Assert.IsNotNull(result);
Assert.AreEqual(5, IteratorUtil.Distance(begin, result));
}
[Test] public void Unique_RandomAccessIterator_Comparer()
{
RandomAccessIterator <int> begin = IteratorUtil.Begin(src);
RandomAccessIterator <int> end = IteratorUtil.End(src);
RandomAccessIterator <int> result = Algorithm.Unique(begin, end, EqualityComparer <int> .Default);
VerifyOutput();
Assert.IsNotNull(result);
Assert.AreEqual(5, IteratorUtil.Distance(begin, result));
}
public int CompareTo(RandomAccessIterator <T> rhs)
{
ListIterator <T> listIterator = rhs as ListIterator <T>;
if (listIterator == null)
{
throw new ArgumentException("Iterator type mismatch.");
}
return(CompareTo(listIterator));
}
Z80Mode GetValueMode(RandomAccessIterator <Token> tokens, bool doNotAdavance, double minValue, double maxValue, int i)
{
var value = Services.Evaluator.Evaluate(tokens, doNotAdavance, minValue, maxValue);
Evaluations[i] = value;
if (value < sbyte.MinValue || value > byte.MaxValue)
{
return(Z80Mode.Extended);
}
return(Z80Mode.PageZero);
}
[Test] public void Find_IntList()
{
int[] array = Constants.TEST_INT_ARRAY;
RandomAccessIterator <int> iter = Algorithm.Find(array, -1);
Assert.AreEqual(8, iter.Position);
iter = Algorithm.Find(array, -217);
Assert.IsNull(iter);
// Assert.IsTrue(IteratorUtil.End(array).Equals(iter));
}
[Test] public void Remove_Comparer_RandomAccessIterator()
{
RandomAccessIterator <int> begin = IteratorUtil.Begin(src);
RandomAccessIterator <int> end = IteratorUtil.End(src);
RandomAccessIterator <int> result = Algorithm.Remove(begin, end, 29, EqualityComparer <int> .Default);
Assert.IsNotNull(result);
Assert.AreEqual(0, begin.Position);
Assert.AreEqual(src.Length, end.Position);
Assert.AreEqual(src.Length - 4, result.Position);
}
// It would be nice to have this routine, but resolution based on delegate type doesn't work very well in C#
public static void Sort <T>(RandomAccessIterator <T> begin, RandomAccessIterator <T> end, Comparison <T> func)
{
if (begin.Equals(end))
{
return;
}
T[] array = new T[end.Position - begin.Position];
Copy(begin, end, array);
Array.Sort(array, func);
Copy(array, begin);
}
public static void Sort <T>(RandomAccessIterator <T> begin, RandomAccessIterator <T> end, Functional.BinaryPredicate <T> func)
{
if (begin.Equals(end))
{
return;
}
T[] array = new T[end.Position - begin.Position];
Copy(begin, end, array);
Array.Sort(array, new Functional.BinaryPredicateComparison <T>(func).Compare);
Copy(array, begin);
}
[Test] public void UniqueCopy_List_Comparer_RandomAccessIterator()
{
RandomAccessIterator <int> destIter = IteratorUtil.Begin(dest);
destIter.MoveNext();
RandomAccessIterator <int> result = Algorithm.UniqueCopy(src, destIter, EqualityComparer <int> .Default);
VerifyOutput();
Assert.IsNotNull(result);
Assert.AreEqual(6, result.Position);
Assert.AreEqual(Int32.MinValue, (result as ListIterator <int>).Read());
}
[Test] public void UniqueCopy_Comparer_RandomAccessIterator()
{
RandomAccessIterator <string> destIter = IteratorUtil.Begin(dest);
destIter.MoveNext();
RandomAccessIterator <string> result = Algorithm.UniqueCopy(IteratorUtil.Begin(src), IteratorUtil.End(src), destIter, EqualityComparer <string> .Default);
VerifyOutput();
Assert.IsNotNull(result);
Assert.AreEqual(6, result.Position);
Assert.AreEqual(MARKER, result.Read());
}
[Test] public void UniqueCopy_List_RandomAccessIterator()
{
RandomAccessIterator <string> destIter = IteratorUtil.Begin(dest);
destIter.MoveNext();
RandomAccessIterator <string> result = Algorithm.UniqueCopy(src, destIter);
VerifyOutput();
Assert.IsNotNull(result);
Assert.AreEqual(6, result.Position);
Assert.AreEqual(MARKER, result.Read());
}
[Test] public void RemoveCopyIf_List_RandomAccessIterator()
{
RandomAccessIterator <int> destIter = IteratorUtil.Begin(dest);
destIter.MoveNext();
RandomAccessIterator <int> result = Algorithm.RemoveCopyIf(src, destIter, Is29);
VerifyOutput();
Assert.IsNotNull(result);
Assert.AreEqual(src.Length - 3, result.Position);
Assert.AreEqual(Int32.MinValue, result.Read());
}
[Test] public void RemoveCopy_Comparer_RandomAccessIterator()
{
RandomAccessIterator <int> destIter = IteratorUtil.Begin(dest);
destIter.MoveNext();
RandomAccessIterator <int> result = Algorithm.RemoveCopy(IteratorUtil.Begin(src), IteratorUtil.End(src), destIter, 29, EqualityComparer <int> .Default);
VerifyOutput();
Assert.IsNotNull(result);
Assert.AreEqual(src.Length - 3, result.Position);
Assert.AreEqual(Int32.MinValue, result.Read());
}
[Test] public void UniqueCopy_RandomAccessIterator()
{
RandomAccessIterator <int> destIter = IteratorUtil.Begin(dest);
destIter.MoveNext();
RandomAccessIterator <int> result = Algorithm.UniqueCopy(IteratorUtil.Begin(src), IteratorUtil.End(src), destIter);
VerifyOutput();
Assert.IsNotNull(result);
Assert.AreEqual(6, result.Position);
Assert.AreEqual(Int32.MinValue, result.Read());
}
[Test] public void UniqueCopy_List_Predicate_RandomAccessIterator()
{
RandomAccessIterator <string> destIter = IteratorUtil.Begin(dest);
destIter.MoveNext();
RandomAccessIterator <string> result = Algorithm.UniqueCopy(src, destIter, delegate(string lhs, string rhs) { return(lhs == rhs); });
VerifyOutput();
Assert.IsNotNull(result);
Assert.AreEqual(6, result.Position);
Assert.AreEqual(MARKER, (result as ListIterator <string>).Read());
}
static public void RandomShuffle <T>(RandomAccessIterator <T> begin, RandomAccessIterator <T> end, RandomShuffleFunc func)
{
if (begin.Equals(end))
{
return;
}
begin = IteratorUtil.Clone(begin);
for (RandomAccessIterator <T> iter = IteratorUtil.AdvanceCopy(begin, 1); !iter.Equals(end); iter.MoveNext())
{
begin.Position = func(iter.Position + 1);
IteratorUtil.Swap(iter, begin);
}
}
public static void Sort <T>(RandomAccessIterator <T> begin, RandomAccessIterator <T> end, IComparer <T> comparer)
{
if (begin.Equals(end))
{
return;
}
// TODO: This is probably the worst sorting algorithm ever written. I'm lazy, and just want to get the interface
// and tests for this algorithm in place. Implement a real sorting function later.
//
// If we are going to do something this lame, it would probably be better to stuff the items one by one into a
// sorted contain, and then copy objects back into [begin,end).
T[] array = new T[end.Position - begin.Position];
Copy(begin, end, array);
Array.Sort(array, comparer);
Copy(array, begin);
}
[Test] public void AdjacentFind_RandomIterator()
{
int[] array = Constants.TEST_INT_ARRAY;
RandomAccessIterator <int> begin = IteratorUtil.Begin(array);
RandomAccessIterator <int> end = IteratorUtil.End(array);
RandomAccessIterator <int> iter = Algorithm.AdjacentFind(begin, end);
Assert.AreEqual(6, IteratorUtil.Distance(begin, iter));
Assert.AreEqual(array[6], iter.Read());
iter = Algorithm.AdjacentFind(IteratorUtil.Begin(array), IteratorUtil.End(array), EqualityComparer <int> .Default);
Assert.AreEqual(6, IteratorUtil.Distance(begin, iter));
Assert.AreEqual(array[6], iter.Read());
iter = Algorithm.AdjacentFind(IteratorUtil.Begin(array), IteratorUtil.End(array), AreEqual);
Assert.AreEqual(6, IteratorUtil.Distance(begin, iter));
Assert.AreEqual(array[6], iter.Read());
}
public static bool Equal <T>(RandomAccessIterator <T> begin, RandomAccessIterator <T> end, RandomAccessIterator <T> cmpBegin, RandomAccessIterator <T> cmpEnd, IComparer <T> comparer)
{
if (IteratorUtil.Distance(begin, end) != IteratorUtil.Distance(cmpBegin, cmpEnd))
{
return(false);
}
for (; !begin.Equals(end) && !cmpBegin.Equals(cmpEnd); begin.MoveNext(), cmpBegin.MoveNext())
{
T t1 = begin.Read();
T t2 = cmpBegin.Read();
if (comparer.Compare(t1, t2) != 0)
{
return(false);
}
}
return(true);
}
[Test] public void MinElement_IntIteratorPredicate()
{
int[] array = Constants.TEST_INT_ARRAY;
ListIterator <int> iter = Algorithm.MinElement(IteratorUtil.Begin(array), IteratorUtil.End(array), LessThanInt);
Assert.AreEqual(-17, iter.Read());
Assert.AreEqual(4, iter.Position);
RandomAccessIterator <int> beginR = IteratorUtil.Begin(array);
RandomAccessIterator <int> endR = IteratorUtil.End(array);
RandomAccessIterator <int> iterR = Algorithm.MinElement(beginR, endR, LessThanInt);
Assert.AreEqual(4, ((ListIterator <int>)iterR).Position);
ForwardIterator <int> beginF = IteratorUtil.Begin(array);
ForwardIterator <int> endF = IteratorUtil.End(array);
ForwardIterator <int> iterF = Algorithm.MinElement(beginF, endF, LessThanInt);
Assert.AreEqual(4, ((ListIterator <int>)iterF).Position);
}
[Test] public void MaxElement_IntIteratorPredicate()
{
int[] array = Constants.TEST_INT_ARRAY;
ListIterator <int> iter = Algorithm.MaxElement(IteratorUtil.Begin(array), IteratorUtil.End(array), Functional.Compare);
Assert.AreEqual(100, iter.Read());
Assert.AreEqual(10, iter.Position);
RandomAccessIterator <int> beginR = IteratorUtil.Begin(array);
RandomAccessIterator <int> endR = IteratorUtil.End(array);
RandomAccessIterator <int> iterR = Algorithm.MaxElement(beginR, endR, Functional.Compare);
Assert.AreEqual(10, ((ListIterator <int>)iterR).Position);
ForwardIterator <int> beginF = IteratorUtil.Begin(array);
ForwardIterator <int> endF = IteratorUtil.End(array);
ForwardIterator <int> iterF = Algorithm.MaxElement(beginF, endF, Functional.Compare);
Assert.AreEqual(10, ((ListIterator <int>)iterF).Position);
}
public static SourceLine GetLastInstructionLine()
{
var iterator = new RandomAccessIterator <SourceLine>(Assembler.LineIterator);
var index = iterator.Index;
if (index > -1)
{
var line = iterator.Current;
while (line == null || line.Instruction == null)
{
if (--index < 0)
{
break;
}
iterator.Rewind(index);
line = iterator.Current;
}
return(line);
}
return(null);
}
public static RandomAccessIterator <T> Remove <T>(RandomAccessIterator <T> begin, RandomAccessIterator <T> end, T value, IEqualityComparer <T> comparer)
where T : IEquatable <T>
{
return(Remove((ForwardIterator <T>)begin, (ForwardIterator <T>)end, value, comparer) as RandomAccessIterator <T>);
}
protected override string OnAssemble(RandomAccessIterator <SourceLine> lines)
{
var line = lines.Current;
var instruction = line.Instruction.Name.ToLower();
var iterator = line.Operands.GetIterator();
if (!iterator.MoveNext())
{
Services.Log.LogEntry(line.Instruction, "Expected expression.");
}
if (instruction.Equals(".encoding"))
{
if (!iterator.Current.IsDoubleQuote() || !Token.IsEnd(iterator.PeekNext()))
{
Services.Log.LogEntry(iterator.Current, "Expected string expression for encoding definition.");
}
else
{
Services.Encoding.SelectEncoding(iterator.Current.Name);
}
}
else
{
string mapping;
if (!iterator.Current.IsDoubleQuote() || !Token.IsEnd(iterator.PeekNext()))
{
mapping = char.ConvertFromUtf32((int)Services.Evaluator.Evaluate(iterator, false, 0, 0x10ffff));
}
else
{
mapping = StringHelper.GetString(iterator, Services);
}
if (instruction.Equals(".map"))
{
if (!iterator.MoveNext())
{
Services.Log.LogEntry(line.Operands[0],
"Missing one or more arguments for directive \".map\".");
}
else
{
int translation;
if (iterator.Current.IsDoubleQuote() && Token.IsEnd(iterator.PeekNext()))
{
translation = Services.Encoding.GetEncodedValue(StringHelper.GetString(iterator, Services));
}
else
{
translation = (int)Services.Evaluator.Evaluate(iterator, false, 0, 0x10ffff);
}
if (iterator.Current != null)
{
if (!iterator.MoveNext())
{
Services.Log.LogEntry(iterator.Current, "Expected expression.");
}
else
{
mapping += char.ConvertFromUtf32(translation);
if (StringHelper.IsStringLiteral(iterator))
{
translation = Services.Encoding.GetEncodedValue(StringHelper.GetString(iterator, Services));
}
else
{
translation = (int)Services.Evaluator.Evaluate(iterator, false, 0, 0x10ffff);
}
if (iterator.Current != null)
{
Services.Log.LogEntry(iterator.Current,
"Unexpected expression.");
return(string.Empty);
}
}
}
Services.Encoding.Map(mapping, translation);
}
}
else
{
if (iterator.Current != null)
{
Services.Log.LogEntry(iterator.Current,
$"Unexpected argument \"{iterator.Current}\" given for directive \".unmap\".");
}
else
{
Services.Encoding.Unmap(mapping);
}
}
}
return(string.Empty);
}
public static bool Equal <T>(RandomAccessIterator <T> begin, RandomAccessIterator <T> end, RandomAccessIterator <T> cmpBegin, RandomAccessIterator <T> cmpEnd)
where T : IEquatable <T>
{
return(Equal(begin, end, cmpBegin, cmpEnd, new Functional.EqualComparer <T>()));
}
public static RandomAccessIterator <T> RemoveCopy <T>(IList <T> source, RandomAccessIterator <T> dest, T value)
where T : IEquatable <T>
{
return(RemoveCopy(source, (OutputIterator <T>)dest, value) as RandomAccessIterator <T>);
}
