public <S, P, R, D extends Pda<S, P>> D filterEdges(
Pda<S, P> pda, Traverser<? super Pda<S, P>, S, R> traverser, PdaFactory<D, S, P, S> factory) {
HashStack<TraversalItem<S, R>> trace = new HashStack<TraversalItem<S, R>>();
R previous = traverser.enter(pda, pda.getStart(), null);
if (previous == null)
return factory == null ? null : factory.create(pda.getStart(), pda.getStop());
Map<S, Integer> distances = new NfaUtil().distanceToFinalStateMap(pda);
MappedComparator<S, Integer> distanceComp = new MappedComparator<S, Integer>(distances);
trace.push(newItem(pda, distanceComp, distances, pda.getStart(), previous));
Multimap<S, S> edges = LinkedHashMultimap.create();
HashSet<S> states = Sets.newLinkedHashSet();
HashSet<Pair<S, R>> success = Sets.newLinkedHashSet();
states.add(pda.getStart());
states.add(pda.getStop());
ROOT:
while (!trace.isEmpty()) {
TraversalItem<S, R> current = trace.peek();
while (current.followers.hasNext()) {
S next = current.followers.next();
R item = traverser.enter(pda, next, current.data);
if (item != null) {
if ((next == pda.getStop() && traverser.isSolution(item))
|| success.contains(Tuples.create(next, item))) {
S s = null;
for (TraversalItem<S, R> i : trace) {
if (s != null) edges.put(s, i.state);
states.add(i.state);
success.add(Tuples.create(i.state, i.data));
s = i.state;
}
edges.put(s, next);
} else {
if (trace.push(newItem(pda, distanceComp, distances, next, item))) continue ROOT;
}
}
}
trace.pop();
}
if (factory == null) return null;
D result = factory.create(pda.getStart(), pda.getStop());
Map<S, S> old2new = Maps.newLinkedHashMap();
old2new.put(pda.getStart(), result.getStart());
old2new.put(pda.getStop(), result.getStop());
for (S old : states) {
if (old == pda.getStart() || old == pda.getStop()) continue;
else if (pda.getPop(old) != null) old2new.put(old, factory.createPop(result, old));
else if (pda.getPush(old) != null) old2new.put(old, factory.createPush(result, old));
else old2new.put(old, factory.createState(result, old));
}
for (S old : states) {
List<S> followers = Lists.newArrayList();
for (S f : edges.get(old)) followers.add(old2new.get(f));
factory.setFollowers(result, old2new.get(old), followers);
}
return result;
}
protected <S, P, T, D extends Pda<S, P>> S clone(
S state,
Pda<S, P> src,
D target,
Function<S, T> tokens,
PdaFactory<D, S, P, T> fact,
Identity<S> identity) {
if (state == src.getStart()) return target.getStart();
if (state == src.getStop()) return target.getStop();
P push = src.getPush(state);
if (push != null) return identity.get(fact.createPush(target, tokens.apply(state)));
P pop = src.getPop(state);
if (pop != null) return identity.get(fact.createPop(target, tokens.apply(state)));
return identity.get(fact.createState(target, tokens.apply(state)));
}
public <S, P, E, T1, T2, D extends Pda<S, P>> D create(
Cfg<E, T1> cfg,
FollowerFunction<E> ff,
Function<E, T2> element2token,
PdaFactory<D, S, P, ? super T2> fact) {
D pda = fact.create(null, null);
Map<E, S> states = Maps.newLinkedHashMap();
Map<E, S> stops = Maps.newLinkedHashMap();
Multimap<E, E> callers = new CfgUtil().getCallers(cfg);
create(
cfg,
pda,
pda.getStart(),
cfg.getRoot(),
ff.getStarts(cfg.getRoot()),
ff,
element2token,
fact,
states,
stops,
callers);
return pda;
}
