Perform the internal release.
511396
private void internalRelease() {

        // try {

        // setKey(null);

        // getNotifier().unlistenAll(getWaveReady());

        callAnnotatedMethod(OnRelease.class);

        if (localFacade() != null) {
            localFacade().unregister(key());
        }

        // thisObject.ready = false;

        // Shall also release all InnerComponent
        if (getInnerComponentMap().isPresent()) {

            final List<Component<?>> toRemove = new ArrayList<>();
            for (final Component<?> innerComponent : getInnerComponentMap().get().values()) {

                // Release the InnerComponent
                innerComponent.release();

                // Store it to avoid co-modification error
                toRemove.add(innerComponent);
            }

            for (final Component<?> innerComponent : toRemove) {

                // Remove it from the list
                // getInnerComponentList().get().remove(innerComponent);

                // Then remove it from map
                getInnerComponentMap().get().remove(innerComponent.key());
            }
        }

        // } catch (final JRebirthThreadException jte) {
        // LOGGER.error(COMPONENT_RELEASE_ERROR, jte);
        // }

    }
693000
def _release_lock(self):
        """"""
        if not self._has_lock():
            return

        # if someone removed our file beforhand, lets just flag this issue
        # instead of failing, to make it more usable.
        lfp = self._lock_file_path()
        try:
            rmfile(lfp)
        except OSError:
            pass
        self._owns_lock = False
1166607
public void releasePermits(ExecutionContext context, Result result) {
        releasePermits(context.permitCount(), result, context.startNanos(), clock.nanoTime());
    }
701205
@Override
	public void release() {
		super.release();
		alternate = false;
		displayAlternate = false;
		title = null;
		media = null;
	}
1214009
def release(self, device_info):
        """"""
        if _debug: DeviceInfoCache._debug("release %r", device_info)

        # this information record might be used by more than one SSM
        if device_info._ref_count == 0:
            raise RuntimeError("reference count")

        # decrement the reference count
        device_info._ref_count -= 1
469735
public function release() {
        if (!$this->releaser) {
            return;
        }

        // Invoke the releaser function given to us by the synchronization source
        // to release the lock.
        $releaser = $this->releaser;
        $this->releaser = null;
        ($releaser)($this);
    }
1061071
@Internal
    public void release() {
        Object body = getBody().orElse(null);
        releaseIfNecessary(body);
        for (ByteBufHolder byteBuf : receivedContent) {
            releaseIfNecessary(byteBuf);
        }
        for (ByteBufHolder byteBuf : receivedData.values()) {
            releaseIfNecessary(byteBuf);
        }
        if (this.body != null && this.body instanceof ReferenceCounted) {
            ReferenceCounted referenceCounted = (ReferenceCounted) this.body;
            releaseIfNecessary(referenceCounted);
        }
        for (Map.Entry<String, Object> attribute : attributes) {
            Object value = attribute.getValue();
            releaseIfNecessary(value);
        }
    }
370688
public void releasePermits(long number, Result result, long startNanos) {
        releasePermits(number, result, startNanos, clock.nanoTime());
    }
1266450
public void release() {
	this.base = null;
	current = root;
	current.body = null;
	current.after = null;
	current.before = null;
    }
1008172
def _release(self):
        """"""
        if self._in_use is None:
            # The holder is not checked out.
            return

        if not self._in_use.done():
            self._in_use.set_result(None)
        self._in_use = None

        # Deinitialize the connection proxy.  All subsequent
        # operations on it will fail.
        if self._proxy is not None:
            self._proxy._detach()
            self._proxy = None

        # Put ourselves back to the pool queue.
        self._pool._queue.put_nowait(self)
656158
def release(self):
        """"""
        base64_key = _encode(self.key)
        base64_value = _encode(self._uuid)

        txn = {
            'compare': [{
                'key': base64_key,
                'result': 'EQUAL',
                'target': 'VALUE',
                'value': base64_value
            }],
            'success': [{
                'request_delete_range': {
                    'key': base64_key
                }
            }]
        }

        result = self.client.transaction(txn)
        if 'succeeded' in result:
            return result['succeeded']
        return False
801579
public final void release()
                    throws java.io.IOException {
        if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
            trace.entry(this,
                        cclass,
                        "release");

        // Give up the lock.
        if (fileLock != null)
            fileLock.release();
        fileLock = null;

        if (fileChannel != null)
            fileChannel.close();
        fileChannel = null;

        if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
            trace.exit(this,
                       cclass,
                       "release");
    }
836498
def release(self):
        
        lock = vars(self).pop('lock', missing)
        lock is not missing and self._release(lock)
1075263
public final void release() {
		synchronized (this.LOCK) {
			if ((this.owner != null)
					&& (this.owner.get() == Thread.currentThread())) {
				this.acquire--;

				if (this.acquire == 0) {
					this.owner = null;
					this.LOCK.notify();
				}

				return;
			}

			if ((this.owner != null) && (this.owner.get() == null)) {
				this.owner = null;
				this.acquire = 0;
				this.LOCK.notify();
			}

			throw new IllegalMonitorStateException(Thread.currentThread()
					.getName()
					+ " is not the owner of the lock. "
					+ ((this.owner != null) ? ((Thread) this.owner.get())
							.getName() : "nobody") + " is the owner.");
		}
	}
146453
async def release(self) -> None:
        """"""
        if self._at_eof:
            return
        while not self._at_eof:
            await self.read_chunk(self.chunk_size)
19482
public synchronized void release()
    {
        _list=null;
        _entry=null;
        _file=null;
        _jarFile=null;
        super.release();
    }
943482
def release(*args):
    '''
    
    '''
    for i in args:
           win32api.keybd_event(VK_CODE[i],0 ,win32con.KEYEVENTF_KEYUP ,0)