Remove a executed trade callback
@param symbol
@param callback
@return
@throws BitfinexClientException
420012
public boolean removeExecutedTradeCallback(final BitfinexExecutedTradeSymbol tradeSymbol,
			final BiConsumer<BitfinexExecutedTradeSymbol, BitfinexExecutedTrade> callback) throws BitfinexClientException {

		return tradesCallbacks.removeCallback(tradeSymbol, callback);
	}
695567
def _remove_session_callback(self, callback_obj, originator):
        ''' 

        '''
        try:
            callback_objs = [callback_obj]
            self._session_callbacks.remove(callback_obj)
            for cb, cb_objs in list(self._callback_objs_by_callable[originator].items()):
                try:
                    cb_objs.remove(callback_obj)
                    if not cb_objs:
                        del self._callback_objs_by_callable[originator][cb]
                except KeyError:
                    pass
        except KeyError:
            raise ValueError("callback already ran or was already removed, cannot be removed again")
        # emit event so the session is notified and can remove the callback
        for callback_obj in callback_objs:
            self._trigger_on_change(SessionCallbackRemoved(self, callback_obj))
1184608
public Closeable onMyWalletEvent(final BiConsumer<BitfinexAccountSymbol,Collection<BitfinexWallet>> listener) {
        walletConsumers.offer(listener);
        return () -> walletConsumers.remove(listener);
    }
766192
public Token removeFirst(Transaction transaction)
                    throws ObjectManagerException {
        final String methodName = "removeFirst";
        if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
            trace.entry(this, cclass, methodName, new Object[] { transaction });

        Link first;
        Token tokenToReturn;
        // Prevent a clash with a backing out transaction.
        synchronized (transaction.internalTransaction) {
            //TODO Having locked on the Internal transaction we should check that this still refers back to the
            //TODO callers external transaction.
            synchronized (this) {
                first = nextLink(null,
                                 transaction,
                                 getTransactionUnlockSequence());
                if (first == null) { // Is there a first element?
                    if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
                        trace.exit(this, cclass, methodName, "via java.util.NoSuchElementException");
                    throw new java.util.NoSuchElementException();
                } // (first == null).

                // Assign the tokenToReturn while we have the list locked so that the ObjectManager 
                // cannot backout this transaction and remove the link under another transaction 
                // causing this thread to see a null Token as a return value.
                tokenToReturn = first.data;

                first.requestDelete(transaction); // Mark for deletion. 

                // If the link is available to all adjust list visible length available.
                // In the case where we delete a link added by the same transaction we have no incremented 
                // the available size yet because we have not yet committed so we would not decrement it.
                if (!first.isLocked())
                    decrementAvailableSize();
            } // synchronized (this).

            // We can release the synchronize lock on the list because we don't care if the
            // link which we are going to delete is changed before we write the log record.
            // Log what we intend to do. Reserve enough spare log space so that the eventual
            // optimistic replace that removes the link from the list is certain to succeed
            // in being written as well. 

            try {
                transaction.delete(first,
                                   logSpaceForDelete());
            } catch (LogFileFullException exception) {
                // No FFDC Code Needed, transaction.delete() has already done this.
                unRemove(first);
                if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
                    trace.exit(this, cclass, methodName, exception);
                throw exception;

                // We should not see ObjectStoreFullException because the ObjectStore already 
                // holds sufficient space to guarantee deletes work.
//      } catch (ObjectStoreFullException exception) {
//        // No FFDC Code Needed, transaction.delete() has already done this.
//        unRemove(first);
//        if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
//        trace.exit(this, cclass, methodName, exception);
//        throw exception;

            } catch (InvalidStateException exception) {
                // No FFDC Code Needed.
                ObjectManager.ffdc.processException(this,
                                                    cclass,
                                                    methodName,
                                                    exception,
                                                    "1:698:1.40");
                unRemove(first);
                if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
                    trace.exit(this, cclass, methodName, exception);
                throw exception;
            } // catch (LogFileFullException exception).
        } // synchronized (transaction.internalTransaction).

        if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
            trace.exit(this, cclass, methodName, new Object[] { tokenToReturn });
        return tokenToReturn;
    }
837830
public FutureOperation unsubscribeTicker(final BitfinexTickerSymbol tickerSymbol) {
		
		final FutureOperation future = new FutureOperation(tickerSymbol);
		pendingUnsubscribes.registerFuture(future);

		lastTickerActivity.remove(tickerSymbol);
		final UnsubscribeChannelCommand command = new UnsubscribeChannelCommand(tickerSymbol);
		client.sendCommand(command);
		
		return future;
	}
1254840
public void unRegisterActivitResumeEvent(IActivityResumeCallback callback) {
        HMSAgentLog.d("unRegisterOnResume:" + StrUtils.objDesc(callback));
        resumeCallbacks.remove(callback);
    }
1365383
public FutureOperation unsubscribeExecutedTrades(final BitfinexExecutedTradeSymbol tradeSymbol) {
		final FutureOperation future = new FutureOperation(tradeSymbol);
		pendingUnsubscribes.registerFuture(future);

		final UnsubscribeChannelCommand command = new UnsubscribeChannelCommand(tradeSymbol);
		client.sendCommand(command);
		
		return future;
	}
508251
@Override
	public CommerceOrderItem removeByC_ERC(long companyId,
		String externalReferenceCode) throws NoSuchOrderItemException {
		CommerceOrderItem commerceOrderItem = findByC_ERC(companyId,
				externalReferenceCode);

		return remove(commerceOrderItem);
	}
999984
public int removeCallback(IConnectionStateCallback criteria) {
		  
		  List<IConnectionStateCallback> listCallbacks = getConnectionDetail().getConnCallbacks();
		  /**
		   * If this method is about to delete the last callback, then
		   * there are no windows left listening, so it is safe to
		   * do a hard disconnect.
		   */
		  if (listCallbacks.size() <= 1) {
			  getConnectionDetail().unHappyDisconnect();
			  listCallbacks.remove(criteria);
			  
			  DefaultConnectionList connList = (DefaultConnectionList) DefaultConnectionList.getSingleton();
			  connList.remove(this);
			  
		  } else {
			//utter a last dying gasp (DISCONNECTED status) before removing the callback.
			  //criteria.setConnectionState(ConnectState.DISCONNECTED);
			  //broadcastConnectionState(criteria);
			  listCallbacks.remove(criteria);
		  }
		  return listCallbacks.size();
	  }
1367021
public void handleEvent(final BitfinexStreamSymbol symbol) {
		final List<FutureOperation> futuresToFinish = pendingFutures
				.stream()
				.filter(f -> f.getSymbol().equals(symbol))
				.collect(Collectors.toList());
		
		pendingFutures.removeAll(futuresToFinish);
		
		futuresToFinish.forEach(f -> f.setToDone());
	}
409000
function (callback) {
        var conn = this.connection(),
            id = this._id; // use the raw ID object

        // prevent new transactions from using this connection.
        this.disconnect();

        // if commit was called with no active conn, it implies, no transact action
        // was called. as such it is an error.
        if (!conn) {
            // allow one pseudo commit even without connection, so that programmatic call of repeated commits or
            // rollbacks can be trapped.
            // note that the absence of `_id` indicates that a `.disconnect` was called.
            return callback && callback(id ? null : new AdapterError(AdapterError.TRANSACTION_UNINITIATED_ROLL));
        }

        conn.rollback(function (error) {
            // try releasing the connection.
            // if that fails then treat it as a major error.
            try {
                conn.release();
            }
            // if there was an error during release, set that as the main error.
            catch (err) {
                !error && (error = err);
            }

            // disassociate the connection from transaction and execute callback
            Transaction.disassociateConnection(conn);
            callback && callback(error);
        });
    }
1151203
function (callback) {
        var conn = this.connection(),
            id = this._id; // use the raw ID object

        // prevent new transactions from using this connection.
        this.disconnect();

        // if commit was called with no active conn, it implies, no transact action
        // was called. as such it is an error.
        if (!conn) {
            // allow one pseudo commit even without connection, so that programmatic call of repeated commits or
            // rollbacks can be trapped.
            // note that the absence of `_id` indicates that a `.disconnect` was called.
            return callback && callback(id ? null : new AdapterError(AdapterError.TRANSACTION_UNINITIATED_COMM));
        }

        // we commit the connection and then release from hash
        conn.commit(function (error) {
            // try releasing the connection.
            // if that fails then treat it as a major error.
            try {
                conn.release();
            }
            // if there was an error during release, set that as the main error.
            catch (err) {
                !error && (error = err);
            }

            // if failure to issue commit or release, then rollback
            if (error && conn.transactionConfig.rollbackOnError) {
                return conn.rollback(function () {
                    // disassociate the connection from transaction and execute callback
                    Transaction.disassociateConnection(conn);
                    callback && callback(error);
                });
            }

            // disassociate the connection from transaction and execute callback
            Transaction.disassociateConnection(conn);
            callback && callback(error);
        });
    }
651460
public FutureOperation subscribeCandles(final BitfinexCandlestickSymbol symbol) throws BitfinexClientException {
		
		final FutureOperation future = new FutureOperation(symbol);
		pendingSubscribes.registerFuture(future);
		
		final SubscribeCandlesCommand command = new SubscribeCandlesCommand(symbol);
		client.sendCommand(command);
		
		return future;
	}
23879
private void removeCallBackStruct(Hashtable map, EventCallBackStruct cb_struct) throws DevFailed {
        removeFilters(cb_struct);
        String callback_key = cb_struct.device.name().toLowerCase() +
                "/" + cb_struct.attr_name + "." + cb_struct.event_name;
        map.remove(callback_key);
    }
861437
public Closeable onAuthenticationFailedEvent(final Consumer<BitfinexAccountSymbol> listener) {
        authFailedConsumers.offer(listener);
        return () -> authFailedConsumers.remove(listener);
    }
62231
@Override
	public CPOption removeByC_ERC(long companyId, String externalReferenceCode)
		throws NoSuchCPOptionException {
		CPOption cpOption = findByC_ERC(companyId, externalReferenceCode);

		return remove(cpOption);
	}
917749
def unbind(self, callback: typing.Union[typing.Callable, AbstractFilter]):
        
        for record in self._registered:
            if record.callback == callback:
                self._registered.remove(record)