package jetbrains.mps.lang.test.runtime;
/*Generated by MPS */
import org.apache.log4j.Logger;
import org.apache.log4j.LogManager;
import org.jetbrains.mps.openapi.model.SNode;
import jetbrains.mps.errors.IErrorReporter;
import jetbrains.mps.smodel.event.SModelCommandListener;
import java.util.List;
import jetbrains.mps.smodel.event.SModelEvent;
import jetbrains.mps.smodel.GlobalSModelEventsManager;
import jetbrains.mps.lang.smodel.generator.smodelAdapter.SNodeOperations;
import org.jetbrains.annotations.NotNull;
import jetbrains.mps.errors.MessageStatus;
import java.util.Set;
import jetbrains.mps.internal.collections.runtime.SetSequence;
import java.util.HashSet;
import jetbrains.mps.internal.collections.runtime.Sequence;
import jetbrains.mps.internal.collections.runtime.IWhereFilter;
import jetbrains.mps.checkers.TypesystemChecker;
import jetbrains.mps.checkers.AbstractConstraintsCheckerRootCheckerAdapter;
import jetbrains.mps.checkers.ConstraintsChecker;
import jetbrains.mps.checkers.RefScopeChecker;
import jetbrains.mps.checkers.TargetConceptChecker;
import jetbrains.mps.project.validation.ValidationUtil;
import org.jetbrains.mps.openapi.util.Processor;
import jetbrains.mps.project.validation.ValidationProblem;
import jetbrains.mps.project.validation.NodeValidationProblem;
import jetbrains.mps.errors.SimpleErrorReporter;
import jetbrains.mps.checkers.ErrorReportUtil;
import org.jetbrains.annotations.Nullable;
/**
*
* @deprecated needs to be united with the common model checking logic. Here we have the second cache of the same things.
*/
@Deprecated
public class TestsErrorsChecker {
private static final Logger LOG = LogManager.getLogger(TestsErrorsChecker.class);
private SNode myRoot;
/**
* contains cached warnings and errors for the current root
*/
private static TestsErrorsChecker.ModelErrorsHolder<IErrorReporter> ourModelErrorsHolder = new TestsErrorsChecker.ModelErrorsHolder<IErrorReporter>();
/**
* clears our cache on any model change
*/
private static SModelCommandListener ourModelChangesListener;
private static void initModelListener() {
if (ourModelChangesListener == null) {
ourModelChangesListener = new SModelCommandListener() {
public void eventsHappenedInCommand(List<SModelEvent> events) {
if (!(events.isEmpty())) {
ourModelErrorsHolder = new TestsErrorsChecker.ModelErrorsHolder();
}
}
};
GlobalSModelEventsManager.getInstance().addGlobalCommandListener(ourModelChangesListener);
}
}
static {
initModelListener();
}
@Deprecated
public TestsErrorsChecker(SNode root) {
assert root == SNodeOperations.getContainingRoot(root);
myRoot = root;
}
public Iterable<IErrorReporter> getAllErrors() {
return getRootErrors();
}
public Iterable<IErrorReporter> getErrors(@NotNull SNode node) {
Iterable<IErrorReporter> result = getRootErrors();
return filterReportersByNode(result, node);
}
public Iterable<IErrorReporter> getErrorsSpecificType(SNode node, final MessageStatus errorType) {
Set<IErrorReporter> result = SetSequence.fromSet(new HashSet<IErrorReporter>());
SetSequence.fromSet(result).addSequence(Sequence.fromIterable(getErrors(node)).where(new IWhereFilter<IErrorReporter>() {
public boolean accept(IErrorReporter it) {
return it.getMessageStatus() == errorType;
}
}));
return result;
}
private Iterable<IErrorReporter> filterReportersByNode(final Iterable<IErrorReporter> errors, @NotNull final SNode aNode) {
return Sequence.fromIterable(errors).where(new IWhereFilter<IErrorReporter>() {
public boolean accept(IErrorReporter it) {
assert it.getSNode() != null;
return it.getSNode().getNodeId().equals(aNode.getNodeId());
}
});
}
private Iterable<IErrorReporter> getRootErrors() {
Set<IErrorReporter> cachedErrors = TestsErrorsChecker.ourModelErrorsHolder.get(myRoot);
if (cachedErrors != null) {
return SetSequence.fromSet(cachedErrors).toListSequence();
}
if (LOG.isDebugEnabled()) {
LOG.debug("Collecting errors in the root " + myRoot);
}
final Set<IErrorReporter> result = SetSequence.fromSet(new HashSet<IErrorReporter>());
SetSequence.fromSet(result).addSequence(SetSequence.fromSet(new TypesystemChecker().getErrors(myRoot, null)));
// todo: add UsedLanguageChecker
SetSequence.fromSet(result).addSequence(SetSequence.fromSet(new AbstractConstraintsCheckerRootCheckerAdapter(AbstractConstraintsCheckerRootCheckerAdapter.SKIP_CONSTRAINTS_CONDITION, new ConstraintsChecker(), new RefScopeChecker(), new TargetConceptChecker()).getErrors(myRoot, null)));
ValidationUtil.validateModelContent(Sequence.<SNode>singleton(myRoot), new Processor<ValidationProblem>() {
public boolean process(ValidationProblem vp) {
if (!((vp instanceof NodeValidationProblem))) {
return true;
}
SNode node = ((NodeValidationProblem) vp).getNode();
SetSequence.fromSet(result).addElement(new SimpleErrorReporter(node, vp.getMessage(), null, null));
return true;
}
});
Set<IErrorReporter> res = SetSequence.fromSetWithValues(new HashSet<IErrorReporter>(), SetSequence.fromSet(result).where(new IWhereFilter<IErrorReporter>() {
public boolean accept(IErrorReporter it) {
return !(ErrorReportUtil.manuallySuppressed(it.getSNode()));
}
}));
TestsErrorsChecker.ourModelErrorsHolder.set(myRoot, res);
return res;
}
private static class ModelErrorsHolder<T> {
private Set<T> myCachedErrors;
private SNode myRoot;
@Nullable
public Set<T> get(SNode root) {
if (myCachedErrors != null && sameRoot(root)) {
return myCachedErrors;
}
return null;
}
private boolean sameRoot(SNode root) {
return root == myRoot;
}
public void set(SNode root, Set<T> errors) {
myRoot = root;
myCachedErrors = SetSequence.fromSet(new HashSet<T>());
SetSequence.fromSet(myCachedErrors).addSequence(SetSequence.fromSet(errors));
}
}
}