import com.intellij.xdebugger.breakpoints.XBreakpoint; //导入依赖的package包/类
private synchronized void registerBreakpoints() {

        log.debug("registering pending breakpoints");

        for (XBreakpoint b : installedBreaks) {
            while (!controller.isReady()) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();  //To change body of catch statement use File | Settings | File Templates.
                    return;
                }
            }

            controller.addBreakPoint(b);
        }

        installedBreaks.clear();
    }
 

import com.intellij.xdebugger.breakpoints.XBreakpoint; //导入依赖的package包/类
@Override
public void registerBreakpoint(@NotNull XBreakpoint breakpoint) {
  Breakpoint javaBreakpoint = BreakpointManager.getJavaBreakpoint(breakpoint);
  if (javaBreakpoint == null) {
    javaBreakpoint = createJavaBreakpoint(breakpoint);
    breakpoint.putUserData(Breakpoint.DATA_KEY, javaBreakpoint);
  }
  if (javaBreakpoint != null) {
    final Breakpoint bpt = javaBreakpoint;
    BreakpointManager.addBreakpoint(bpt);
    // use schedule not to block initBreakpoints
    myProcess.getManagerThread().schedule(new DebuggerCommandImpl() {
      @Override
      protected void action() throws Exception {
        bpt.createRequest(myProcess);
      }

      @Override
      public Priority getPriority() {
        return Priority.HIGH;
      }
    });
  }
}
 

import com.intellij.xdebugger.breakpoints.XBreakpoint; //导入依赖的package包/类
@Override
public void unregisterBreakpoint(@NotNull final XBreakpoint breakpoint, boolean temporary) {
  final Breakpoint javaBreakpoint = BreakpointManager.getJavaBreakpoint(breakpoint);
  if (javaBreakpoint != null) {
    // use schedule not to block initBreakpoints
    myProcess.getManagerThread().schedule(new DebuggerCommandImpl() {
      @Override
      protected void action() throws Exception {
        myProcess.getRequestsManager().deleteRequest(javaBreakpoint);
      }

      @Override
      public Priority getPriority() {
        return Priority.HIGH;
      }
    });
  }
}
 

import com.intellij.xdebugger.breakpoints.XBreakpoint; //导入依赖的package包/类
@Override
public XBreakpointClassGroup getGroup(@NotNull B b, @NotNull Collection<XBreakpointClassGroup> groups) {
  if (b instanceof XBreakpoint) {
    Breakpoint javaBreakpoint = BreakpointManager.getJavaBreakpoint((XBreakpoint)b);
    if (javaBreakpoint == null) {
      return null;
    }
    String className = javaBreakpoint.getShortClassName();
    String packageName = javaBreakpoint.getPackageName();
    if (className == null) {
      return null;
    }
    for (XBreakpointClassGroup group : groups) {
      if (group.getClassName().equals(className) && group.getPackageName().equals(packageName))  {
        return group;
      }
    }
    return new XBreakpointClassGroup(packageName, className);
  }
  return null;
}
 

import com.intellij.xdebugger.breakpoints.XBreakpoint; //导入依赖的package包/类
@Override
public XBreakpointPackageGroup getGroup(@NotNull B breakpoint, @NotNull Collection<XBreakpointPackageGroup> groups) {
  String packageName = null;
  if (breakpoint instanceof XBreakpoint) {
    Breakpoint javaBreakpoint = BreakpointManager.getJavaBreakpoint((XBreakpoint)breakpoint);
    if (javaBreakpoint != null) {
      packageName = javaBreakpoint.getPackageName();
    }
  }
  if (packageName == null) {
    return null;
  }
  for (XBreakpointPackageGroup group : groups) {
    if (StringUtil.equals(group.getPackageName(), packageName)) {
      return group;
    }
  }
  return new XBreakpointPackageGroup(packageName);
}
 

import com.intellij.xdebugger.breakpoints.XBreakpoint; //导入依赖的package包/类
@Nullable
@Override
public XBreakpoint<JavaMethodBreakpointProperties> addBreakpoint(final Project project, JComponent parentComponent) {
  final AddWildcardBreakpointDialog dialog = new AddWildcardBreakpointDialog(project);
  if (!dialog.showAndGet()) {
    return null;
  }
  return ApplicationManager.getApplication().runWriteAction(new Computable<XBreakpoint<JavaMethodBreakpointProperties>>() {
    @Override
    public XBreakpoint<JavaMethodBreakpointProperties> compute() {
      return XDebuggerManager.getInstance(project).getBreakpointManager()
        .addBreakpoint(JavaWildcardMethodBreakpointType.this, new JavaMethodBreakpointProperties(
          dialog.getClassPattern(),
          dialog.getMethodName()));
    }
  });
}
 

import com.intellij.xdebugger.breakpoints.XBreakpoint; //导入依赖的package包/类
@Nullable
@Override
public XBreakpoint<JavaExceptionBreakpointProperties> addBreakpoint(final Project project, JComponent parentComponent) {
  final PsiClass throwableClass =
    JavaPsiFacade.getInstance(project).findClass(CommonClassNames.JAVA_LANG_THROWABLE, GlobalSearchScope.allScope(project));
  TreeClassChooser chooser = TreeClassChooserFactory.getInstance(project)
    .createInheritanceClassChooser(DebuggerBundle.message("add.exception.breakpoint.classchooser.title"),
                                   GlobalSearchScope.allScope(project), throwableClass, true, true, null);
  chooser.showDialog();
  final PsiClass selectedClass = chooser.getSelected();
  final String qName = selectedClass == null ? null : JVMNameUtil.getNonAnonymousClassName(selectedClass);

  if (qName != null && qName.length() > 0) {
    return ApplicationManager.getApplication().runWriteAction(new Computable<XBreakpoint<JavaExceptionBreakpointProperties>>() {
     @Override
     public XBreakpoint<JavaExceptionBreakpointProperties> compute() {
       return XDebuggerManager.getInstance(project).getBreakpointManager().addBreakpoint(
         JavaExceptionBreakpointType.this, new JavaExceptionBreakpointProperties(qName, ((PsiClassOwner)selectedClass.getContainingFile()).getPackageName()));
     }
   });
  }
  return null;
}
 

import com.intellij.xdebugger.breakpoints.XBreakpoint; //导入依赖的package包/类
@Nullable
@Override
public XSourcePosition getSourcePosition(@NotNull XBreakpoint<T> breakpoint) {
  Breakpoint javaBreakpoint = BreakpointManager.getJavaBreakpoint(breakpoint);
  if (javaBreakpoint != null) {
    final PsiClass aClass = javaBreakpoint.getPsiClass();
    if (aClass != null) {
      return ApplicationManager.getApplication().runReadAction(new Computable<XSourcePosition>() {
        @Override
        public XSourcePosition compute() {
          PsiFile containingFile = aClass.getContainingFile();
          if (containingFile != null && aClass.getTextOffset() >= 0) {
            return XDebuggerUtil.getInstance().createPositionByOffset(containingFile.getVirtualFile(), aClass.getTextOffset());
          }
          return null;
        }
      });
    }
  }
  return null;
}
 

import com.intellij.xdebugger.breakpoints.XBreakpoint; //导入依赖的package包/类
static String getText(XBreakpoint<JavaMethodBreakpointProperties> breakpoint) {
  final StringBuilder buffer = StringBuilderSpinAllocator.alloc();
  try {
    //if(isValid()) {
    final String className = breakpoint.getProperties().myClassPattern;
    final boolean classNameExists = className != null && className.length() > 0;
    if (classNameExists) {
      buffer.append(className);
    }
    if(breakpoint.getProperties().myMethodName != null) {
      if (classNameExists) {
        buffer.append(".");
      }
      buffer.append(breakpoint.getProperties().myMethodName);
    }
    //}
    //else {
    //  buffer.append(DebuggerBundle.message("status.breakpoint.invalid"));
    //}
    return buffer.toString();
  }
  finally {
    StringBuilderSpinAllocator.dispose(buffer);
  }
}
 

import com.intellij.xdebugger.breakpoints.XBreakpoint; //导入依赖的package包/类
private void updateBreakpoints(@NotNull Document document) {
  Collection<XLineBreakpointImpl> breakpoints = myBreakpoints.getKeysByValue(document);
  if (breakpoints == null) {
    return;
  }

  TIntHashSet lines = new TIntHashSet();
  List<XBreakpoint<?>> toRemove = new SmartList<XBreakpoint<?>>();
  for (XLineBreakpointImpl breakpoint : breakpoints) {
    breakpoint.updatePosition();
    if (!breakpoint.isValid() || !lines.add(breakpoint.getLine())) {
      toRemove.add(breakpoint);
    }
  }

  removeBreakpoints(toRemove);
}
 

import com.intellij.xdebugger.breakpoints.XBreakpoint; //导入依赖的package包/类
public XDependentBreakpointManager(final XBreakpointManagerImpl breakpointManager) {
  myBreakpointManager = breakpointManager;
  myDispatcher = EventDispatcher.create(XDependentBreakpointListener.class);
  myBreakpointManager.addBreakpointListener(new XBreakpointAdapter<XBreakpoint<?>>() {
    public void breakpointRemoved(@NotNull final XBreakpoint<?> breakpoint) {
      XDependentBreakpointInfo info = mySlave2Info.remove(breakpoint);
      if (info != null) {
        myMaster2Info.remove(info.myMasterBreakpoint, info);
      }

      Collection<XDependentBreakpointInfo> infos = myMaster2Info.removeAll((XBreakpointBase)breakpoint);
      if (infos != null) {
        for (XDependentBreakpointInfo breakpointInfo : infos) {
          XDependentBreakpointInfo removed = mySlave2Info.remove(breakpointInfo.mySlaveBreakpoint);
          if (removed != null) {
            myDispatcher.getMulticaster().dependencyCleared(breakpointInfo.mySlaveBreakpoint);
          }
        }
      }
    }
  });
}
 

import com.intellij.xdebugger.breakpoints.XBreakpoint; //导入依赖的package包/类
public void setMasterBreakpoint(@NotNull XBreakpoint<?> slave, @NotNull XBreakpoint<?> master, boolean leaveEnabled) {
  XDependentBreakpointInfo info = mySlave2Info.get(slave);
  if (info == null) {
    addDependency((XBreakpointBase<?,?,?>)master, (XBreakpointBase<?,?,?>)slave, leaveEnabled);
  }
  else if (info.myMasterBreakpoint == master) {
    info.myLeaveEnabled = leaveEnabled;
  }
  else {
    myMaster2Info.remove(info.myMasterBreakpoint, info);
    info.myMasterBreakpoint = (XBreakpointBase)master;
    info.myLeaveEnabled = leaveEnabled;
    myMaster2Info.put((XBreakpointBase)master, info);
  }
  myDispatcher.getMulticaster().dependencySet(slave, master);
}
 

import com.intellij.xdebugger.breakpoints.XBreakpoint; //导入依赖的package包/类
public void testSerialize() throws Exception {
  XLineBreakpoint<?> master = createMaster();
  XLineBreakpoint<?> slave = createSlave();
  myDependentBreakpointManager.setMasterBreakpoint(slave, master, true);

  Element element = save();
  myDependentBreakpointManager.clearMasterBreakpoint(slave);
  //System.out.println(JDOMUtil.writeElement(element, SystemProperties.getLineSeparator()));
  load(element);

  List<XBreakpoint<?>> breakpoints = getAllBreakpoints();
  assertEquals(3, breakpoints.size());
  assertEquals("default", ((MyBreakpointProperties)breakpoints.get(0).getProperties()).myOption);
  XLineBreakpoint newMaster = (XLineBreakpoint)breakpoints.get(1);
  XLineBreakpoint newSlave = (XLineBreakpoint)breakpoints.get(2);
  assertEquals("file://master", newMaster.getFileUrl());
  assertEquals("file://slave", newSlave.getFileUrl());
  assertSame(newMaster, myDependentBreakpointManager.getMasterBreakpoint(newSlave));
  assertTrue(myDependentBreakpointManager.isLeaveEnabled(newSlave));
}
 

import com.intellij.xdebugger.breakpoints.XBreakpoint; //导入依赖的package包/类
public void testAddRemove() {
  XBreakpoint<MyBreakpointProperties> defaultBreakpoint = myBreakpointManager.getDefaultBreakpoint(MY_SIMPLE_BREAKPOINT_TYPE);
  assertSameElements(getAllBreakpoints(), defaultBreakpoint);

  XLineBreakpoint<MyBreakpointProperties> lineBreakpoint =
    myBreakpointManager.addLineBreakpoint(MY_LINE_BREAKPOINT_TYPE, "url", 239, new MyBreakpointProperties("123"));

  XBreakpoint<MyBreakpointProperties> breakpoint = myBreakpointManager.addBreakpoint(MY_SIMPLE_BREAKPOINT_TYPE, new MyBreakpointProperties("abc"));

  assertSameElements(getAllBreakpoints(), breakpoint, lineBreakpoint, defaultBreakpoint);
  assertSame(lineBreakpoint, assertOneElement(myBreakpointManager.getBreakpoints(MY_LINE_BREAKPOINT_TYPE)));
  assertSameElements(myBreakpointManager.getBreakpoints(MY_SIMPLE_BREAKPOINT_TYPE), breakpoint, defaultBreakpoint);

  myBreakpointManager.removeBreakpoint(lineBreakpoint);
  assertSameElements(getAllBreakpoints(), breakpoint, defaultBreakpoint);
  assertTrue(myBreakpointManager.getBreakpoints(MY_LINE_BREAKPOINT_TYPE).isEmpty());
  assertSameElements(myBreakpointManager.getBreakpoints(MY_SIMPLE_BREAKPOINT_TYPE), breakpoint, defaultBreakpoint);

  myBreakpointManager.removeBreakpoint(breakpoint);
  assertSameElements(getAllBreakpoints(), defaultBreakpoint);
  assertSameElements(myBreakpointManager.getBreakpoints(MY_SIMPLE_BREAKPOINT_TYPE), defaultBreakpoint);
}
 

import com.intellij.xdebugger.breakpoints.XBreakpoint; //导入依赖的package包/类
protected List<XBreakpoint<?>> getAllBreakpoints() {
  final XBreakpointBase<?,?,?>[] breakpoints = ApplicationManager.getApplication().runReadAction(new Computable<XBreakpointBase<?,?,?>[]>() {
          public XBreakpointBase<?,?,?>[] compute() {
            return myBreakpointManager.getAllBreakpoints();
          }
        });
  final List<XBreakpoint<?>> result = new ArrayList<XBreakpoint<?>>();
  for (XBreakpointBase<?, ?, ?> breakpoint : breakpoints) {
    final XBreakpointType type = breakpoint.getType();
    if (type instanceof MySimpleBreakpointType || type instanceof MyLineBreakpointType) {
      result.add(breakpoint);
    }
  }
  Collections.sort(result, new Comparator<XBreakpoint<?>>() {
    @Override
    public int compare(XBreakpoint<?> o1, XBreakpoint<?> o2) {
      return StringUtil.compare(((MyBreakpointProperties)o1.getProperties()).myOption,
                                ((MyBreakpointProperties)o2.getProperties()).myOption, true);
    }
  });
  return result;
}
 

import com.intellij.xdebugger.breakpoints.XBreakpoint; //导入依赖的package包/类
@Override
public XBreakpoint<PyExceptionBreakpointProperties> addBreakpoint(final Project project, JComponent parentComponent) {
  final PyClassTreeChooserDialog dialog = new PyClassTreeChooserDialog("Select Exception Class",
                                                                       project,
                                                                       GlobalSearchScope.allScope(project),
                                                                       new PyExceptionCachingFilter(), null);

  dialog.showDialog();

  // on ok
  final PyClass pyClass = dialog.getSelected();
  if (pyClass != null) {
    final String qualifiedName = pyClass.getQualifiedName();
    assert qualifiedName != null : "Qualified name of the class shouldn't be null";
    return ApplicationManager.getApplication().runWriteAction(new Computable<XBreakpoint<PyExceptionBreakpointProperties>>() {
      @Override
      public XBreakpoint<PyExceptionBreakpointProperties> compute() {
        return XDebuggerManager.getInstance(project).getBreakpointManager()
          .addBreakpoint(PyExceptionBreakpointType.this, new PyExceptionBreakpointProperties(qualifiedName));
      }
    });
  }
  return null;
}
 

import com.intellij.xdebugger.breakpoints.XBreakpoint; //导入依赖的package包/类
public DoUpdateIdeWithBreakpoint(
    XBreakpointManager manager,
    VirtualFile file,
    int line,
    CloudLineBreakpointProperties properties,
    Breakpoint serverBreakpoint,
    Map<String, XBreakpoint> ideBreakpoints,
    CloudDebugProcess debugProcess) {
  this.manager = manager;
  this.file = file;
  this.line = line;
  this.properties = properties;
  this.serverBreakpoint = serverBreakpoint;
  this.ideBreakpoints = ideBreakpoints;
  this.debugProcess = debugProcess;
}
 

import com.intellij.xdebugger.breakpoints.XBreakpoint; //导入依赖的package包/类
/**
 * Called when the server records a new snapshot, we find the IDE representation and disable it.
 */
public void setStateToDisabled(@NotNull Breakpoint serverBreakpoint) {
  final XBreakpoint ideBreakpoint = ideBreakpoints.get(serverBreakpoint.getId());
  if (ideBreakpoint != null
      && ideBreakpoint.getProperties() instanceof CloudLineBreakpointProperties) {
    CloudLineBreakpointProperties properties =
        (CloudLineBreakpointProperties) ideBreakpoint.getProperties();
    properties.setDisabledByServer(true);
    SwingUtilities.invokeLater(
        new Runnable() {
          @Override
          public void run() {
            ideBreakpoint.setEnabled(false);
          }
        });
  }
}
 

import com.intellij.xdebugger.breakpoints.XBreakpoint; //导入依赖的package包/类
@Override
public void stop() {
  getStateController().stopBackgroundListening();

  RunProfile profile = getXDebugSession().getRunProfile();
  if (profile instanceof CloudDebugRunConfiguration) {
    ((CloudDebugRunConfiguration) profile).setProcessState(processState);
  }

  getRepositoryValidator().restoreToOriginalState(getXDebugSession().getProject());

  XBreakpointManager breakpointManager =
      XDebuggerManager.getInstance(getXDebugSession().getProject()).getBreakpointManager();
  for (XBreakpoint bp : breakpointManager.getAllBreakpoints()) {
    com.intellij.debugger.ui.breakpoints.Breakpoint cloudBreakpoint =
        BreakpointManager.getJavaBreakpoint(bp);
    if (!(cloudBreakpoint instanceof CloudLineBreakpointType.CloudLineBreakpoint)) {
      continue;
    }
    CloudLineBreakpointType.CloudLineBreakpoint cloudLineBreakpoint =
        (CloudLineBreakpointType.CloudLineBreakpoint) cloudBreakpoint;
    cloudLineBreakpoint.setVerified(false);
    cloudLineBreakpoint.setErrorMessage(null);
    updateBreakpointPresentation(cloudLineBreakpoint);
  }
}
 

import com.intellij.xdebugger.breakpoints.XBreakpoint; //导入依赖的package包/类
public void testRegisterGetAndDelete() {
  registerMockBreakpoint(
      new String[] {"foowatch1"},
      "condition == true",
      123,
      "foo.java",
      "com.google",
      false,
      "b_id");

  assertNull(removedBp.get());
  assertNotNull(addedBp.get());
  assertContainsElements(addedBp.get().getExpressions(), "foowatch1");
  assertTrue(addedBp.get().getLocation().getLine() == 124);
  assertTrue(addedBp.get().getLocation().getPath().equals("com/google/foo.java"));
  assertTrue(addedBp.get().getCondition().equals("condition == true"));

  addedBp.get().setId("b_id");

  XBreakpoint xideBreakpoint = handler.getXBreakpoint(addedBp.get());
  assertNotNull(xideBreakpoint);
  handler.deleteBreakpoint(addedBp.get());

  assertNotNull(removedBp.get());
  assertTrue(removedBp.get().equals(addedBp.get().getId()));
}