Removes the basic_block ptr from the list for "comes_from"
        if it exists. It also sets self.prev to None if it is basic_block.
488831
def delete_from(self, basic_block):
        
        if basic_block is None:
            return

        if self.lock:
            return

        self.lock = True

        if self.prev is basic_block:
            if self.prev.next is self:
                self.prev.next = None
            self.prev = None

        for i in range(len(self.comes_from)):
            if self.comes_from[i] is basic_block:
                self.comes_from.pop(i)
                break

        self.lock = False
499130
async def RemoveBlocks(self, all_):
        '''
        
        '''
        # map input types to rpc msg
        _params = dict()
        msg = dict(type='Controller',
                   request='RemoveBlocks',
                   version=5,
                   params=_params)
        _params['all'] = all_
        reply = await self.rpc(msg)
        return reply
390031
function removeBrsAdjacentToPastedBlocks( nodesData, range ) {
			var succeedingNode = range.endContainer.getChild( range.endOffset ),
				precedingNode = range.endContainer.getChild( range.endOffset - 1 );

			if ( succeedingNode )
				remove( succeedingNode, nodesData[ nodesData.length - 1 ] );

			if ( precedingNode && remove( precedingNode, nodesData[ 0 ] ) ) {
				// If preceding <br> was removed - move range left.
				range.setEnd( range.endContainer, range.endOffset - 1 );
				range.collapse();
			}

			function remove( maybeBr, maybeBlockData ) {
				if ( maybeBlockData.isBlock && maybeBlockData.isElement && !maybeBlockData.node.is( 'br' ) &&
					checkIfElement( maybeBr ) && maybeBr.is( 'br' ) ) {
					maybeBr.remove();
					return 1;
				}
			}
		}
49995
function() {
    var topBlocks = this.workspace_.getTopBlocks(false);
    for (var i = 0, block; block = topBlocks[i]; i++) {
      block.removeSelect();
    }
  }
931146
public void removeEmptyBlocks() {
        Block curr = blocklistHead;
        Block prev = null;
        int effId = 0;
        while (curr != null) {
            if (!curr.isEmpty()) {
                curr.id = effId++;
                if (prev != null) {
                    prev.nextBlock = curr;
                } else {
                    blocklistHead = curr;
                }
                prev = curr;
            }
            curr = curr.nextBlock;
        }
        if (prev != null) {
            prev.nextBlock = null;
        } else {
            blocklistHead = null;
        }
        numBlocks = effId;
    }
608567
def _free(self, ptr):
        
        raise NotImplementedError("%s not implemented for %s" % (self._free.__func__.__name__,
                                                                 self.__class__.__name__))
1348060
def remove(socket)
      ptr = ptr_for_socket(socket)
      rc = ZMQ.poller_remove(@poller_ptr, ptr)
      HasFFIDelegate.raise_zmq_err if rc == -1
      forget_socket(socket)
    end
427135
def _remove_source(self, source_name):
        

        assert source_name in self.sources, "Source %s is not part of the current model" % source_name

        source = self.sources.pop(source_name)

        if source.source_type == POINT_SOURCE:

            self._point_sources.pop(source.name)

        elif source.source_type == EXTENDED_SOURCE:

            self._extended_sources.pop(source.name)

        elif source.source_type == PARTICLE_SOURCE:

            self._particle_sources.pop(source.name)

        self._remove_child(source_name)
168481
def remove(self):
        
        if not self._is_item:
            raise TypeError("Should be called on an item, not ListNode's itself.")
        self.container.node_stack.remove(self)
286987
public void remove()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "remove", this);
    
    if(previous != null)
      previous.next = next;
    else
      list.first = next;
    
    if(next != null)
      next.previous = previous;
    else
      list.last = previous;

    previous = null;
    next = null;

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "remove", list.printList());
}
17437
private String removeBlocks(String originalSql) {
        StringBuilder cleanedSql = new StringBuilder(originalSql.length());

        Pattern regexPattern = null;
        Matcher regexMatcher = null;

        regexPattern = Pattern.compile(getRegexSkipBlockSearch(), Pattern.CASE_INSENSITIVE);
        regexMatcher = regexPattern.matcher(originalSql + "\n");

        int prevBlockEnd = 0;
        int blockStart = 0;
        int blockEnd = 0;
        String block = null;

        while (regexMatcher.find() == true) {
            blockStart = regexMatcher.start();
            blockEnd = Math.min(originalSql.length(), regexMatcher.end());

            block = originalSql.substring(blockStart, blockEnd);

            cleanedSql.append(originalSql.substring(prevBlockEnd, blockStart));

            prevBlockEnd = blockEnd;

            cleanedSql.append(fill(FILL_SYMBOL, block.length()));
        }

        cleanedSql.append(originalSql.substring(prevBlockEnd, originalSql.length()));

        return cleanedSql.toString();
    }
665737
void removeINode(Block b) {
    BlockInfo info = blocks.get(b);
    if (info != null) {
      info.inode = null;
      if (info.getDatanode(0) == null) {  // no datanodes left
        removeBlockFromMap(b); // remove block from the map
      }
    }
  }
1226601
def remove(self, block_id):
        
        with self._mutex:
            entry = self._block_map[block_id]
            self._queue.remove(entry)
927480
def del_object_from_parent(self):
        
        if self.parent:
            self.parent.objects.pop(self.ref)
911286
def remove(self, node):
        """"""
        if not isinstance(node, Node):
            raise TypeError('expecting Node instance')
        if node._list is None:
            return
        if node._list is not self:
            raise RuntimeError('node is not contained in list')
        if node._next is None:
            self._last = node._prev  # last node
        else:
            node._next._prev = node._prev
        if node._prev is None:
            self._first = node._next  # first node
        else:
            node._prev._next = node._next
        node._list = node._prev = node._next = None
        self._size -= 1
817981
def remove(self, pointer):
        
        doc = deepcopy(self.document)
        parent, obj = None, doc
        try:
            # fetching
            for token in Pointer(pointer):
                parent, obj = obj, token.extract(obj, bypass_ref=True)

            # removing
            if isinstance(parent, Mapping):
                del parent[token]

            if isinstance(parent, MutableSequence):
                parent.pop(int(token))
        except Exception as error:
            raise Error(*error.args)

        return Target(doc)
858874
def _clear_block_deco(self):
        """"""
        for deco in self._block_decos:
            self.editor.decorations.remove(deco)
        self._block_decos[:] = []