Clear the breakpoint given by the number.

@param bpno
The breakpoint number to remove.
@return The breakpoint object removed, or null.
497898
public Breakpoint clearBreakpoint(int bpno)
	{
		Breakpoint old = breakpoints.remove(bpno);

		if (old != null)
		{
			PStm stmt = findStatement(old.location.getFile(), old.location.getStartLine());

			if (stmt != null)
			{
				BreakpointManager.setBreakpoint(stmt, new Breakpoint(stmt.getLocation()));
			} else
			{
				PExp exp = findExpression(old.location.getFile(), old.location.getStartLine());
				assert exp != null : "Cannot locate old breakpoint?";
				BreakpointManager.setBreakpoint(exp, new Breakpoint(exp.getLocation()));
			}
		}

		return old; // null if not found
	}
1373284
public static base_response clear(nitro_service client, nsstats resource) throws Exception {
		nsstats clearresource = new nsstats();
		clearresource.cleanuplevel = resource.cleanuplevel;
		return clearresource.perform_operation(client,"clear");
	}
725532
def Clear(self):
    
    self._RemoveImportHook()
    if self._cookie is not None:
      native.LogInfo('Clearing breakpoint %s' % self.GetBreakpointId())
      native.ClearConditionalBreakpoint(self._cookie)
      self._cookie = None

    self._completed = True
252545
public T pop() {
		final int max = stack.size() - 1;
		if (max < 0) {
			throw new NoSuchElementException();
		}
		return stack.remove(max);
	}
877285
def set_or_clear_breakpoint(self):
        """"""
        if self.data:
            editor = self.get_current_editor()
            editor.debugger.toogle_breakpoint()
263731
@VisibleForTesting
    void clear() {
        this.segmentUpdates.clear();
        this.newSegments.clear();
        this.newSegmentNames.clear();
        this.newTruncationPoints.clear();
        this.processedCheckpoint = false;
        resetNewSequenceNumber();
    }
132254
public static base_response clear(nitro_service client) throws Exception {
		nsacls6 clearresource = new nsacls6();
		return clearresource.perform_operation(client,"clear");
	}
592166
def remove_breakpoint(self, py_db, filename, breakpoint_type, breakpoint_id):
        '''
        
        '''
        file_to_id_to_breakpoint = None

        if breakpoint_type == 'python-line':
            breakpoints = py_db.breakpoints
            file_to_id_to_breakpoint = py_db.file_to_id_to_line_breakpoint

        elif py_db.plugin is not None:
            result = py_db.plugin.get_breakpoints(py_db, breakpoint_type)
            if result is not None:
                file_to_id_to_breakpoint = py_db.file_to_id_to_plugin_breakpoint
                breakpoints = result

        if file_to_id_to_breakpoint is None:
            pydev_log.critical('Error removing breakpoint. Cannot handle breakpoint of type %s', breakpoint_type)

        else:
            try:
                id_to_pybreakpoint = file_to_id_to_breakpoint.get(filename, {})
                if DebugInfoHolder.DEBUG_TRACE_BREAKPOINTS > 0:
                    existing = id_to_pybreakpoint[breakpoint_id]
                    pydev_log.info('Removed breakpoint:%s - line:%s - func_name:%s (id: %s)\n' % (
                        filename, existing.line, existing.func_name.encode('utf-8'), breakpoint_id))

                del id_to_pybreakpoint[breakpoint_id]
                py_db.consolidate_breakpoints(filename, id_to_pybreakpoint, breakpoints)
                if py_db.plugin is not None:
                    py_db.has_plugin_line_breaks = py_db.plugin.has_line_breaks()

            except KeyError:
                pydev_log.info("Error removing breakpoint: Breakpoint id not found: %s id: %s. Available ids: %s\n",
                    filename, breakpoint_id, dict_keys(id_to_pybreakpoint))

        py_db.on_breakpoints_changed(removed=True)
467218
private void clear(Object caller, int version) {
        assert mutation_in_progress(caller, version);
        _buf_limit = 0;
        for (int ii=0; ii<_blocks.size(); ii++) {
            _blocks.get(ii).clearBlock();
            // _blocks.get(ii)._idx = -1; this is done in clearBlock()
        }
        bbBlock first = _blocks.get(0);
        first._idx = 0;                        // cas: 26 dec 2008
        first._offset = 0;
        first._limit = 0;
        _next_block_position = 1;
        return;
    }
831408
public final long clear(long numberToClear)
    {
        long numberRemainingToClear = numberToClear;
        // Avoid locking the Map by looking at the subMaps indivdually starting at a
        // random point in the sequence, so as not to disturb the distribution.
        int index = new java.util.Random(Thread.currentThread().hashCode()).nextInt(subMaps.length);
        int numberEmpty = 0;
        while (numberRemainingToClear > 0 && numberEmpty < subMaps.length) {
            java.util.Map subMap = subMaps[index];
            synchronized (subMap) {
                if (!subMap.isEmpty()) {
                    java.util.Iterator iterator = subMap.entrySet().iterator();
                    iterator.next();
                    iterator.remove();
                    numberRemainingToClear--;
                    numberEmpty = 0;
                } else {
                    numberEmpty++;
                } // if (subMap.isEmpty()).
            } // synchronized (subMap).

            index++;
            if (index == subMaps.length)
                index = 0;
        } // while (numberRemainingToClear > 0).

        return numberToClear - numberRemainingToClear;
    }
420144
public static void clearEvidence(Network bn, int node) {
        if (bn.isEvidence(node)) {
            bn.clearEvidence(node);
            bn.updateBeliefs();
        }
    }
22253
public static void clearEvidence(ProbabilisticNetwork bn, String nodeName)
            throws ShanksException {
        ProbabilisticNode node = (ProbabilisticNode) bn.getNode(nodeName);
        ShanksAgentBayesianReasoningCapability.clearEvidence(bn, node);
    }
759153
public boolean remove()
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "remove");

        boolean reply = iterator.remove();

        if (reply)
        {
            size--;
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "remove", "reply=" + reply);
        return reply;
    }
912629
public static <T extends Throwable> T clearTrace(T exception) {
        requireNonNull(exception, "exception");
        exception.setStackTrace(EMPTY_STACK_TRACE);
        return exception;
    }
1069503
def __postCallAction_codebp(self, event):
        

        # If the breakpoint was accidentally hit by another thread,
        # pass it to the debugger instead of calling the "post" callback.
        #
        # XXX FIXME:
        # I suppose this check will fail under some weird conditions...
        #
        tid = event.get_tid()
        if tid not in self.__paramStack:
            return True

        # Remove the code breakpoint at the return address.
        pid     = event.get_pid()
        address = event.breakpoint.get_address()
        event.debug.dont_break_at(pid, address)

        # Call the "post" callback.
        try:
            self.__postCallAction(event)

        # Forget the parameters.
        finally:
            self.__pop_params(tid)
1163945
public Entry remove(Entry removePointer)
  {
    if (tc.isEntryEnabled())
      SibTr.entry(tc, "remove", new Object[] { removePointer });
    
    Entry removedEntry = null;
    
    //check that the entry to be removed is not null and is in this list
    if(contains(removePointer))
    {         
      //call the internal unsynchronized remove method on the entry to be removed.
      removedEntry = removePointer.remove();
    }
    else //if the entry is not found in this list, throw a runtime exception
    {
      SIErrorException e = new SIErrorException(
        nls.getFormattedMessage(
          "INTERNAL_MESSAGING_ERROR_CWSIP0001",
          new Object[] {
            "com.ibm.ws.sib.processor.utils.linkedlist.LinkedList",
            "1:291:1.3" },
          null));
      
      FFDCFilter.processException(
        e,
        "com.ibm.ws.sib.processor.utils.linkedlist.LinkedList.remove",
        "1:297:1.3",
        this);
        
      SibTr.exception(tc, e);   
      SibTr.error(tc, "INTERNAL_MESSAGING_ERROR_CWSIP0001",
        new Object[] {
          "com.ibm.ws.sib.processor.utils.linkedlist.LinkedList",
          "1:304:1.3" });   

      if (tc.isEntryEnabled())
        SibTr.exit(tc, "remove", e);
      
      throw e;
    }
    
    if (tc.isEntryEnabled())
      SibTr.exit(tc, "remove", removedEntry);
    
    //return the object which was removed
    return removedEntry;
  }
1316625
def erase_all_breakpoints(self):
        

        # This should be faster but let's not trust the GC so much :P
        # self.disable_all_breakpoints()
        # self.__codeBP       = dict()
        # self.__pageBP       = dict()
        # self.__hardwareBP   = dict()
        # self.__runningBP    = dict()
        # self.__hook_objects = dict()

##        # erase hooks
##        for (pid, address, hook) in self.get_all_hooks():
##            self.dont_hook_function(pid, address)

        # erase code breakpoints
        for (pid, bp) in self.get_all_code_breakpoints():
            self.erase_code_breakpoint(pid, bp.get_address())

        # erase page breakpoints
        for (pid, bp) in self.get_all_page_breakpoints():
            self.erase_page_breakpoint(pid, bp.get_address())

        # erase hardware breakpoints
        for (tid, bp) in self.get_all_hardware_breakpoints():
            self.erase_hardware_breakpoint(tid, bp.get_address())