Removes the specified loader.
556081
private synchronized void removeLoader(ClassLoader loader)
  {
    int i;
    for (i = _loaders.size() - 1; i >= 0; i--) {
      WeakReference<ClassLoader> ref = _loaders.get(i);
      ClassLoader refLoader = ref.get();

      if (refLoader == null)
        _loaders.remove(i);
      else if (refLoader == loader)
        _loaders.remove(i);
    }
  }
116874
def _remove(self, xer, primary):
        
        if xer in primary:
            notifier = primary.pop(xer)
            notifier.shutdown()
1170850
def _unload(self, ):
        
        try:
            self.uninit()
        except Exception as e:
            log.exception("Unload failed!")
            raise errors.PluginUninitError('%s' % e)
        self.__status = self.__UNLOADED
247646
function () {
        var i, entries = registry.entries()
        for (i in entries) {
          if (entries[i].type && entries[i].type !== 'unload')
            remove(entries[i].element, entries[i].type)
        }
        win[detachEvent]('onunload', cleanup)
        win.CollectGarbage && win.CollectGarbage()
      }
329232
def remove(self, level, logger):
        
        self.config[level].discard(logger)
        logger.close()
243592
private void close(ClassLoader classLoader) {
        synchronized (configCache) {
            ConfigWrapper config = configCache.remove(classLoader);
            if (config != null) {
                Set<String> applicationNames = config.getApplications();
                for (String app : applicationNames) {
                    appClassLoaderMap.remove(app);
                }

                config.close();
            }
        }
    }
356393
def unload(self):
        
        self.is_loaded = False
        for evt in self._event_cache:
            self.context.unregister(
                evt['event'], evt['callback'], evt['selector'])
        self._event_cache = {}
906065
function(script) {
			script.module.uninstall();
			if (script.stopped || (!script.callback && Loader.loading !== script)) {
				script.loader.load(script);
				Loader.next();
				return;
			}
			this.loaded[script.id] = script;
			delete this.pending[script.id];
			Loader.loading = null;
			Loader.next();
		}
49767
def unload(self):
        

        if self.loaded:
            self.loaded = False
            self._openalprpy_lib.dispose(self.alpr_pointer)
256497
def remove(self, force=False):
        
        if force:
            _fs, filename = opener.parse(self.uri)
            _fs.remove(filename)
        self.uri = None
970242
public void removeLRU() {
        int removeCount = (int) Math.max((size() * trimFactor), 1);

        Iterator<Map.Entry<K, V>> entries = entrySet().iterator();
        while ((removeCount--) > 0 && entries.hasNext()) {
            entries.next();
            entries.remove();
        }
    }
251721
public static void clearClassLoader(final ClassLoader classLoader) {
        BeanPropertiesCache.clear(classLoader);
        final Iterator<Map.Entry<CacheKey, String>> it = CLASS_CACHE.entrySet().iterator();
        while (it.hasNext()) {
            final CacheKey key = it.next().getKey();
            if (key.loader == classLoader) {
                it.remove();
            }
        }
    }
360411
public void classLoaderDestroy(DynamicClassLoader loader)
  {
    Object resource = _resourceRef.get();
    if (resource == null)
      return;
    
    Method destroy = CloseListener.getDestroyMethod(resource.getClass());

    if (destroy == null)
      return;
    
    try {
      destroy.invoke(resource, (Object []) null);
    } catch (Throwable e) {
      log.log(Level.WARNING, e.toString(), e);
    }
  }
408543
public void unload() {
        clear();
        offset = 0;
        limit = 0;
        itemCount = 1;
        completed = false;
        if (isEnableRecycling()) {
            recycleManager.unload();
        }
    }
739191
public static void removeEnvironmentListener(EnvLoaderListener listener,
                                            ClassLoader loader)
  {
    for (; loader != null; loader = loader.getParent()) {
      if (loader instanceof EnvironmentClassLoader) {
        ((EnvironmentClassLoader) loader).removeListener(listener);
        return;
      }
    }

    _globalEnvironmentListeners.remove(listener);
  }
739384
public void removeHandler() {

        clearShowing();
        if (m_overHandlerRegistration != null) {
            m_overHandlerRegistration.removeHandler();
            m_overHandlerRegistration = null;
        }
        m_target = null;
    }
1131437
def delete(self):
        """"""
        # set 'loaded' first ... so if we have to bail, we know we tried.
        self.loaded = True
        if not hasattr(self.manager, "delete"):
            return
        self.manager.delete(self)