Free resources and make this instance unusable
199362
function() {

		if (this._binds) {

			for (var i = 0, count = this._binds.length; i < count; i++) {
				this._binds[i].removeListener(this._bind_changed_listeners[i]);
			}

			this._binds = this._bind_changed_listeners = null;

		}

		this._argument.removeListener(this._argument_changed_listener);
		this._observable_listener && this._flushObservable();

		if (this._own_collection) {

			this._value.destroy();

		}

		this.suspendRefreshable();

	}
179219
public void removeLockedObject() {
        if (this != _resourceLocks._root && !this.getPath().equals("/")) {

            int size = _parent._children.length;
            for (int i = 0; i < size; i++) {
                if (_parent._children[i].equals(this)) {
                    LockedObject[] newChildren = new LockedObject[size - 1];
                    for (int i2 = 0; i2 < (size - 1); i2++) {
                        if (i2 < i) {
                            newChildren[i2] = _parent._children[i2];
                        } else {
                            newChildren[i2] = _parent._children[i2 + 1];
                        }
                    }
                    if (newChildren.length != 0) {
                        _parent._children = newChildren;
                    } else {
                        _parent._children = null;
                    }
                    break;
                }
            }

            // removing from hashtable
            _resourceLocks._locksByID.remove(getID());
            _resourceLocks._locks.remove(getPath());

            // now the garbage collector has some work to do
        }
    }
336512
def _stop_instance(self):
        """"""
        instance = self._get_instance()
        instance.stop()
        self._wait_on_instance('stopped', self.timeout)
1271175
def _sanitize_resources(cls, resources):
        """"""

        try:
            for resource in cls._loop_raw(resources):
                cls._sanitize_resource(resource)
        except (KeyError, TypeError):
            _LOGGER.debug("no shade data available")
            return None
1098027
public function removeResources ()
	{

		foreach (array_keys ($this->resources) as $name)
		{
			if (isset ($this->$name))
			{
				unset ($this->$name);
			}
		}

		unset ($this->resources);
		
	}
1061899
public synchronized void unuse() {
        assert(inUse);
        inUse = false;
        compiler = null;
        fileManager = null;
        fileManagerBase = null;
        smartFileManager = null;
        context = null;
        subTasks = null;
    }
822577
def free(self):
        """"""
        if self._ptr is None:
            return
        Gauged.array_free(self.ptr)
        FloatArray.ALLOCATIONS -= 1
        self._ptr = None
720052
public void free()
    {
        m_converter = null;
        for (int i = this.getComponentCount() - 1; i >= 0; i--)
        {
            JComponent component = (JComponent)this.getComponent(i);
            if (component instanceof Freeable)
                ((Freeable)component).free();
        }
    }
1246458
def _cleanup_factory(self):
        """"""
        _self = weakref.proxy(self)
        def wrapper():
            try:
                _self.close(timeout=0)
            except (ReferenceError, AttributeError):
                pass
        return wrapper
18386
private void releaseEglResources() {
        mReadyForFrames = false;
        if (mInputWindowSurface != null) {
            mInputWindowSurface.release();
            mInputWindowSurface = null;
        }
        if (mFullScreen != null) {
            mFullScreen.release();
            mFullScreen = null;
        }
        if (mEglCore != null) {
            mEglCore.release();
            mEglCore = null;
        }

        mSurfaceTexture = null;
    }
825575
public function free()
    {
        if ($this->locked) {
            $this->unlock();
        }
        $this->content = null;
        $this->raw = null;

        unset(static::$instances[$this->filename]);
    }
862014
def free_memory(cls, exclude=None):
        """"""

        annotations_in_memory = Annotation.__ANNOTATIONS_IN_MEMORY__

        exclude = () if exclude is None else exclude

        for annotation_cls in list(annotations_in_memory.keys()):

            if issubclass(annotation_cls, exclude):
                continue

            if issubclass(annotation_cls, cls):
                del annotations_in_memory[annotation_cls]
1340715
def cleanup_unreachable(rdf):
    """"""

    all_subjects = set(rdf.subjects())

    logging.debug("total subject resources: %d", len(all_subjects))

    reachable = find_reachable(rdf, SKOS.Concept)
    nonreachable = all_subjects - reachable

    logging.debug("deleting %s non-reachable resources", len(nonreachable))

    for subj in nonreachable:
        delete_uri(rdf, subj)
7660
def free(self, kind, name):
        
        try:
            params = self._parse(name)
            index = int(params['index'], 10)
            self._free[kind].add(index)
            assert index <= self._top[kind]
            if index == self._top[kind]:
                self._top[kind] -= 1
        except ValueError:
            # ignore failures in self._parse()
            pass
102054
function (){
    if (!instance._once) return;
    
    //Uncache the files
    ["index.js", "command.js", "argp.js", "body.js", "error.js", "wrap.js"]
    .forEach (function (filename){
      delete require.cache[__dirname + path.sep + filename];
    });
    
    //The user may have a reference to the instance so it should be freed, eg.
    //var p = argp.createParser (). If the user doesn't free the instance, eg.
    //p = null, it will retain an empty object, {}
    for (var p in instance){
      delete instance[p];
    }
    instance.__proto__ = null;
    delete instance.constructor;
  }
417645
def destroy(options = {}, &block)
      object = get_resource_ivar || find_resource

      object.destroy
      options[:location] = collection_path

      respond_with(object, options, &block)
    end
608567
def _free(self, ptr):
        
        raise NotImplementedError("%s not implemented for %s" % (self._free.__func__.__name__,
                                                                 self.__class__.__name__))