Only removes top-level terms. Child terms can be removed at the parent.
438211
def remove_term(self, t):
        

        try:
            self.terms.remove(t)
        except ValueError:
            pass

        if t.section and t.parent_term_lc == 'root':
            t.section = self.add_section(t.section)
            t.section.remove_term(t, remove_from_doc=False)

        if t.parent:
            try:
                t.parent.remove_child(t)

            except ValueError:
                pass
89574
def remove_all(self, *tagnames):
        
        for tagname in tagnames:
            matching = self.findall(qn(tagname))
            for child in matching:
                self.remove(child)
114328
def remove_from_parent(self):
        """"""
        parent = self.parent
        if parent is not None:
            try:
                children = parent.children
            except AttributeError: pass
            else:
                remove_upto_once(children, self)
576763
public function clear()
    {
        $this->dom = null;
        $this->nodes = null;
        $this->parent = null;
        $this->children = null;
    }
479380
private void clearParentFilter (SiteNode parent) {
		if (parent != null) {
			parent.setFiltered(false);
			clearParentFilter(parent.getParent());
		}
	}
1287752
function removeFromSanctuary(parent) {
        var comments = queryComments(parent)
        for (var i = 0, comment; comment = comments[i++]; ) {
            if (comment.nodeValue == "ms-if") {
                var msIfEl = comment.elem
                if (msIfEl.parentNode) {
                    msIfEl.parentNode.removeChild(msIfEl)
                }
            }
        }
        parent.textContent = ""
    }
933126
private void removeEntry(CmsUUID entryId, CmsUUID parentId) {

        CmsClientSitemapEntry entry = getEntryById(entryId);
        CmsClientSitemapEntry deleteParent = getEntryById(parentId);
        removeAllChildren(entry);
        deleteParent.removeSubEntry(entry.getPosition());
        m_entriesById.remove(entryId);
        m_entriesByPath.remove(entry.getSitePath());
        // apply to detailpage table
        CmsDetailPageTable detailPageTable = getData().getDetailPageTable();
        if (detailPageTable.contains(entryId)) {
            detailPageTable.remove(entryId);
        }
    }
98422
public final void removeAll() {
        Iterator<T> it = iterator();
        while (it.hasNext()) {
            it.next();
            it.remove();
        }
    }
983512
public void removeAll()
    {
        if (m_aCurrentRecord != null)
        {
            for (int index = m_iCurrentRecordStart; index < m_iCurrentRecordEnd; index++)
            {
                int iArrayIndex = this.bufferToArrayIndex(index);
                Object bookmark = m_aCurrentRecord[iArrayIndex];
                if ((bookmark != null) && (bookmark != gEmptyCell))
                    this.freeElement(bookmark);
                m_aCurrentRecord[iArrayIndex] = gEmptyCell;   // No record here
            }
        }
        m_iCurrentRecordStart = 0;      // The first
        m_iCurrentRecordEnd = 0;        // One after the last (Use array nomenclature)
    }
115362
def drop(self, ex):
    ""
    # todo: factor out inheritance logic (for readability)
    if ex.name not in self:
      if ex.ifexists: return
      raise KeyError(ex.name)
    table_ = self[ex.name]
    parent = table_.parent_table
    if table_.child_tables:
      if not ex.cascade:
        raise table.IntegrityError('delete_parent_without_cascade',ex.name)
      self.cascade_delete(ex.name)
    else: del self[ex.name]
    if parent: parent.child_tables.remove(table_)
455674
def remove(self, parent):
        
        if parent not in self._aggregates:
            raise ValueError("Sensor %r does not have an aggregate rule "
                             "associated" % parent)
        children = self.children(parent)
        try:
            self.remove_links(parent, children)
        except Exception:
            pass
        del self._aggregates[parent]
1085393
public void removeChildren(CmsUUID parentId) {

        // create a new list to avoid concurrent modifications
        Collection<?> children = getChildren(parentId);
        // may be null when monkey clicking
        if (children != null) {
            List<Object> childIds = new ArrayList<Object>(children);
            for (Object childId : childIds) {
                removeItemRecursively(childId);
            }
        }
    }
1240844
def remove_entity_tags(self):
        '''
        
        '''
        terms_to_remove = [term for term in self._term_idx_store._i2val
                           if any([word in SPACY_ENTITY_TAGS for word in term.split()])]
        return self.remove_terms(terms_to_remove)
329714
public void removeAllChildren() {
        for (final GVRSceneObject so : headTransformObject.getChildren()) {
            final boolean notCamera = (so != leftCameraObject && so != rightCameraObject && so != centerCameraObject);
            if (notCamera) {
                headTransformObject.removeChildObject(so);
            }
        }
    }
1116336
private void removeNestedItemsFromTopLevel(ResourceMap publishRelatedResources) {

        Set<CmsResource> toDelete = Sets.newHashSet();
        for (CmsResource parent : publishRelatedResources.keySet()) {
            if (toDelete.contains(parent)) {
                continue;
            }
            for (CmsResource child : publishRelatedResources.get(parent)) {
                if (publishRelatedResources.containsKey(child)) {
                    toDelete.add(child);
                }
            }
        }
        for (CmsResource delResource : toDelete) {
            publishRelatedResources.remove(delResource);
        }
    }
1116537
def remove_term_layer(self):
        
        if self.term_layer is not None:
            this_node = self.term_layer.get_node()
            self.root.remove(this_node)
            self.term_layer = None

        if self.header is not None:
            self.header.remove_lp('terms')
1156700
function() {
        var child;
        var root = this.vectorRoot;
        if (root) {
            while (child = root.firstChild) {
                root.removeChild(child);
            }
        }
        root = this.textRoot;
        if (root) {
            while (child = root.firstChild) {
                root.removeChild(child);
            }
        }
        if (this.indexer) {
            this.indexer.clear();
        }
    }