public void Remove()
{
lock (list.SyncRoot)
{
iterator.Remove();
}
}
internal static bool ReorderIncorrectBinaryTransition(IList <ITransition> transitions)
{
int shiftCount = 0;
IListIterator <ITransition> cursor = transitions.ListIterator();
do
{
if (!cursor.MoveNext())
{
return(false);
}
ITransition next = cursor.Current;
if (next is ShiftTransition)
{
++shiftCount;
}
else
{
if (next is BinaryTransition)
{
--shiftCount;
if (shiftCount <= 0)
{
cursor.Remove();
}
}
}
}while (shiftCount > 0);
if (!cursor.MoveNext())
{
return(false);
}
ITransition next_1 = cursor.Current;
while ((next_1 is UnaryTransition) || (next_1 is CompoundUnaryTransition))
{
cursor.Remove();
if (!cursor.MoveNext())
{
return(false);
}
next_1 = cursor.Current;
}
// At this point, the rest of the transition sequence should suffice
return(true);
}
/// <summary>
/// In this case, we are starting to build a new subtree when instead
/// we should have been combining existing trees.
/// </summary>
/// <remarks>
/// In this case, we are starting to build a new subtree when instead
/// we should have been combining existing trees. What we can do is
/// find the transitions that build up the next subtree in the gold
/// transition list, figure out how it gets applied to a
/// BinaryTransition, and make that the next BinaryTransition we
/// perform after finishing the subtree. If there are multiple
/// BinaryTransitions in a row, we ignore any associated
/// UnaryTransitions (unfixable) and try to transition to the final
/// state. The assumption is that we can't do anything about the
/// incorrect subtrees any more, so we skip them all.
/// <br />
/// Sadly, this does not seem to help - the parser gets worse when it
/// learns these states
/// </remarks>
internal static bool ReorderIncorrectShiftTransition(IList <ITransition> transitions)
{
IList <BinaryTransition> leftoverBinary = Generics.NewArrayList();
while (transitions.Count > 0)
{
ITransition head = transitions.Remove(0);
if (head is ShiftTransition)
{
break;
}
if (head is BinaryTransition)
{
leftoverBinary.Add((BinaryTransition)head);
}
}
if (transitions.Count == 0 || leftoverBinary.Count == 0)
{
// honestly this is an error we should probably just throw
return(false);
}
int shiftCount = 0;
IListIterator <ITransition> cursor = transitions.ListIterator();
BinaryTransition lastBinary = null;
while (cursor.MoveNext() && shiftCount >= 0)
{
ITransition next = cursor.Current;
if (next is ShiftTransition)
{
++shiftCount;
}
else
{
if (next is BinaryTransition)
{
--shiftCount;
if (shiftCount < 0)
{
lastBinary = (BinaryTransition)next;
cursor.Remove();
}
}
}
}
if (!cursor.MoveNext() || lastBinary == null)
{
// once again, an error. even if the sequence of tree altering
// gold transitions ends with a BinaryTransition, there should
// be a FinalizeTransition after that
return(false);
}
string label = lastBinary.label;
if (lastBinary.IsBinarized())
{
label = Sharpen.Runtime.Substring(label, 1);
}
if (lastBinary.side == BinaryTransition.Side.Right)
{
// When we finally transition all the binary transitions, we
// will want to have the new node be the right head. Therefore,
// we add a bunch of temporary binary transitions with a right
// head, ending up with a binary transition with a right head
for (int i = 0; i < leftoverBinary.Count; ++i)
{
cursor.Add(new BinaryTransition("@" + label, BinaryTransition.Side.Right));
}
// use lastBinary.label in case the last transition is temporary
cursor.Add(new BinaryTransition(lastBinary.label, BinaryTransition.Side.Right));
}
else
{
cursor.Add(new BinaryTransition("@" + label, BinaryTransition.Side.Left));
for (int i = 0; i < leftoverBinary.Count - 1; ++i)
{
cursor.Add(new BinaryTransition("@" + label, leftoverBinary[i].side));
}
cursor.Add(new BinaryTransition(lastBinary.label, leftoverBinary[leftoverBinary.Count - 1].side));
}
return(true);
}
public void Remove()
{
iterator.Remove();
}