AbstractConstraintsCheckerRootCheckerAdapter.java

package jetbrains.mps.checkers;

/*Generated by MPS */

import java.util.Set;
import org.jetbrains.mps.openapi.model.SNode;
import jetbrains.mps.lang.smodel.generator.smodelAdapter.SNodeOperations;
import jetbrains.mps.smodel.adapter.structure.MetaAdapterFactory;
import org.jetbrains.annotations.NotNull;
import jetbrains.mps.internal.collections.runtime.SetSequence;
import java.util.HashSet;
import jetbrains.mps.internal.collections.runtime.Sequence;
import jetbrains.mps.errors.IErrorReporter;
import org.jetbrains.mps.openapi.module.SRepository;
import org.jetbrains.mps.openapi.util.Processor;
import org.jetbrains.mps.openapi.model.SModel;
import org.jetbrains.mps.util.DescendantsTreeIterator;
import jetbrains.mps.util.Reference;

public class AbstractConstraintsCheckerRootCheckerAdapter implements IRootChecker {
  private Set<AbstractNodeChecker> myRules;

  public interface ErrorSkipCondition {
    boolean skipSingleNode(SNode node);
    boolean skipSubtree(SNode root);
  }

  private AbstractConstraintsCheckerRootCheckerAdapter.ErrorSkipCondition mySkipCondition;

  public static final AbstractConstraintsCheckerRootCheckerAdapter.ErrorSkipCondition SKIP_CONSTRAINTS_CONDITION = new AbstractConstraintsCheckerRootCheckerAdapter.ErrorSkipCondition() {
    public boolean skipSingleNode(SNode node) {
      return false;
    }
    public boolean skipSubtree(SNode root) {
      return SNodeOperations.isInstanceOf(root, MetaAdapterFactory.getInterfaceConcept(0xceab519525ea4f22L, 0x9b92103b95ca8c0cL, 0x50ef06e32fec9043L, "jetbrains.mps.lang.core.structure.ISkipConstraintsChecking"));
    }
  };

  public static final AbstractConstraintsCheckerRootCheckerAdapter.ErrorSkipCondition SKIP_NOTHING_CONDITION = new AbstractConstraintsCheckerRootCheckerAdapter.ErrorSkipCondition() {
    public boolean skipSingleNode(SNode node) {
      return false;
    }
    public boolean skipSubtree(SNode root) {
      return false;
    }
  };

  public static final AbstractConstraintsCheckerRootCheckerAdapter.ErrorSkipCondition SUPRESS_ERRORS_CONDITION = new AbstractConstraintsCheckerRootCheckerAdapter.ErrorSkipCondition() {
    public boolean skipSingleNode(SNode node) {
      return !(ErrorReportUtil.shouldReportError(node));
    }
    public boolean skipSubtree(SNode root) {
      return false;
    }
  };

  public AbstractConstraintsCheckerRootCheckerAdapter(@NotNull AbstractConstraintsCheckerRootCheckerAdapter.ErrorSkipCondition skipCondition, AbstractNodeChecker... rules) {
    myRules = SetSequence.fromSetWithValues(new HashSet<AbstractNodeChecker>(), Sequence.fromArray(rules));
    mySkipCondition = skipCondition;
  }
  public AbstractConstraintsCheckerRootCheckerAdapter(AbstractNodeChecker... rules) {
    this(SKIP_NOTHING_CONDITION, rules);
  }
  @Override
  public Set<IErrorReporter> getErrors(SNode rootNode, SRepository repository) {
    final Set<IErrorReporter> result = SetSequence.fromSet(new HashSet<IErrorReporter>());
    processErrors(rootNode, repository, new Processor<IErrorReporter>() {
      public boolean process(IErrorReporter error) {
        SetSequence.fromSet(result).addElement(error);
        return true;
      }
    });
    return result;
  }
  @Override
  public void processErrors(SNode rootNode, SRepository repository, final Processor<IErrorReporter> processor) {
    SModel model = SNodeOperations.getModel(rootNode);
    assert model != null;

    DescendantsTreeIterator fullCheckIterator = new DescendantsTreeIterator(rootNode);

    final Reference<Boolean> cancelled = new Reference<Boolean>(false);

    LanguageErrorsCollector errorsCollector = new LanguageErrorsCollector() {
      public void addError(IErrorReporter errorReporter) {
        if (mySkipCondition.skipSingleNode(errorReporter.getSNode())) {
          return;
        }
        cancelled.set(cancelled.get() || !(processor.process(errorReporter)));
      }
    };

    while (fullCheckIterator.hasNext() && !(cancelled.get())) {
      SNode node = fullCheckIterator.next();
      if (mySkipCondition.skipSubtree(node)) {
        fullCheckIterator.skipChildren();
        continue;
      }
      for (AbstractNodeChecker checker : myRules) {
        checker.checkNode(node, errorsCollector, repository);
      }
    }
  }
}