  // $Id: varia.txt 2073 2006-06-19 12:33:28Z  $
  
  
  Various modifications made to Cache. This file will be discarded soon.
  
  
   /**
     * Replicates the update to all members, and use locks at each member to ensure transactional serializability.
     * When a lock in a member cannot be acquired, a LockingException will be thrown. Typically the caller will
     * then abort the transaction (releasing all locks) and retry.<p>
     * This call can be one of many inside the same transaction, or it may be the only one. In the first case, the
     * caller is responsible to call commit() or rollback() once the transaction is done. In the latter case, the
     * transaction can be committed by setting <code>commit</code> to true.<br>
     * A transaction (Xid) is always associated with the current thread. If this call is invoked, and there is no
     * transaction associated with the current thread, a default transaction will be created. Otherwise the current
     * transaction will be used.
     * @param key The key to be set. Needs to be serializable. Can be null.
     * @param value The value to be set. Needs to be serializable. Can be null.
     * @param sync_timeout Max number of milliseconds to wait for all responses. Note that this needs to be higher
     *                     than <code>lock_acquisition_timeout</code>. 0 means to wait forever for all responses.
     * @param lock_acquisition_timeout Number of milliseonds to wait until a lock becomes available. Needs to be lower
     *                                 than <code>sync_timeout</code>. 0 means to wait forever. <em>0 will block
     *                                 forever in case of deadlocks. Once we have deadlock detection in place,
     *                                 this parameter may be deprecated.</em>
     * @param lock_lease_timeout       Number of milliseonds until a lock is released automatically (if not released
     *                                 before). Not currently used.
     * @param commit                   If true the transaction will be committed after this call if the call was successful.
     * @return Object The previous value associated with the given key, or null if none was associated
     * @exception LockingException Throw when one or more of the members failed acquiring the lock within
     *                             <code>lock_acquisition_timeout</code> milliseconds
     * @exception TimeoutException Thrown when one or more of the members didn't send a response. LockingExceptions
     *                             take precedence over TimeoutExceptions, e.g. if we have both locking and timeout
     *                             exceptions, a LockingException will be thrown.
     */
    Object put(Object key, Object value, long sync_timeout, 
               long lock_acquisition_timeout, long lock_lease_timeout,
               boolean commit) throws LockingException, TimeoutException;
