Removes an event for a ref (reference),
320166
def remove_event(self, ref):
        
        # is this reference one which has been setup?
        if ref in self._refs:
            self._refs[ref].remove_callback(ref)
1036587
protected void unsetItemInterface(ServiceReference<ItemInterface> ref) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
            SibTr.entry(tc, "unsetItemInterface", ref);
        itemInterfaceRef.setReference(ref);
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
            SibTr.exit(tc, "unsetItemInterface");

    }
1063603
@Trivial
    public void unsetSslSupport(ServiceReference<ChannelFactoryProvider> ref) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
            Tr.entry(this, tc, "unsetSslSupport", new Object[] { ref.getProperty("type"), ref });
        }
        // see if its for the same service ref, if yes then destroy
        if (_sslFactoryProvider.getReference() == ref)
        {
            if (_isSSLChain) {
                if (_isChainStarted)
                    performAction(destroyChainAction);
            }

        }
        if (_sslFactoryProvider.unsetReference(ref)) {
            _isSSLEnabled = false;
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            Tr.exit(tc, "unsetSslSupport", _isSSLEnabled);
        }

    }
4234
def remove_external_references(self):
        
        for ex_ref_node in self.node.findall('externalReferences'):
            self.node.remove(ex_ref_node)
1267893
protected void unsetContextProvider(ServiceReference<JCAContextProvider> ref) {
        contextProviders.removeReference((String) ref.getProperty(JCAContextProvider.TYPE), ref);
    }
735009
function (refpath) {
            var bindings = this._bindings[refpath];
            if (bindings) {
                for (var bind in bindings) {
                    if (bindings.hasOwnProperty(bind)) {
                        var moduleDescription = this._getModuleDataDescription(refpath, bind);
                        this.json.removeListener(moduleDescription.container, moduleDescription.property, bindings[bind][1], true);
                    }
                }
                delete this._bindings[refpath];
            }
        }
982210
private synchronized void disableDeferredReferenceData() {
        deferredReferenceDataEnabled = false;
        if (parent != null && deferredReferenceDatas != null) {
            parent.removeDeferredReferenceData(this);
            deferredReferenceDatas = null;
        }
    }
43486
protected void removeStartedApplication(ServiceReference<Application> ref) {
        String appName = (String) ref.getProperty(NAME);
        lock.writeLock().lock();
        try {
            appStates.remove(appName);
        } finally {
            lock.writeLock().unlock();
        }
    }
376958
protected void removeAction() {
        component.removeEventListener(eventName, this);

        if (component.getAttribute(attrName) == this) {
            component.removeAttribute(attrName);
        }
    }
284960
function removeEvent(element, eventName, eventIndex) {
  if (element.__bunny_event_handlers !== undefined && element.__bunny_event_handlers.handlers[eventIndex] !== undefined) {
    element.removeEventListener(eventName, element.__bunny_event_handlers.handlers[eventIndex]);
    delete element.__bunny_event_handlers.handlers[eventIndex];
    // do not decrement counter, each new event handler should have next unique index
  }
  return null;
}
33547
def removeEventListener(self, event: str, listener: _EventListenerType
                            ) -> None:
        
        self._remove_event_listener(event, listener)
530205
def drop_callback_reference(self, subscription):
        
        if subscription not in self.__subscriptions:
            raise workflows.Error(
                "Attempting to drop callback reference for unknown subscription"
            )
        if not self.__subscriptions[subscription]["unsubscribed"]:
            raise workflows.Error(
                "Attempting to drop callback reference for live subscription"
            )
        del self.__subscriptions[subscription]
1300466
public void removeReference(Reference reference) throws GreenPepperServerException
    {
        if(!references.contains(reference))
        {
            throw new GreenPepperServerException( GreenPepperServerErrorKey.REFERENCE_NOT_FOUND, "Reference not found");
        }

        references.remove(reference);
        reference.setSpecification(null);
    }
1253023
def remove_value(self, name):
        """"""
        ns = self._get_reference_namespace(name)
        ns.pop(name)
630189
function removeReference(name, opposite) {
  const ref = this.references[name]
  _.unset(this.references, name)
  if (ref.opposite !== undefined) {
    if (opposite) {
      _.unset(ref.type.references, ref.opposite)
    } else {
      _.unset(ref.type.references[ref.opposite], 'opposite')
    }
  }
}
927480
def del_object_from_parent(self):
        
        if self.parent:
            self.parent.objects.pop(self.ref)
1212436
private static Ref removeCompanionOpt(List<Ref> refs, Ref cmp) {
        Iterator<Ref> iter;
        Ref ref;

        iter = refs.iterator();
        while (iter.hasNext()) {
            ref = iter.next();
            if (ref.module.equals(cmp.module) && Util.eq(ref.variant, cmp.variant)) {
                iter.remove();
                return ref;
            }
        }
        return null;
    }