Remove a child deferred reference data to this scope.
490551
public synchronized void removeDeferredReferenceData(DeferredReferenceData refData) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            Tr.entry(tc, "removeDeferredReferenceData", "this=" + this, refData);
        }

        if (deferredReferenceDatas != null) {
            deferredReferenceDatas.remove(refData);
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            Tr.exit(tc, "removeDeferredReferenceData");
        }
    }
828192
public void uninit() {
        log.debug("Un-init scope");
        for (IBasicScope child : children.keySet()) {
            if (child instanceof Scope) {
                ((Scope) child).uninit();
            }
        }
        stop();
        setEnabled(false);
        if (hasParent()) {
            if (parent.hasChildScope(name)) {
                parent.removeChildScope(this);
            }
        }
    }
1047242
public void deleteReference() {
    if (decreaseRefCount() == 0) {
      T deleted;
      synchronized (this) {
        deleted = mValue;
        mValue = null;
      }
      mResourceReleaser.release(deleted);
      removeLiveReference(deleted);
    }
  }
146580
public boolean removeReference(ServiceReference<T> reference) {
        synchronized (elementMap) {
            ConcurrentServiceReferenceElement<T> element = elementMap.remove(reference);
            if (element == null) {
                return false;
            }

            elementSet.remove(element);
            return true;
        }
    }
624733
protected void removePendingRequestForType(ResourceRequestInfo req) {
    Context c = getContext(req.getType());
    Object removed = Utilities.removeReference(c.pendingRequests, req);
    if (removed != null) {
      c.pendingRequestCount--;
    }
  }
4234
def remove_external_references(self):
        
        for ex_ref_node in self.node.findall('externalReferences'):
            self.node.remove(ex_ref_node)
252734
public <T> void cleanNullReferencesAll() {
		for (Map<Object, Reference<Object>> objectMap : classMaps.values()) {
			cleanMap(objectMap);
		}
	}
416998
def destroy(self, recursive):
        
        for transition_id in list(self.transitions.keys()):
            self.remove_transition(transition_id, destroy=recursive)
        for data_flow_id in list(self.data_flows.keys()):
            self.remove_data_flow(data_flow_id, destroy=recursive)
        for scoped_variable_id in list(self.scoped_variables.keys()):
            self.remove_scoped_variable(scoped_variable_id, destroy=recursive)
        for state_id in list(self.states.keys()):
            if recursive:
                self.remove_state(state_id, recursive, force=True, destroy=recursive)
            else:
                del self.states[state_id]
        super(ContainerState, self).destroy(recursive)
12061
private static void purgeQueue() {

        ChronoReference cref;

        while ((cref = (ChronoReference) QUEUE.poll()) != null) {
            for (ChronoReference test : CHRONOS) {
                if (test.name.equals(cref.name)) {
                    CHRONOS.remove(test);
                    break;
                }
            }
        }

    }
904385
def clear_relation(cls):
        
        for k, v in cls.properties.items():
            if isinstance(v, ReferenceProperty):
                if hasattr(v, 'collection_name') and hasattr(v.reference_class, v.collection_name):
                    delattr(v.reference_class, v.collection_name)

                    if isinstance(v, OneToOne):
                        #append to reference_class._onetoone
                        del v.reference_class._onetoone[v.collection_name]
865596
def delete_by_scope(scope, lock_name, custom_headers:nil)
      response = delete_by_scope_async(scope, lock_name, custom_headers:custom_headers).value!
      nil
    end
192675
function(reject) {
      let index = _.indexOf(this.deferred, reject);
      if (index >= 0) {
        this.deferred.splice(index, 1);
      }
    }
974574
def child_removed(self, child):
        
        super(AbstractItemView, self).child_removed(child)
        self.get_member('_items').reset(self)
455720
def __clear_references(self, request, remove_request=True):
        """"""
        # remove request itself
        if remove_request:
            with self.__requests:
                self.__requests.pop(request.id_)
        # remove request type specific references
        if not request.success:
            with self.__pending_subs:
                self.__pending_subs.pop(request.id_, None)
            with self.__pending_controls:
                self.__pending_controls.pop(request.id_, None)
819593
function () {
                var me = this;
                if (!me._dataInPromise) {
                    me._dataInPromise = new Promise(function (resolve) {
                        me._dataInResolve = resolve;
                    }).then(function (data) {
                        delete me._dataInPromise;
                        delete me._dataInResolve;
                        return data;
                    });
                }
                return me._dataInPromise;
            }
1209959
function removeReferral(client) {
    if (! client) return;

    client.unbind();
    var indexOf = pendingReferrals.indexOf(client);
    if (indexOf >= 0) {
      pendingReferrals.splice(indexOf, 1);
    }
  }
1125510
function deleteScope(scope){
    var key, handlers, i;

    for (key in _handlers) {
      handlers = _handlers[key];
      for (i = 0; i < handlers.length; ) {
        if (handlers[i].scope === scope) handlers.splice(i, 1);
        else i++;
      }
    }
  }