BreakpointCreatorsManager.java

package jetbrains.mps.debug.api;

/*Generated by MPS */

import com.intellij.openapi.components.ApplicationComponent;
import org.apache.log4j.Logger;
import org.apache.log4j.LogManager;
import java.util.Map;
import jetbrains.mps.internal.collections.runtime.MapSequence;
import java.util.LinkedHashMap;
import java.util.Set;
import jetbrains.mps.internal.collections.runtime.SetSequence;
import java.util.LinkedHashSet;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.mps.openapi.model.SNode;
import jetbrains.mps.internal.collections.runtime.IWhereFilter;
import jetbrains.mps.lang.smodel.generator.smodelAdapter.SNodeOperations;
import jetbrains.mps.debug.api.breakpoints.ILocationBreakpoint;
import org.jetbrains.mps.openapi.language.SAbstractConcept;
import com.intellij.openapi.project.Project;
import jetbrains.mps.baseLanguage.closures.runtime._FunctionTypes;
import org.apache.log4j.Level;
import jetbrains.mps.textgen.trace.TraceablePositionInfo;
import jetbrains.mps.textgen.trace.TraceInfo;
import com.intellij.openapi.application.ApplicationManager;

public class BreakpointCreatorsManager implements ApplicationComponent {
  private static final Logger LOG = LogManager.getLogger(BreakpointCreatorsManager.class);
  @Deprecated
  private Map<String, BreakpointCreator> myCreatorsByConcept = MapSequence.fromMap(new LinkedHashMap<String, BreakpointCreator>(16, (float) 0.75, false));
  private Set<BreakpointCreator> myCreators = SetSequence.fromSet(new LinkedHashSet<BreakpointCreator>());

  public BreakpointCreatorsManager() {
  }
  @NotNull
  @Override
  public String getComponentName() {
    return "Debug Info Manager";
  }

  public void addCreator(BreakpointCreator creator) {
    SetSequence.fromSet(myCreators).addElement(creator);
  }

  public void removeCreator(BreakpointCreator creator) {
    SetSequence.fromSet(myCreators).removeElement(creator);
  }

  public boolean isDebuggableNode(@Nullable final SNode node) {
    if (node == null) {
      return false;
    }
    return SetSequence.fromSet(myCreators).findFirst(new IWhereFilter<BreakpointCreator>() {
      public boolean accept(BreakpointCreator it) {
        return it._0().invoke(SNodeOperations.getConcept(node), node);
      }
    }) != null;
  }
  private ILocationBreakpoint createBreakpoint(SAbstractConcept concept, SNode node, Project project) {
    for (BreakpointCreator creator : SetSequence.fromSet(myCreators)) {
      if (creator._0().invoke(concept, node)) {
        _FunctionTypes._return_P2_E0<? extends ILocationBreakpoint, ? super SNode, ? super Project> function = creator._1();
        if (function == null) {
          if (LOG.isEnabledFor(Level.WARN)) {
            LOG.warn("Could not create breakpoint for node " + node);
          }
          return null;
        }
        return function.invoke(node, project);
      }
    }
    return null;
  }
  @Nullable
  public ILocationBreakpoint createBreakpoint(SNode node, Project project) {
    ILocationBreakpoint breakpoint = createBreakpoint(SNodeOperations.getConcept(node), node, project);
    if (breakpoint != null) {
      return breakpoint;
    }

    // [MM] why are we changing concept, but not node? 
    TraceablePositionInfo position = TraceInfo.getPositionForNode(node);
    if (position != null) {
      SAbstractConcept concept = position.getConcept();
      if (concept == null) {
        return null;
      }
      return createBreakpoint(concept, node, project);
    }
    return null;
  }
  @Override
  public void initComponent() {
  }
  @Override
  public void disposeComponent() {
  }
  public static BreakpointCreatorsManager getInstance() {
    return ApplicationManager.getApplication().getComponent(BreakpointCreatorsManager.class);
  }
}