Remove any `c:tx[c:rich]` child, or do nothing if not present.
339957
def remove_tx_rich(self):
        
        matches = self.xpath('c:tx[c:rich]')
        if not matches:
            return
        tx = matches[0]
        self.remove(tx)
1031410
def remove_child(self, child):
        
        child.set_model(None)
        if self._model:
            row = self.childItems.index(child)
            parentindex = self._model.index_of_item(self)
            self._model.removeRow(row, parentindex)
        else:
            self.childItems.remove(child)
370204
def _del_cached_value(self, xblock):
        """"""
        # pylint: disable=protected-access
        if hasattr(xblock, '_field_data_cache') and self.name in xblock._field_data_cache:
            del xblock._field_data_cache[self.name]
456532
def remove_child(self, child_pid, reorder=False):
        """"""
        super(PIDNodeOrdered, self).remove_child(child_pid)
        child_relations = self._resolved_pid.child_relations.filter(
            PIDRelation.relation_type == self.relation_type.id).order_by(
                PIDRelation.index).all()
        if reorder:
            for idx, c in enumerate(child_relations):
                c.index = idx
329396
def remove_override(self, key):
        """"""
        keys = key.split('.')
        if len(keys) > 1:
            raise NotImplementedError
        elif key in self.overrides:
            del self.overrides[key]
            self._uncache(key)
249003
public void removeReader(TransactionImpl tx, Object obj)
    {
        checkTimedOutLocks();

        Identity oid = new Identity(obj, getBroker());
        String oidString = oid.toString();
        String txGuid = tx.getGUID();
        removeReaderInternal(oidString, txGuid);
    }
1282400
def _delete(self, c, context, hm):
        """"""
        pools = hm.get("pools", [])

        for pool in pools:
            pool_id = pool.get("pool_id")
            self._dissociate(c, context, hm, pool_id)

        self._delete_unused(c, context, hm)
530941
def OnRemoveCards(self, removedcards):
        """"""
        parentnode = self.root
        for cardtoremove in removedcards:
            (childCard, cookie) = self.GetFirstChild(parentnode)
            while childCard.IsOk():
                if self.GetItemText(childCard) == \
                        toHexString(cardtoremove.atr):
                    self.Delete(childCard)
                (childCard, cookie) = self.GetNextChild(parentnode, cookie)
        self.Expand(self.root)
        self.EnsureVisible(self.root)
        self.Repaint()
980261
def _uncheck_descendant(self, item):
        """"""
        children = self.get_children(item)
        for iid in children:
            self.change_state(iid, "unchecked")
            self._uncheck_descendant(iid)
702927
public void performClear(Transaction tx, Resource... contexts) {
        if(notNull(contexts)) {
            for (int i = 0; i < contexts.length; i++) {
                if (notNull(contexts[i])) {
                    graphManager.delete(contexts[i].stringValue(), tx);
                } else {
                    graphManager.delete(DEFAULT_GRAPH_URI, tx);
                }
            }
        }else{
            graphManager.delete(DEFAULT_GRAPH_URI, tx);
        }
    }
1361602
def child_removed(self, child):
        
        layout = self.layout
        if child.widget is not None:
            layout.removeArrangedSubview(child.widget)
            layout.removeSubview(child.widget)
1208480
def remove(self):
        
        self.__bulk.add_delete(self.__selector, _DELETE_ALL,
                               collation=self.__collation)
1223674
def remove_from_parent(self):
        '''
        
        '''
        if self.parent:
            self.parent._children.remove(self)
            self.parent._invalidate_time_caches()
            self.parent = None
708253
def remove_child(self, child):
        
        self.children.remove(child)
        child.parent = None

        if self.view and self.view.is_loaded:
            self.view.dispatch({
                'name': 'remove',
                'selector': '#' + child.id
            })
568450
def remove_value(self, keys, value):
        
        self.count -= 1
        if not self.key:
            keys = self.__value_reverse_mapping[value]
            del self.__value_reverse_mapping[value]
        if len(keys) == 0:
            self.values.remove(value)
        else:
            key = keys[0]
            index = bisect.bisect_left(self.children, TreeNode(key, reversed=self.reversed))
            assert index != len(self.children) and self.children[index].key == key
            self.children[index].remove_value(keys[1:], value)
            if self.tree_node_updated:
                self.tree_node_updated(self.children[index])
            if self.children[index].count == 0:
                del self.children[index]
                if self.child_removed:
                    self.child_removed(self, index)
1022869
def remove(self):
        
        if self.parent is not None:
            for i, child in enumerate(self.parent.children):
                if id(child) == id(self):
                    self.parent.remove_child(i)
                    self.parent = None
                    break
884432
def remove_child(self, index):
        
        if index < 0:
            index = index + len(self)
        self.__children = self.__children[0:index] + self.__children[(index + 1):]