Called by the CPO framework. This method calls the
<code>release</code> on all the CpoReleasible associated with this object
545765
@Override
  public void release() throws CpoException {
    for (CpoReleasible releasible : releasibles) {
      try {
        releasible.release();
      } catch (CpoException ce) {
        logger.error("Error Releasing Callable Statement Transform Object", ce);
        throw ce;
      }
    }
  }
924262
public void release() 
    {
    	IPhynixxManagedConnection<C> con= this.connection;
        if (connection != null) {
            this.connection.removeConnectionListener(this);
        }
        this.connection = null;
        
        // return con; 
    }
943570
private void releaseCloseLock()
   {
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "releaseCloseLock");
      closeLock.readLock().unlock();
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "releaseCloseLock");
   }
276235
public void releaseAll() throws Exception {
		Collection<String> children = getAllPaths();

		Exception exception = null;

		for (String child: children) {
			try {
				release(child);
			} catch (Exception e) {
				exception = ExceptionUtils.firstOrSuppressed(e, exception);
			}
		}

		if (exception != null) {
			throw new Exception("Could not properly release all state nodes.", exception);
		}
	}
1228335
protected void release()
   {
      if (tc.isEntryEnabled()) SibTr.entry(this, tc, "release");
      if (!transmissionsRemaining)
      {
         if (tc.isDebugEnabled()) SibTr.debug(this, tc, "no more transmissions remaining - repooling");
         
         // Ensure we release the byte buffers back into the pool
         if (buffer != null)
         {
            buffer.release();
         }
         
         connection = null;
         conversation = null;
         buffer = null;
         sendListener = null;
         pool.add(this);
      }
      if (tc.isEntryEnabled()) SibTr.exit(this, tc, "release");
   }
1220278
@EventHandler(field = "_resourceContext", eventSet = ResourceContext.ResourceEvents.class, eventName = "onRelease")
    public void onRelease() {

        if (LOGGER.isDebugEnabled()) {
            LOGGER.debug("Enter: onRelease()");
        }

        for (PreparedStatement ps : getResources()) {
            try {
                ps.close();
            } catch (SQLException sqe) {
            }
        }
        getResources().clear();

        if (_connection != null) {
            try {
                _connection.close();
            } catch (SQLException e) {
                throw new ControlException("SQL Exception while attempting to close database connection.", e);
            }
        }

        _connection = null;
        _connectionDataSource = null;
        _connectionDriver = null;
    }
1311629
public synchronized void release() {
        Enumeration ptdE=threadData.keys();
        while( ptdE.hasMoreElements() ) {
            PerThreadData ptd=(PerThreadData)ptdE.nextElement();
            for (int i=ptd.current; i>=0; i--) {
                if( ptd.handlers != null && ptd.handlers[i]!=null )
                    ptd.handlers[i].release();
            }
        }
    }
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);
    }
67599
def release_lock(self):
    
    if not self._lock.acquired:
      return False
    else:
      self._lock.release()
      return True
554480
public void release() {
        HMSAgentLog.d("release");

        isResolving = false;
        resolveActivity = null;
        hasOverActivity = false;

        HuaweiApiClient client =  getApiClient();
        if (client != null) {
            client.disconnect();
        }

        synchronized (APICLIENT_LOCK) {
            apiClient = null;
        }

        synchronized (STATIC_CALLBACK_LOCK) {
            staticCallbacks.clear();
        }

        synchronized (CALLBACK_LOCK) {
            connCallbacks.clear();
        }
    }
419455
public function release()
    {
        if ($this->released) {
            throw new LockAlreadyReleasedError('The lock has already been released!');
        }

        // Invoke the releaser function given to us by the synchronization source
        // to release the lock.
        ($this->releaser)($this);
        $this->released = true;
    }
543792
public synchronized void release()
   {
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "release");

      super.release();

      if (poolManager != null)
      {
         poolManager.release(this);
      }

      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "release");
   }
853302
@Override
	public void release() {
		super.release();
		setSrcExpr(null);
		setUseRandomParamExpr(null);
		setMediaExpr(null);
		setTitleExpr(null);
		setAlternateExpr(null);
		setDisplayAlternateExpr(null);
	}
748078
protected void release(ByteArray byteArray) {

    if (byteArray instanceof PooledByteArray) {
      PooledByteArray pooledArray = (PooledByteArray) byteArray;
      if (pooledArray.release()) {
        this.byteArrayPool.release(byteArray.getBytes());
      }
    }
  }
550985
public void release(Collection<T> release)
    {
        List<Ref<T>> refs = new ArrayList<>();
        List<T> notPresent = null;
        for (T obj : release)
        {
            Ref<T> ref = references.remove(obj);
            if (ref == null)
            {
                if (notPresent == null)
                    notPresent = new ArrayList<>();
                notPresent.add(obj);
            }
            else
            {
                refs.add(ref);
            }
        }

        IllegalStateException notPresentFail = null;
        if (notPresent != null)
        {
            notPresentFail = new IllegalStateException("Could not release references to " + notPresent
                                                       + " as references to these objects were not held");
            notPresentFail.fillInStackTrace();
        }
        try
        {
            release(refs);
        }
        catch (Throwable t)
        {
            if (notPresentFail != null)
                t.addSuppressed(notPresentFail);
        }
        if (notPresentFail != null)
            throw notPresentFail;
    }
840236
def release(self):
		
		if self._locked is True:
			self._locked = False
			self._lock.release()
1254686
def release_client(self, cb):
        
        cb.stop_using()
        self._q.put(cb, True)