void IncrementalGAnalyzer.Analyze(GAnlysInput input, IncrGAnalysisListener listener) { int offset = 0; var afterLis = new PrvtALis { }; foreach (var morpheme in input.followings) { EasyIncrGAnalysListener easyLis = new EasyIncrGAnalysListener(); var nextInput = input.GetAdvanced(offset); lasyAnlys.Analyze(nextInput, easyLis); if (easyLis.didMatch) { listener.OnMatch(nextInput, afterLis); return; } else { afterLis.gBlocks.Add(new StdMutableGUnit { word = morpheme.word }); } offset++; } }
void IncrementalGAnalyzer.Analyze(GAnlysInput input, IncrGAnalysisListener listener) { if (IsMatching(input)) { listener.OnMatch(input.GetAdvanced(words.Count), this); } }
void IncrementalGAnalyzer.Analyze(GAnlysInput input, IncrGAnalysisListener listener) { anaylzers[0].Analyze(input, new ChainListener { index = 0, results = new List <IndexAndResult>(), analyzers = anaylzers, finalListener = listener, afterListenerFactory = CreateAfterListener } ); }
void IncrementalGAnalyzer.Analyze(GAnlysInput input, IncrGAnalysisListener listener) { var recLis = new RecordingIncrGAnalysListener { baseListener = listener }; baseAnalyzer.Analyze(input, recLis); if (!recLis.didMatch) { listener.OnMatch(input, StbAfterLis.instance); } }
void IncrementalGAnalyzer.Analyze(GAnlysInput input, IncrGAnalysisListener listener) { foreach (var sourceFUnit in input.followings) { if (sourceFUnit.id == morphemeID) { listener.OnMatch(input.GetAdvanced(1), new QuoteAfterMatchListener { unit = sourceFUnit }); } break; } }
void AlternativeIncrGAnalyzer.AnalyzeAgain(IncrGAnalysisListener listener) { var nextInput = previousResult[previousResult.Count - 1].nextInput; var newResultStack = new List <EasyIncrGAnalysListener>(previousResult); #region try past alternatives while (newResultStack.Count != 0) { var lastResult = newResultStack[newResultStack.Count - 1]; if (lastResult.alternative != null) { var altLis = new EasyIncrGAnalysListener(); lastResult.alternative.AnalyzeAgain(altLis); if (altLis.didMatch) { newResultStack.RemoveAt(newResultStack.Count - 1); newResultStack.Add(lastResult); listener.OnMatch(altLis.nextInput, new ClusterAMListener { listeners = newResultStack }, new PrvtAltIGAnlys { parent = parent, previousResult = newResultStack }); return; } } } #endregion #region try repeat var conjLis = new EasyIncrGAnalysListener(); parent.conjectionAnalyzer.Analyze(nextInput, conjLis); if (conjLis.didMatch) { nextInput = conjLis.nextInput; } if (conjLis.didMatch || parent.isConjectionOptional) { var mainLis = new EasyIncrGAnalysListener(); parent.baseAnalyzer.Analyze(nextInput, mainLis); if (mainLis.didMatch) { newResultStack.Add(mainLis); listener.OnMatch(mainLis.nextInput, new ClusterAMListener { listeners = newResultStack }, new PrvtAltIGAnlys { parent = parent, previousResult = newResultStack }); return; } } #endregion }
void IncrementalGAnalyzer.Analyze(GAnlysInput input, IncrGAnalysisListener listener) { var easyLis = new EasyIncrGAnalysListener(); baseAnalyzer.Analyze(input, easyLis); if (easyLis.didMatch) { var alt = new PrvtAltIGAnlys { parent = this, previousResult = new List <EasyIncrGAnalysListener> { easyLis } }; listener.OnMatch(easyLis.nextInput, easyLis.listener, alt); } }
void IncrementalGAnalyzer.Analyze(GAnlysInput input, IncrGAnalysisListener listener) { if (candidates.Count == 0) { return; } var innerListener = new SubListener { clientListner = listener, parent = this, nextAnalyzerIndex = 1, originalInput = input }; while (!innerListener.didHit && innerListener.nextAnalyzerIndex - 1 < candidates.Count) { candidates[innerListener.nextAnalyzerIndex - 1].Analyze(input, innerListener); innerListener.nextAnalyzerIndex++; } }
void IncrementalGAnalyzer.Analyze(GAnlysInput input, IncrGAnalysisListener listener) { var easyLis = new EasyIncrGAnalysListener(); baseAnalyzer.Analyze(input, easyLis); if (easyLis.didMatch) { var alt = new PrvtAltIGAnlys { input = input, parent = this, previousAlt = easyLis.alternative, analyzers = new List <IncrementalGAnalyzer> { baseAnalyzer } }; listener.OnMatch(easyLis.nextInput, easyLis.listener, alt); } }
void AlternativeIncrGAnalyzer.AnalyzeAgain(IncrGAnalysisListener listener) { var index = nextIndex; var innerListener = new SubListener { clientListner = listener, parent = parent, nextAnalyzerIndex = index, originalInput = originalInput }; if (subAltAnalyzer != null) { subAltAnalyzer.AnalyzeAgain(innerListener); } while (!innerListener.didHit && index < parent.candidates.Count) { innerListener.nextAnalyzerIndex++; parent.candidates[index].Analyze(originalInput, innerListener); index++; } }
public void UnitProcess(GAnlysInput input, int fromIndex, IncrGAnalysisListener listener) { for (int index = fromIndex; index < wordAnalyzers.Count; index++) { if (wordAnalyzers[index].IsMatching(input)) { if (index < wordAnalyzers.Count - 1) { listener.OnMatch(input.GetAdvanced(wordAnalyzers[index].words.Count), wordAnalyzers[0], new PrvtAltGAnlys { parent = this, index = index + 1, input = input }); return; } else { listener.OnMatch(input.GetAdvanced(wordAnalyzers[index].words.Count), wordAnalyzers[0], null); return; } } } }
void AlternativeIncrGAnalyzer.AnalyzeAgain(IncrGAnalysisListener listener) { var newResults = new List <IndexAndResult>(results); while (newResults.Count > 0) { var lastResult = newResults[newResults.Count - 1]; newResults.RemoveAt(newResults.Count - 1); var altLis = new ChainListener { finalListener = listener, index = lastResult.index, analyzers = analyzers, afterListenerFactory = afterListenerFactory, results = newResults }; lastResult.result.alternative?.AnalyzeAgain(altLis); if (altLis.didFinalMatch) { return; } } }
void IncrementalGAnalyzer.Analyze(GAnlysInput input, IncrGAnalysisListener listener) { UnitProcess(input, 0, listener); }
void IncrementalGAnalyzer.Analyze(GAnlysInput input, IncrGAnalysisListener listener) { baseAnalyzer.Analyze(input, new ResultChangingIGAListener { baseListener = listener, parent = this }); }
void AlternativeIncrGAnalyzer.AnalyzeAgain(IncrGAnalysisListener listener) { parent.UnitProcess(input, index, listener); }
void AlternativeIncrGAnalyzer.AnalyzeAgain(IncrGAnalysisListener listener) { #region try past alternatives if (previousAlt != null) { var altLis = new EasyIncrGAnalysListener(); previousAlt.AnalyzeAgain(altLis); if (altLis.didMatch) { var alt = new PrvtAltIGAnlys { parent = parent, previousAlt = altLis.alternative, analyzers = analyzers, input = input }; listener.OnMatch(altLis.nextInput, altLis.listener, alt); return; } } #endregion #region try repeat /*if (parent.conjectionAnalyzer != null && !parent.isConjectionOptional) { * var easyConjLis = new EasyIncrGAnalysListener(); * parent.conjectionAnalyzer.Analyze(input, easyConjLis); * if (!easyConjLis.didMatch) { * return; * } * }*/ var newAnalyzers = new List <IncrementalGAnalyzer>(analyzers); if (parent.conjectionAnalyzer != null) { if (parent.isConjectionOptional) { newAnalyzers.Add(new IGAnlys_IgnoreBlock { baseAnalyzer = new IGAnlys_Optional { baseAnalyzer = parent.conjectionAnalyzer } }); } else { newAnalyzers.Add(new IGAnlys_IgnoreBlock { baseAnalyzer = parent.conjectionAnalyzer }); } } newAnalyzers.Add(parent.baseAnalyzer); var repeatLis = new EasyIncrGAnalysListener(); newAnalyzers[0].Analyze( input, new ChainListener { index = 0, results = new List <IndexAndResult>(), analyzers = newAnalyzers, finalListener = repeatLis, afterListenerFactory = DefaultAfterListener } ); if (repeatLis.didMatch) { listener.OnMatch(repeatLis.nextInput, repeatLis.listener, new PrvtAltIGAnlys { analyzers = newAnalyzers, input = input, parent = parent, previousAlt = repeatLis.alternative } ); } #endregion }
void AlternativeIncrGAnalyzer.AnalyzeAgain(IncrGAnalysisListener listener) { baseAltAnalyzer.AnalyzeAgain(new ResultChangingIGAListener { parent = parent, baseListener = listener }); }
void IncrementalGAnalyzer.Analyze(GAnlysInput input, IncrGAnalysisListener listener) { Stack <EasyIncrGAnalysListener> resultArchives = new Stack <EasyIncrGAnalysListener>(); while (true) { var currentInput = resultArchives.Count == 0 ? input : resultArchives.Peek().nextInput; if (resultArchives.Count > 0 && conjectionAnalyzer != null) { var conjLis = new EasyIncrGAnalysListener(); conjectionAnalyzer.Analyze(currentInput, conjLis); if (conjLis.didMatch) { currentInput = conjLis.nextInput; } if (!conjLis.didMatch && !isConjectionOptional) { break; } } var easyLis = new EasyIncrGAnalysListener(); baseAnalyzer.Analyze(currentInput, easyLis); if (!easyLis.didMatch) { if (resultArchives.Count == 0) { return; } else { break; } } else { resultArchives.Push(easyLis); } } List <AfterMatchListener> afLiss = new List <AfterMatchListener>(); foreach (var result in resultArchives) { afLiss.Add(result.listener); } bool hasAlt = false; foreach (var result in resultArchives) { if (result.alternative != null) { hasAlt = true; } } AlternativeIncrGAnalyzer altLis = null; if (hasAlt) { altLis = new PrvtAltIGAnlys { givenResultArchive = resultArchives, parent = this }; } listener.OnMatch(resultArchives.Peek().nextInput, new PrvtLis { listeners = afLiss }, altLis); }
void AlternativeIncrGAnalyzer.AnalyzeAgain(IncrGAnalysisListener listener) { Stack <EasyIncrGAnalysListener> resultArchives = new Stack <EasyIncrGAnalysListener>(givenResultArchive); EasyIncrGAnalysListener lastLis = null; while (true) { if (resultArchives.Count <= 0) { return; } var analyzer = resultArchives.Pop(); if (analyzer.alternative == null) { continue; } var easyLis = new EasyIncrGAnalysListener(); analyzer.alternative.AnalyzeAgain(easyLis); if (easyLis.didMatch) { resultArchives.Push(easyLis); lastLis = easyLis; break; } } while (true) { if (parent.conjectionAnalyzer != null) { var conjLis = new EasyIncrGAnalysListener { }; parent.conjectionAnalyzer.Analyze(lastLis.nextInput, conjLis); if (conjLis.didMatch) { lastLis = conjLis; } else if (!parent.isConjectionOptional) { return; } } var easyLis = new EasyIncrGAnalysListener(); parent.baseAnalyzer.Analyze(lastLis.nextInput, easyLis); if (!easyLis.didMatch) { if (resultArchives.Count == 0) { return; } else { break; } } else { resultArchives.Push(easyLis); } } List <AfterMatchListener> afLiss = new List <AfterMatchListener>(); foreach (var result in resultArchives) { afLiss.Add(result.listener); } bool hasAlt = false; foreach (var result in resultArchives) { if (result.alternative != null) { hasAlt = true; } } AlternativeIncrGAnalyzer altAnlys = null; if (hasAlt) { altAnlys = new PrvtAltIGAnlys { givenResultArchive = resultArchives, parent = parent }; } listener.OnMatch(resultArchives.Peek().nextInput, new PrvtLis { listeners = afLiss }, altAnlys); }