@Override public void produce(final ClassInference inference) { final IndexedContextRoot originRoot = inference.getTraceRoot(); Queue<ClassInference> inferencesByOrigin = tracedInferences_ .get(originRoot); if (inferencesByOrigin == null) { inferencesByOrigin = new ConcurrentLinkedQueue<ClassInference>(); final Queue<ClassInference> previous = tracedInferences_ .putIfAbsent(originRoot, inferencesByOrigin); if (previous != null) inferencesByOrigin = previous; } inferencesByOrigin.add(inference); }
private static ClassConclusion getConclusion(ClassInference inference) { return inference.accept(CONCLUSION_GETTER_); }
@Override public void produce(ClassInference inference) { Context context = state_.getContext(inference.getDestination()); if (context != null) { super.produce(inference); } }
@Override public void produce(ClassInference inference) { Context context = state_.getContext(inference.getDestination()); if (context != null) { super.produce(inference); } }
@Override public void produce(final ClassInference inference) { final IndexedContextRoot originRoot = inference.getTraceRoot(); Queue<ClassInference> inferencesByOrigin = tracedInferences_ .get(originRoot); if (inferencesByOrigin == null) { inferencesByOrigin = new ConcurrentLinkedQueue<ClassInference>(); final Queue<ClassInference> previous = tracedInferences_ .putIfAbsent(originRoot, inferencesByOrigin); if (previous != null) inferencesByOrigin = previous; } inferencesByOrigin.add(inference); }
private static ClassConclusion getConclusion(ClassInference inference) { return inference.accept(CONCLUSION_GETTER_); }
@Override public void produce(ClassInference inference) { Context context = state_.getContext(inference.getDestination()); if (context != null) { super.produce(inference); } }
@Override public void produce(final ClassInference inference) { final IndexedContextRoot originRoot = inference.getTraceRoot(); Queue<ClassInference> inferencesByOrigin = tracedInferences_ .get(originRoot); if (inferencesByOrigin == null) { inferencesByOrigin = new ConcurrentLinkedQueue<ClassInference>(); final Queue<ClassInference> previous = tracedInferences_ .putIfAbsent(originRoot, inferencesByOrigin); if (previous != null) inferencesByOrigin = previous; } inferencesByOrigin.add(inference); }
private static ClassConclusion getConclusion(ClassInference inference) { return inference.accept(CONCLUSION_GETTER_); }
@Override public void produce(ClassInference inference) { if (localTodo_.isActivated() && inference.getDestination() == localTodo_.getActiveRoot()) { localTodo_.add(inference); } else { mainWriter.produce(inference); } }
@Override protected Boolean defaultVisit(ClassInference conclusion) { tracedRoots_.add(conclusion.getTraceRoot()); return true; }
/** * @param inference * @param premise * @return {@code true} if the given {@code ClassInference} has the given * {@code ClassConclusion} as one of the premises */ private static boolean hasPremise(ClassInference inference, ClassConclusion premise) { ConclusionEqualityChecker checker = new ConclusionEqualityChecker( premise); inference.accept(new ClassInferenceLocalPremiseVisitor<Void>( CONCLUSION_FACTORY_, checker)); return checker.getResult(); }
@Override public void produce(ClassInference inference) { if (localTodo_.isActivated() && inference.getDestination() == localTodo_.getActiveRoot()) { localTodo_.add(inference); } else { mainWriter.produce(inference); } }
@Override public void produce(ClassInference inference) { Context sourceContext = state_.getContext(inference.getTraceRoot()); if (sourceContext == null || !sourceContext.isSaturated()) { super.produce(inference); } }
/** * @param inference * @param premise * @return {@code true} if the given {@code ClassInference} has the given * {@code ClassConclusion} as one of the premises */ private static boolean hasPremise(ClassInference inference, ClassConclusion premise) { ConclusionEqualityChecker checker = new ConclusionEqualityChecker( premise); inference.accept(new ClassInferenceLocalPremiseVisitor<Void>( CONCLUSION_FACTORY_, checker)); return checker.getResult(); }
@Override public void produce(ClassInference inference) { if (localTodo_.isActivated() && inference.getDestination() == localTodo_.getActiveRoot()) { localTodo_.add(inference); } else { mainWriter.produce(inference); } }
@Override public void produce(ClassInference inference) { Context sourceContext = state_.getContext(inference.getTraceRoot()); if (sourceContext == null || !sourceContext.isSaturated()) { super.produce(inference); } }
/** * @param inference * @param premise * @return {@code true} if the given {@code ClassInference} has the given * {@code ClassConclusion} as one of the premises */ private static boolean hasPremise(ClassInference inference, ClassConclusion premise) { ConclusionEqualityChecker checker = new ConclusionEqualityChecker( premise); inference.accept(new ClassInferenceLocalPremiseVisitor<Void>( CONCLUSION_FACTORY_, checker)); return checker.getResult(); }
@Override public void produce(ClassInference inference) { Context sourceContext = state_.getContext(inference.getTraceRoot()); if (sourceContext == null || !sourceContext.isSaturated()) { super.produce(inference); } }
/** * @param inference * @return a local premise of the given {@code ClassInference} that cannot * be derived by other inferences in {@link #output_} that do not * use the conclusion of this {@code ClassInference} as one of the * premises; returns {@code null} if such a premise does not exist */ private ClassConclusion getBlockedPremise(ClassInference inference) { DerivabilityChecker checker = new DerivabilityChecker( getConclusion(inference)); inference.accept(new ClassInferenceLocalPremiseVisitor<Void>( CONCLUSION_FACTORY_, checker)); return checker.getResult(); }