/// <summary>Try to remove extraneous items from the set of sampled items.</summary>
/// <remarks>
/// Try to remove extraneous items from the set of sampled items. This checks
/// if an item is unnecessary based on the desired error bounds, and merges it
/// with the adjacent item if it is.
/// </remarks>
private void Compress()
{
if (samples.Count < 2)
{
return;
}
ListIterator <SampleQuantiles.SampleItem> it = samples.ListIterator();
SampleQuantiles.SampleItem prev = null;
SampleQuantiles.SampleItem next = it.Next();
while (it.HasNext())
{
prev = next;
next = it.Next();
if (prev.g + next.g + next.delta <= AllowableError(it.PreviousIndex()))
{
next.g += prev.g;
// Remove prev. it.remove() kills the last thing returned.
it.Previous();
it.Previous();
it.Remove();
// it.next() is now equal to next, skip it back forward again
it.Next();
}
}
}
/// <summary>
/// {@inheritDoc}
///
/// <para>This implementation first gets a list iterator that points to the end
/// of the list (with {@code listIterator(size())}). Then, it iterates
/// backwards over the list until the specified element is found, or the
/// beginning of the list is reached.
///
/// </para>
/// </summary>
/// <exception cref="ClassCastException"> {@inheritDoc} </exception>
/// <exception cref="NullPointerException"> {@inheritDoc} </exception>
public virtual int LastIndexOf(Object o)
{
ListIterator <E> it = ListIterator(Size());
if (o == null)
{
while (it.HasPrevious())
{
if (it.Previous() == null)
{
return(it.NextIndex());
}
}
}
else
{
while (it.HasPrevious())
{
if (o.Equals(it.Previous()))
{
return(it.NextIndex());
}
}
}
return(-1);
}
public void ForwardAndBackIteratorTest()
{
ExtendedOneWayLinkedListWithHead <int> lista = new ExtendedOneWayLinkedListWithHead <int>();
lista.Add(1);
lista.Add(2);
lista.Add(3);
List <int> actual = new List <int>();
ListIterator <int> iterator = lista.GetListIterator();
actual.Add(iterator.Next());
actual.Add(iterator.Next());
actual.Add(iterator.Previous());
actual.Add(iterator.Next());
actual.Add(iterator.Next());
while (iterator.HasPrevious())
{
actual.Add(iterator.Previous());
}
Assert.ThrowsException <System.IndexOutOfRangeException>(() => iterator.Previous());
List <int> lista2 = new List <int> {
1, 2, 2, 2, 3, 3, 2, 1
};
Assert.AreEqual(lista2.Count, actual.Count);
IEnumerator <int> iterator1 = actual.GetEnumerator();
IEnumerator <int> iterator2 = lista2.GetEnumerator();
while (iterator1.MoveNext() && iterator2.MoveNext())
{
Assert.AreEqual(iterator1.Current, iterator2.Current);
}
}
public void TestListIterator()
{
Object tempValue;
List <Object> list = new ArrayList <Object>();
list.Add(3);
list.Add(5);
list.Add(5);
list.Add(1);
list.Add(7);
ListIterator <Object> lit = list.ListIterator();
Assert.IsTrue(!lit.HasPrevious, "Should not have previous");
Assert.IsTrue(lit.HasNext, "Should have next");
tempValue = lit.Next();
Assert.IsTrue(tempValue.Equals(3),
"next returned wrong value. Wanted 3, got: " + tempValue);
tempValue = lit.Previous();
SimpleList <Object> list2 = new SimpleList <Object>();
list2.Add(new Object());
ListIterator <Object> lit2 = list2.ListIterator();
lit2.Add(new Object());
lit2.Next();
list = new MockArrayList <Object>();
ListIterator <Object> it = list.ListIterator();
it.Add("one");
it.Add("two");
Assert.AreEqual(2, list.Size());
}
/// <exception cref="NBoilerpipe.BoilerpipeProcessingException"></exception>
public bool Process(TextDocument doc)
{
bool changes = false;
int words = 0;
IList <TextBlock> blocks = doc.GetTextBlocks();
if (!blocks.IsEmpty())
{
ListIterator <TextBlock> it = blocks.ListIterator <TextBlock>(blocks.Count);
TextBlock tb;
while (it.HasPrevious())
{
tb = it.Previous();
if (tb.HasLabel(DefaultLabels.INDICATES_END_OF_TEXT))
{
tb.AddLabel(DefaultLabels.STRICTLY_NOT_CONTENT);
tb.RemoveLabel(DefaultLabels.MIGHT_BE_CONTENT);
tb.SetIsContent(false);
changes = true;
}
else
{
if (tb.IsContent())
{
words += tb.GetNumWords();
if (words > 200)
{
break;
}
}
}
}
}
return(changes);
}
/// <exception cref="NBoilerpipe.BoilerpipeProcessingException"></exception>
public bool Process(TextDocument doc)
{
IList <TextBlock> textBlocks = doc.GetTextBlocks();
if (textBlocks.Count < 2)
{
return(false);
}
bool changes = false;
int remaining = textBlocks.Count;
TextBlock blockBelow = null;
TextBlock block;
for (ListIterator <TextBlock> it = textBlocks.ListIterator <TextBlock>(textBlocks.Count); it.HasPrevious
();)
{
if (--remaining <= 0)
{
break;
}
if (blockBelow == null)
{
blockBelow = it.Previous();
continue;
}
block = it.Previous();
ICollection <string> labels = block.GetLabels();
if (labels != null && !labels.IsEmpty())
{
foreach (string l in labels)
{
blockBelow.AddLabel(labelPrefix + l);
}
changes = true;
}
blockBelow = block;
}
return(changes);
}
/// <summary>Merges items from buffer into the samples array in one pass.</summary>
/// <remarks>
/// Merges items from buffer into the samples array in one pass.
/// This is more efficient than doing an insert on every item.
/// </remarks>
private void InsertBatch()
{
if (bufferCount == 0)
{
return;
}
Arrays.Sort(buffer, 0, bufferCount);
// Base case: no samples
int start = 0;
if (samples.Count == 0)
{
SampleQuantiles.SampleItem newItem = new SampleQuantiles.SampleItem(buffer[0], 1,
0);
samples.AddItem(newItem);
start++;
}
ListIterator <SampleQuantiles.SampleItem> it = samples.ListIterator();
SampleQuantiles.SampleItem item = it.Next();
for (int i = start; i < bufferCount; i++)
{
long v = buffer[i];
while (it.NextIndex() < samples.Count && item.value < v)
{
item = it.Next();
}
// If we found that bigger item, back up so we insert ourselves before it
if (item.value > v)
{
it.Previous();
}
// We use different indexes for the edge comparisons, because of the above
// if statement that adjusts the iterator
int delta;
if (it.PreviousIndex() == 0 || it.NextIndex() == samples.Count)
{
delta = 0;
}
else
{
delta = ((int)Math.Floor(AllowableError(it.NextIndex()))) - 1;
}
SampleQuantiles.SampleItem newItem = new SampleQuantiles.SampleItem(v, 1, delta);
it.Add(newItem);
item = newItem;
}
bufferCount = 0;
}
internal virtual void Normalize()
{
for (ListIterator <ComparableVersion.Item> iterator = ListIterator(Count); iterator
.HasPrevious();)
{
ComparableVersion.Item item = iterator.Previous();
if (item.IsNull())
{
iterator.Remove();
}
else
{
// remove null trailing items: 0, "", empty list
break;
}
}
}
public void AddInIteratorTest()
{
ExtendedOneWayLinkedListWithHead <int> lista = new ExtendedOneWayLinkedListWithHead <int>();
lista.Add(1);
lista.Add(2);
lista.Add(3);
ListIterator <int> iterator = lista.GetListIterator();
List <int> actual = new List <int>();
while (iterator.HasNext())
{
actual.Add(iterator.Next());
iterator.Add(8);
actual.Add(iterator.Previous());
actual.Add(iterator.Next());
}
List <int> lista2 = new List <int> {
1, 8, 8, 2, 8, 8, 3, 8, 8
};
Assert.AreEqual(lista2.Count, actual.Count);
IEnumerator <int> iterator1 = actual.GetEnumerator();
IEnumerator <int> iterator2 = lista2.GetEnumerator();
while (iterator1.MoveNext() && iterator2.MoveNext())
{
Assert.AreEqual(iterator1.Current, iterator2.Current);
}
lista2 = new List <int> {
1, 8, 2, 8, 3, 8
};
Assert.AreEqual(lista2.Count, lista.Count);
iterator1 = lista.GetEnumerator();
iterator2 = lista2.GetEnumerator();
while (iterator1.MoveNext() && iterator2.MoveNext())
{
Assert.AreEqual(iterator1.Current, iterator2.Current);
}
}
private void CompareListIterators(ListIterator it1, ListIterator it2)
{
while (it1.HasPrevious())
{
NUnit.Framework.Assert.AreEqual(it1.Previous(), it2.Previous());
}
NUnit.Framework.Assert.IsFalse(it2.HasPrevious());
CompareIterators(it1, it2);
}
