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