Clears list parent chain as currently memorized.
542502
protected function clearEntireListParentHierarchy()
    {
        $separator = $this->getListParentSeparator();

        foreach ($this->listParents as $parent) {

            if ( ! $parent || is_string($parent) && false === strpos($parent, $separator)) {
                break;
            }

            // Unset parent at this level
            $context = $this->getModelSessionKey(
                $this->getModuleHelper()->modelSlug(get_class($parent->model))
            );

            $this->setListParentDataInMemory(null, null, $parent->relation . $separator . $parent->key, $context);
        }

        $this->setListParentDataInMemory(null, null, $this->globalSubContext());

        $this->listParentRelation  = null;
        $this->listParentRecordKey = null;
        $this->listParents         = [];
    }
1096115
def clear(self):
        
        self.reference = None
        self._pending_ref = None
        super(SimpleDependency, self).clear()
1106278
public static Object clearRef (Object[] list, Object element)
    {
        return clear(REFERENCE_COMP, list, element);
    }
1220498
def clear( self ):
        
        self.blockSignals(True)
        self.setUpdatesEnabled(False)
        for child in self.findChildren(XRolloutItem):
            child.setParent(None)
            child.deleteLater()
        self.setUpdatesEnabled(True)
        self.blockSignals(False)
446692
public static function ClearList(){
            $oThis = self::CreateInstanceIfNotExists();
            
            if(preg_match('/{list\:(.*?)}/', $oThis->sBuffer, $aMatches) == 1){
                $sListName = $aMatches[1]; 

                $iStart = strpos($oThis->sBuffer, "{list:{$sListName}}");

                if($iStart > 0)
                    $iEnd = strpos($oThis->sBuffer, "{end}", $iStart);

                if($iStart > 0 && $iEnd > 0)
                    $sList = substr($oThis->sBuffer, $iStart, $iEnd-$iStart)."{end}";

                $oThis->sBuffer = str_replace($sList, "", $oThis->sBuffer);
            }
        }
1066587
def _close_list(self):
        
        list_type = self.current_parent_element['attrs']['class']
        tag = LIST_TYPES[list_type]

        html = '</{t}>'.format(
            t=tag
        )
        self.cleaned_html += html
        self.current_parent_element['tag'] = ''
        self.current_parent_element['attrs'] = {}
1321514
public void clear() {
		streamNodes = new HashMap<>();
		virtualSelectNodes = new HashMap<>();
		virtualSideOutputNodes = new HashMap<>();
		virtualPartitionNodes = new HashMap<>();
		vertexIDtoBrokerID = new HashMap<>();
		vertexIDtoLoopTimeout  = new HashMap<>();
		iterationSourceSinkPairs = new HashSet<>();
		sources = new HashSet<>();
		sinks = new HashSet<>();
	}
1122241
def clear(self, *args):
        
        for field in self.fields_to_clear + list(args):
            setattr(self, field, None)
1122024
public void clear() {
    // Clears all keys, values and buckets linked lists.
    for (EntryImpl<K, V> entry = _mapFirst; entry != null; entry = entry._after) {
      entry._key = null;
      entry._value = null;
      entry._before = null;
      entry._next = null;
      if (entry._previous == null) { // First in bucket.
        _entries[entry._index] = null;
      } else {
        entry._previous = null;
      }
    }

    // Recycles all entries.
    if (_mapLast != null) {
      _mapLast._after = _poolFirst; // Connects to pool.
      _poolFirst = _mapFirst;
      _mapFirst = null;
      _mapLast = null;
      _size = 0;
      sizeChanged();
    }
  }
969865
def clear_list_value(self, value):
        
        # Don't go any further: this value is empty.
        if not value:
            return self.empty_value
        # Clean empty items if wanted
        if self.clean_empty:
            value = [v for v in value if v]
        return value or self.empty_value
280510
public static void clearBufferArray(WsByteBuffer[] list) {
        if (list != null) {
            for (int i = 0; i < list.length; ++i) {
                if (list[i] != null)
                    list[i].clear();
            }
        }
    }
1193846
def clear(self):
        
        self._filters = []
        self._order_by = OrderedDict()
        self._selects = set()
        self._negation = False
        self._attribute = None
        self._chain = None
        self._search = None

        return self
796825
public void clear() {
    messages = Collections.emptyList();
    isMessagesListMutable = false;
    if (builders != null) {
      for (SingleFieldBuilder<MType, BType, IType> entry :
          builders) {
        if (entry != null) {
          entry.dispose();
        }
      }
      builders = null;
    }
    onChanged();
    incrementModCounts();
  }
599234
function clear()
	{
		foreach ($this->nodes as $n) {$n->clear(); $n = null;}
		// This add next line is documented in the sourceforge repository. 2977248 as a fix for ongoing memory leaks that occur even with the use of clear.
		if (isset($this->children)) foreach ($this->children as $n) {$n->clear(); $n = null;}
		if (isset($this->parent)) {$this->parent->clear(); unset($this->parent);}
		if (isset($this->root)) {$this->root->clear(); unset($this->root);}
		unset($this->doc);
		unset($this->noise);
	}
1125199
public void clear() {
        itemBox.setValue("");
        label.removeStyleName(CssName.ACTIVE);

        Collection<Widget> values = suggestionMap.values();
        for (Widget widget : values) {
            Widget parent = widget.getParent();
            if (parent instanceof ListItem) {
                parent.removeFromParent();
            }
        }
        suggestionMap.clear();

        clearStatusText();
    }
1276329
public void clear() {
		//clear each collection to make previously returned lists empty
		for (List<V> value : map.values()) {
			value.clear();
		}
		map.clear();
	}
355030
public void clearCacheIncludingAncestors() {
		clearCache();
		if (getParentMessageSource() instanceof ReloadableResourceBundleMessageSource) {
			((ReloadableResourceBundleMessageSource) getParentMessageSource()).clearCacheIncludingAncestors();
		} else if (getParentMessageSource() instanceof org.springframework.context.support.ReloadableResourceBundleMessageSource) {
            ((org.springframework.context.support.ReloadableResourceBundleMessageSource) getParentMessageSource()).clearCacheIncludingAncestors();
		}
	}