Unregister stream wrapper.
421708
public static function unregister(string $protocol): bool
    {
        unset(self::$partitions[$protocol]);

        $wrappers = stream_get_wrappers();
        if (!in_array($protocol, $wrappers)) {
            throw new Exception(
                "Protocol '$protocol' has not been registered yet"
            );
        }

        return stream_wrapper_unregister($protocol);
    }
663075
protected void unregister(IEventListener listener) {
        log.debug("unregister - listener: {}", listener);
        if (listeners.remove(listener)) {
            listenerStats.decrement();
        }
    }
1177613
public function unregister()
    {
        foreach (array_reverse($this->previousLoaders) as $previousLoader) {
            spl_autoload_register($previousLoader, true);
        }

        spl_autoload_unregister(array($this, 'loadClass'));
    }
618211
public static function unregisterStreamWrapperClass()
    { 
        $unregisterFunction = self::getStreamWrapperUnregisterFunction();
        if (!isset(self::$protocolName)) {
            throw new \RuntimeException(
                    sprintf('Scheme name not found for %s', __CLASS__));
        }

        @$unregisterFunction(self::$protocolName);
    }
61437
def remove_stream(self, ssrc):
        
        _srtp_assert(lib.srtp_remove_stream(self._srtp[0], htonl(ssrc)))
484003
def purge(self):
        
        self.channel.purge_stream(self.stream_id, remove_definition=False, sandbox=None)
781824
private int unregisterHandles() {
        int cancelledHandles = 0;
        for (;;) {
            AcceptorOperationFuture future = cancelQueue.poll();
            if (future == null) {
                break;
            }

            // close the channels
            for (SocketAddress a : future.getLocalAddresses()) {
                H handle = boundHandles.remove(a);
                
                if (handle == null) {
                    continue;
                }

                try {
                    close(handle);
                    wakeup(); // wake up again to trigger thread death
                } catch (Throwable e) {
                    ExceptionMonitor.getInstance().exceptionCaught(e);
                } finally {
                    cancelledHandles++;
                }
            }

            future.setDone();
        }

        return cancelledHandles;
    }
849205
def unregister(self):
        """"""
        pdu = RegisterForeignDevice(0)
        pdu.pduDestination = self.bbmdAddress

        # send it downstream
        self.request(pdu)

        # change the status to unregistered
        self.registrationStatus = -2

        # clear the BBMD address and time-to-live
        self.bbmdAddress = None
        self.bbmdTimeToLive = None
1021434
def unregisterHandler(self, fh):

        

        try:
            self.fds.remove(fh)

        except KeyError:
            pass

        self.lock.acquire()

        try:
            self.data.rollover() # rollover data on close.

        finally:
            self.lock.release()

        if self.closing and not self.fds:
            self.data.close()
1126225
def unregister(self, event):
        
        if self.running:
            raise RuntimeError("Can't unregister while running")
        self._handlers.pop(event, None)
344121
void unregistered() {
        try {
            if (!m_alreadyStopped) {
                try {
                    safeStopping();
                } finally {
                    try {
                        m_writeStream.shutdown();
                    } finally {
                        m_readStream.shutdown();
                    }
                }
            }
        } finally {
            networkLog.debug("Closing channel " + m_threadName);
            try {
                m_sc.close();
            } catch (IOException e) {
                networkLog.warn(e);
            }
        }
    }
732061
def unregisterStdOut(func):
    
    try:
        sys.stdout.hooks.remove(weakref.ref(func))
    except (AttributeError, ValueError):
        pass
397466
def unregister(self, filter_name):
        
        if filter_name in self.filter_list:
            self.filter_list.pop(filter_name)
1045171
def close(self):
        """"""
        self.flush()
        self.stream.close()
        logging.StreamHandler.close(self)
248429
void unregister(ResourceMonitorImpl monitorImpl)
   {
      Set<Entry<WatchKey, ResourceMonitorImpl>> entrySet = keys.entrySet();
      Iterator<Entry<WatchKey, ResourceMonitorImpl>> iterator = entrySet.iterator();
      while (iterator.hasNext())
      {
         Entry<WatchKey, ResourceMonitorImpl> next = iterator.next();
         if (next.getValue() == monitorImpl)
         {
            next.getKey().cancel();
            iterator.remove();
         }
      }
   }
813748
static void unregister(Object value) {
        if (value != null) {
            Map<Object, Object> m = getRegistry();
            if (m != null) {
                m.remove(value);
                if (m.isEmpty()) {
                    REGISTRY.remove();
                }
            }
        }
    }
798637
def UnregisterFlowProcessingHandler(self, timeout=None):
    """"""
    if self.flow_processing_request_handler_thread:
      self.flow_processing_request_handler_stop = True
      self.flow_processing_request_handler_thread.join(timeout)
      if self.flow_processing_request_handler_thread.isAlive():
        raise RuntimeError("Flow processing handler did not join in time.")
      self.flow_processing_request_handler_thread = None