RootCheckerSpecificCheckerAdapter.java

package jetbrains.mps.ide.modelchecker.platform.actions;

/*Generated by MPS */

import jetbrains.mps.checkers.IRootChecker;
import org.jetbrains.mps.openapi.module.SRepository;
import org.jetbrains.annotations.NotNull;
import jetbrains.mps.errors.IErrorReporter;
import org.jetbrains.mps.openapi.model.SNode;
import jetbrains.mps.errors.QuickFixProvider;
import jetbrains.mps.errors.QuickFix_Runtime;
import org.jetbrains.mps.openapi.model.SNodeReference;
import java.util.List;
import jetbrains.mps.ide.findusages.model.SearchResult;
import org.jetbrains.mps.openapi.model.SModel;
import org.jetbrains.mps.openapi.util.ProgressMonitor;
import jetbrains.mps.internal.collections.runtime.ListSequence;
import java.util.ArrayList;
import jetbrains.mps.lang.smodel.generator.smodelAdapter.SModelOperations;
import org.jetbrains.mps.openapi.util.Processor;

public class RootCheckerSpecificCheckerAdapter extends SpecificChecker {
  private final IRootChecker myChecker;
  private final String myCategory;
  private final SRepository myRepository;

  public RootCheckerSpecificCheckerAdapter(IRootChecker checker, String category, @NotNull SRepository repository) {
    myChecker = checker;
    myCategory = category;
    myRepository = repository;
  }

  public IModelCheckerFix getFix(IErrorReporter errorReporter) {
    final SNode reporterNode = errorReporter.getSNode();
    if (reporterNode != null) {
      QuickFixProvider provider = check_3jptrj_a0a0b0g(errorReporter);
      if (provider != null) {
        final QuickFix_Runtime quickFix = provider.getQuickFix();
        if (quickFix != null && provider.isExecutedImmediately()) {
          final SNodeReference reporterNodeRef = reporterNode.getReference();
          return new IModelCheckerFix() {
            public boolean doFix() {
              SNode resolved = reporterNodeRef.resolve(myRepository);
              if (resolved != null) {
                quickFix.execute(reporterNode);
                return true;
              } else {
                return false;
              }
            }
          };
        }
      }
    }
    return null;
  }

  public List<SearchResult<ModelCheckerIssue>> checkModel(SModel model, final ProgressMonitor monitor) {
    final List<SearchResult<ModelCheckerIssue>> results = ListSequence.fromList(new ArrayList<SearchResult<ModelCheckerIssue>>());

    monitor.start(myCategory, 1);
    for (final SNode rootNode : SModelOperations.roots(model, null)) {
      myChecker.processErrors(rootNode, myRepository, new Processor<IErrorReporter>() {
        public boolean process(IErrorReporter errorReporter) {
          SpecificChecker.addIssue(results, errorReporter.getSNode(), errorReporter.reportError(), SpecificChecker.getResultCategory(errorReporter.getMessageStatus()), myCategory, getFix(errorReporter));
          return !(monitor.isCanceled());
        }
      });
    }
    monitor.done();
    return results;
  }

  private static QuickFixProvider check_3jptrj_a0a0b0g(IErrorReporter checkedDotOperand) {
    if (null != checkedDotOperand) {
      return checkedDotOperand.getIntentionProvider();
    }
    return null;
  }
}