Release any acquired resources.
555095
protected void localRelease()
    {
        super.localRelease();
        if (_attrs != null)
            _attrs.clear();
        _cr = null;
        _dataSource = null;
        _defaultValue = null;
        _optionsDataSource = null;
        _disabled = false;
        _orientation = null;
        _orientVal = null;
        _realName = null;
        _style = null;
        _class = null;
        _labelStyle = null;
        _labelStyleClass = null;

        _repIdx = 0;
        _repCurItem = null;
    }
419206
function() {
      this.emit('acquiring');
      const onAcquisitionError = (err) => {
        logger.debug('Resource acquisition failed with error', err);
        this.emit('failed', err);
        this.handle('failed');
      };
      const onAcquired = (o) => {
        this.item = o;
        this.waitInterval = 0;
        if (this.item.on) {
          this.disposeHandle = this.item.once(disposalEvent || 'close', (err) => {
            logger.info('Resource lost, releasing', err);
            this.emit('lost');
            this.transition('released');
          });
          this.item.once('error', (err) => {
            logger.info('Resource error', err);
            this.transition('failed');
          });
          this.item.on('drain', () => {
            this.emit('drain');
          });
        }
        this.transition('acquired');
      };
      const onException = (ex) => {
        logger.debug('Resource acquisition failed with exception', ex);
        this.emit('failed', ex);
        this.handle('failed');
      };
      factory()
        .then(onAcquired, onAcquisitionError)
        .catch(onException);
    }
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
872351
protected void releaseTable() {
		// set the counters back
		this.numBuckets = 0;
		
		if (this.buckets != null) {
			for (MemorySegment bucket : this.buckets) {
				this.availableMemory.add(bucket);
			}
			this.buckets = null;
		}
	}
959297
def Release(self):
    
    if self.locked:
      query = ("UPDATE locks SET lock_expiration=0, lock_owner=0 "
               "WHERE lock_expiration=%s "
               "AND lock_owner=%s "
               "AND subject_hash=unhex(md5(%s))")
      args = [self.expires, self.lock_token, self.subject]
      self.store.ExecuteQuery(query, args)
      self.locked = False
406151
@Override
    protected void releaseResources() {
        super.releaseResources();
        PropertySpec.current.remove();
        PropertySpec.currentSpec.remove();
        if (this.state != State.DESTROYED) {
            ParamValueLoaderService.clearParamTree();
            sessionManager = null;
            this.allParams = null;
            this.extraParams = null;
            this.requestParamCache = null;
            this.router = null;
            this.handler = null;
            // xio impl might need this this.request = null;
            // xio impl might need this this.response = null;
            this.flash = null;
            this.session = null;
            this.controllerInstances = null;
            this.result = null;
            this.uploads.clear();
            ActionContext.clearLocal();
        }
        this.state = State.DESTROYED;
    }
487395
protected void releaseTable() {
		// set the counters back
		this.numBuckets = 0;
		
		if (this.buckets != null) {
			for (int i = 0; i < this.buckets.length; i++) {
				this.availableMemory.add(this.buckets[i]);
			}
			this.buckets = null;
		}
	}
1016185
def release_pool(self):
        """"""
        if self._current_acquired > 0:
            raise PoolException("Can't release pool: %d connection(s) still acquired" % self._current_acquired)
        while not self._pool.empty():
            conn = self.acquire()
            conn.close()
        if self._cleanup_thread is not None:
            self._thread_event.set()
            self._cleanup_thread.join()
        self._pool = None
1266135
def free_resources(self):
        '''  '''
        if not self.is_stopped():
            logger.info("Freeing resources: %s" % self.get_transfer_id())
            self.stop(True)
148145
def release(self, connection):
        """"""
        self._checkpid()
        if connection.pid == self.pid:
            idx = connection._pattern_idx
            self._in_use_connections[idx].remove(connection)
            self._available_connections[idx].append(connection)
413625
def deallocate(self):
        """"""
        if self._domain is not None:
            domain_delete(self._domain, self.logger)
        if self._network is not None:
            self._network_delete()
        if self._storage_pool is not None:
            self._storage_pool_delete()
        if self._hypervisor is not None:
            self._hypervisor_delete()
1098027
public function removeResources ()
	{

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

		unset ($this->resources);
		
	}
1173873
public void releaseDbResources()
    {
        Iterator it = m_rsIterators.iterator();
        while (it.hasNext())
        {
            ((OJBIterator) it.next()).releaseDbResources();
        }
    }
310155
def release(self) -> None:
        """"""
        if self._value >= self._initial_value:
            raise ValueError("Semaphore released too many times")
        super(BoundedSemaphore, self).release()
299998
def release(self):
        
        if not self.acquired:
            return False

        os.close(self.fd)

        if os.path.exists(self.path):
            os.remove(self.path)

        self.acquired = False
        return True
801243
def _finalCleanup(self):
        
        for conn in self._connections.values():
            conn.releaseConnectionResources()
        assert not self._connections
1362337
public void release() {

        this.parent = null;

        this.id = null;
        this.facesJspId = null;
        this.created = false;
        this.bodyContent = null;
        this.isNestedInIterator = false;
        _nextChildIndex = 0;
    }