Remove the stickies bound to the nodes in the list
767124
function _loop2(i) {
                var node = nodeList[i];
    
                stickies.some(function (sticky) {
                    if (sticky._node === node) {
                        sticky.remove();
                        return true;
                    }
                });
            }
739515
public void clear ()
    {
        for (int icount = _items.size(); icount > 0; icount--) {
            DirtyItem item = _items.remove(0);
            item.clear();
            _freelist.add(item);
        }
    }
672885
void clear(int list) {
		int last = getLast(list);
		while (last != nullNode()) {
			int n = last;
			last = getPrev(n);
			freeNode_(n);
		}
		m_lists.setField(list, 0, -1);
		m_lists.setField(list, 1, -1);
		setListSize_(list, 0);
	}
1370427
function removeBindings() {
      for (var i = 0; i < this._c.length; i++) {
        this.unbind(this._c[i].children);
      }
    }
911692
protected void removeContainerTags() {
	tags.removeOfType(TreeMember.class);
	tags.removeOfType(RootContainer.class);
	tags.removeOfType(TreeDepth.class);
    }
532303
def clear(self):
        ''''''
        self._size = 0
        self._level = 1
        self._head = Node('HEAD', None,
                          [None]*SKIPLIST_MAXLEVEL,
                          [1]*SKIPLIST_MAXLEVEL)
941185
function removeFromList(i, L, R) {
    R[L[i]] = R[i];
    L[R[i]] = L[i];
    R[i] = i;
    L[i] = i;
}
1136306
function () {
		var annotation = this,
			chart = this.chart,
			allItems = chart.annotations.allItems,
			index = allItems.indexOf(annotation);

		if (index > -1) {
			allItems.splice(index, 1);
		}

		each(['title', 'shape', 'group'], function (element) {
			if (annotation[element]) {
				annotation[element].destroy();
				annotation[element] = null;
			}
		});

		annotation.group = annotation.title = annotation.shape = annotation.chart = annotation.options = null;
	}
561417
def clear(self, keep_attrs=False):
        
        if not keep_attrs:
            for a in (self.graph_attr, self.node_attr, self.edge_attr):
                a.clear()
        del self.body[:]
1101454
function removeUnusedProperties(node) {
    if (typeof node !== "object") {
        return;
    }
    ["position"].forEach(function (key) {
        if (node.hasOwnProperty(key)) {
            delete node[key];
        }
    });
}
869009
private void cleanupLists(PrefixKey key) {
    // Remove expired list entries. Keep track of the last list removed.
    NavigableMap<PrefixKey, CacheValue<Object>> head = prefixMap.headMap(key, true).descendingMap();
    Iterator<Entry<PrefixKey, CacheValue<Object>>> headItr = head.entrySet().iterator();
    Entry<PrefixKey, CacheValue<Object>> last = null;

    while (headItr.hasNext()) {
      Entry<PrefixKey, CacheValue<Object>> entry = headItr.next();
      if (isExpired(entry.getValue()) && key.isParent(entry.getKey())) {
        last = entry;
        headItr.remove();
      }
    }

    // If a list was removed, check its contained items for expiration.
    if (last != null) {
      SortedMap<PrefixKey, CacheValue<GoogleCloudStorageItemInfo>> prefix =
          getPrefixSubMap(itemMap, last.getKey());
      prefix.entrySet().removeIf(entry -> isExpired(entry.getValue()));
    }
  }
676247
def clear(self):
        """"""
        for n in self.nodes():
            if self.nodes[n]["type"] == "variable":
                self.nodes[n]["value"] = None
            elif self.nodes[n]["type"] == "function":
                self.nodes[n]["func_visited"] = False
1323879
def clear_marking(self):
        """"""
        if self.marktag:
            try:
                self.canvas.delete_object_by_tag(self.marktag, redraw=False)
            except Exception:
                pass

        if self.markhltag:
            try:
                self.canvas.delete_object_by_tag(self.markhltag, redraw=False)
            except Exception:
                pass

        self.treeview.clear()  # Clear table too
        self.w.nshown.set_text('0')
        self.fitsimage.redraw()
13554
function unsetSticky (sticky, position) {
  const comp = sticky.component
  const element = sticky.element
  position = position ? position + '' : sticky.prePosition
  element.style.position = position
  element.style.marginTop = sticky.preMarginTop || ''
  element.style.top = sticky.preTop || ''
  element.classList.remove('jud-sticky')
  if (comp.stickyPlaceholder) {
    const parent = comp.stickyPlaceholder.parentNode
    parent.insertBefore(element, comp.stickyPlaceholder)
    parent.removeChild(comp.stickyPlaceholder)
    comp.stickyPlaceholder = null
  }
}
737272
function removeValueFromList(list, value) {
    for (var i = list.length - 1; i >= 0; i--) {
        if (list[i] == value) {
            return list.splice(i, 1); // remove from array
        }
    }
    return false;
}
869173
protected void clearItemIdMaps() {
		if (getScratchMap() != null) {
			getScratchMap().remove(CUSTOM_IDS_TO_NODE_SCRATCH_MAP_KEY);
			getScratchMap().remove(ALL_IDS_TO_INDEX_SCRATCH_MAP_KEY);
			getScratchMap().remove(EXPANDED_IDS_TO_INDEX_MAPPING_SCRATCH_MAP_KEY);
		}
	}
866631
def clear(self):
        '''
        
        '''

        self.tags = []
        '''the current list of tags which have been opened in the XML file'''

        self.chars = {}
        '''the chars held by each tag, indexed by their tag name'''

        self.attribs = {}
        '''the attributes of each tag, indexed by their tag name'''

        self.handler = None
        ''' the method which will handle the current tag, and the data currently in the class '''

        self.piece = PieceTree.PieceTree()
        '''the class tree top'''

        self.isDynamic = False
        '''Indicator of whether the current thing being processed is a dynamic'''

        self.data["note"] = None
        self.data["direction"] = None
        self.data["expression"] = None
        self.data["degree"] = None
        self.data["frame_note"] = None
        self.data["staff_id"] = 1
        self.data["voice"] = 1
        self.data["handleType"] = ""