Close the unpickler and frees the resources such as the unpickle stack and memo table.
509080
public void close() {
		if(stack!=null)	stack.clear();
		if(memo!=null) memo.clear();
		if(input!=null)
			try {
				input.close();
			} catch (IOException e) {
			}
	}
187617
public function close()
    {
        if (!$this->freed) {
            $this->freed = true;
            if (isset($this->bev)) {
                $this->bev->free();
            }
            $this->bev = null;
            //$this->eventLoop->interrupt();
        }
        if ($this->pool) {
            $this->pool->detach($this);
        }
    }
510728
function () {
                this._removeOldStates();
                ariaUtilsEvent.removeListener(window, "unload", this._saveStateCB);
                this._storage.setItem(this._STORAGE_KEY, stateMemory);
                this._storage.$dispose();
                this._storage = null;
            }
313681
def close(self):
        

        for key in self.masklist.keys():
            self.masklist[key] = None
        self.masklist = {}
344608
def stop(self):
        
        if self._stack:
            try:
                self._stack.teardown()
            except Exception:
                self.fatal(sys.exc_info())

        super().stop()
693612
def clear(self):
        
        with self._hlock:
            self.handlers.clear()
        with self._mlock:
            self.memoize.clear()
1028556
def close(self):
        
        self.closed = True
        self._flush_bits_to_stream()
        self._stream.close()
1334536
def close(self):
        
        self._dll.JLINKARM_Close()

        if self._lock is not None:
            del self._lock
            self._lock = None

        return None
840798
def close(self):
        
        if self._resource is not None:
            self._pool.put_resource(self._resource)
            self._resource = None
            self._pool = None
203960
def close(self):
        
        files = self.__dict__.get("files")
        for _key, value in iter_multi_items(files or ()):
            value.close()
1354297
@Override
  public void close()
  {
    super.close();
    facts.clear();
    indexAndOffsets.clear();

    if (selectors != null) {
      selectors.clear();
    }

    Closer c = Closer.create();
    aggBuffers.forEach(c::register);
    try {
      c.close();
    }
    catch (IOException e) {
      throw new RuntimeException(e);
    }
    aggBuffers.clear();
  }
540914
public void dispose ()
    {
        // make sure the stream is stopped
        if (_state != AL10.AL_STOPPED) {
            stop();
        }

        // delete the source and buffers
        _source.delete();
        for (Buffer buffer : _buffers) {
            buffer.delete();
        }

        // remove from manager
        _soundmgr.removeStream(this);
    }
1193282
def close(self):
        ''''''
        if self._save_filename:
            self._cookie_jar.save(
                self._save_filename,
                ignore_discard=self._keep_session_cookies
            )
732789
void close() {
    final ContextStop contextStop = new ContextStopImpl(this.identifier);
    for (final EventHandler<ContextStop> stopHandler : this.contextStopHandlers) {
      stopHandler.onNext(contextStop);
    }
  }
1208461
def _close(self):
        

        if self.stream:
            try:
                if not self.stream.closed:
                    # Flushing probably isn't technically necessary, but it feels right
                    self.stream.flush()
                    self.stream.close()
            finally:
                self.stream = None
721547
def close(self):
        
        # This may not be absolutely necessary, but it is safe.
        # It's the closest thing to a close() method.
        if self._dev is not None:
            usb.util.dispose_resources(self._dev)
            self._dev = None
891249
def close(self):
        
        self._handle.remove()
        self._node_monitor_event_handle.remove()
        self._allocation_table.close()