//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: static<T> void walk(util.fst.FST<T> fst) throws java.io.IOException
internal static void walk <T>(FST <T> fst)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.ArrayList<util.fst.FST.Arc<T>> queue = new java.util.ArrayList<>();
List <FST.Arc <T> > queue = new List <FST.Arc <T> >();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.BitSet seen = new java.util.BitSet();
BitArray seen = new BitArray();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final util.fst.FST.BytesReader reader = fst.getBytesReader();
FST.BytesReader reader = fst.BytesReader;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final util.fst.FST.Arc<T> startArc = fst.getFirstArc(new util.fst.FST.Arc<T>());
FST.Arc <T> startArc = fst.getFirstArc(new FST.Arc <T>());
queue.Add(startArc);
while (queue.Count > 0)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final util.fst.FST.Arc<T> arc = queue.remove(0);
FST.Arc <T> arc = queue.Remove(0);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final long node = arc.target;
long node = arc.target;
//System.out.println(arc);
if (FST.targetHasArcs(arc) && !seen.Get((int)node))
{
seen.Set((int)node, true);
fst.readFirstRealTargetArc(node, arc, reader);
while (true)
{
queue.Add((new FST.Arc <T>()).copyFrom(arc));
if (arc.Last)
{
break;
}
else
{
fst.readNextRealArc(arc, reader);
}
}
}
}
}
// Use the builder to create:
private NormalizeCharMap(FST <CharsRef> map)
{
this.map = map;
if (map != null)
{
try
{
// Pre-cache root arcs:
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.apache.lucene.util.fst.FST.Arc<org.apache.lucene.util.CharsRef> scratchArc = new org.apache.lucene.util.fst.FST.Arc<>();
FST.Arc <CharsRef> scratchArc = new FST.Arc <CharsRef>();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.apache.lucene.util.fst.FST.BytesReader fstReader = map.getBytesReader();
FST.BytesReader fstReader = map.BytesReader;
map.getFirstArc(scratchArc);
if (FST.targetHasArcs(scratchArc))
{
map.readFirstRealTargetArc(scratchArc.target, scratchArc, fstReader);
while (true)
{
Debug.Assert(scratchArc.label != FST.END_LABEL);
cachedRootArcs[Convert.ToChar((char)scratchArc.label)] = (new FST.Arc <CharsRef>()).copyFrom(scratchArc);
if (scratchArc.Last)
{
break;
}
map.readNextRealArc(scratchArc, fstReader);
}
}
//System.out.println("cached " + cachedRootArcs.size() + " root arcs");
}
catch (IOException ioe)
{
// Bogus FST IOExceptions!! (will never happen)
throw new Exception(ioe);
}
}
}
internal bool canGrow(Frame frame) // can walk forward on both fst&fsa
{
return(frame.fsaState != -1 && FST.targetHasArcs(frame.fstArc));
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: @Override public int read() throws java.io.IOException
public override int read()
{
//System.out.println("\nread");
while (true)
{
if (replacement != null && replacementPointer < replacement.length)
{
//System.out.println(" return repl[" + replacementPointer + "]=" + replacement.chars[replacement.offset + replacementPointer]);
return(replacement.chars[replacement.offset + replacementPointer++]);
}
// TODO: a more efficient approach would be Aho/Corasick's
// algorithm
// (http://en.wikipedia.org/wiki/Aho%E2%80%93Corasick_string_matching_algorithm)
// or this generalizatio: www.cis.uni-muenchen.de/people/Schulz/Pub/dictle5.ps
//
// I think this would be (almost?) equivalent to 1) adding
// epsilon arcs from all final nodes back to the init
// node in the FST, 2) adding a .* (skip any char)
// loop on the initial node, and 3) determinizing
// that. Then we would not have to restart matching
// at each position.
int lastMatchLen = -1;
CharsRef lastMatch = null;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int firstCH = buffer.get(inputOff);
int firstCH = buffer.get(inputOff);
if (firstCH != -1)
{
FST.Arc <CharsRef> arc = cachedRootArcs[Convert.ToChar((char)firstCH)];
if (arc != null)
{
if (!FST.targetHasArcs(arc))
{
// Fast pass for single character match:
Debug.Assert(arc.Final);
lastMatchLen = 1;
lastMatch = arc.output;
}
else
{
int lookahead = 0;
CharsRef output = arc.output;
while (true)
{
lookahead++;
if (arc.Final)
{
// Match! (to node is final)
lastMatchLen = lookahead;
lastMatch = outputs.add(output, arc.nextFinalOutput);
// Greedy: keep searching to see if there's a
// longer match...
}
if (!FST.targetHasArcs(arc))
{
break;
}
int ch = buffer.get(inputOff + lookahead);
if (ch == -1)
{
break;
}
if ((arc = map.findTargetArc(ch, arc, scratchArc, fstReader)) == null)
{
// Dead end
break;
}
output = outputs.add(output, arc.output);
}
}
}
}
if (lastMatch != null)
{
inputOff += lastMatchLen;
//System.out.println(" match! len=" + lastMatchLen + " repl=" + lastMatch);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int diff = lastMatchLen - lastMatch.length;
int diff = lastMatchLen - lastMatch.length;
if (diff != 0)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int prevCumulativeDiff = getLastCumulativeDiff();
int prevCumulativeDiff = LastCumulativeDiff;
if (diff > 0)
{
// Replacement is shorter than matched input:
addOffCorrectMap(inputOff - diff - prevCumulativeDiff, prevCumulativeDiff + diff);
}
else
{
// Replacement is longer than matched input: remap
// the "extra" chars all back to the same input
// offset:
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int outputStart = inputOff - prevCumulativeDiff;
int outputStart = inputOff - prevCumulativeDiff;
for (int extraIDX = 0; extraIDX < -diff; extraIDX++)
{
addOffCorrectMap(outputStart + extraIDX, prevCumulativeDiff - extraIDX - 1);
}
}
}
replacement = lastMatch;
replacementPointer = 0;
}
else
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int ret = buffer.get(inputOff);
int ret = buffer.get(inputOff);
if (ret != -1)
{
inputOff++;
buffer.freeBefore(inputOff);
}
return(ret);
}
}
}