docs: public boolean remove(Token token,
                            Transaction transaction)
                      throws ObjectManagerException
      {
          final String methodName = "remove";
          if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
              trace.entry(this, cclass, methodName, new Object[] { token,
                                                                  transaction });
  
          // Make an initial unsynchronized search for the link.
          ConcurrentSubList.Link linkToRemove = findLink(token,
                                                         transaction);
  
          boolean found = false;
          if (linkToRemove != null) { // Was a candidate found found?
              // We did not take the synchronize lock on the subList, so it could
              // have been modified.
              // Take the lock on the relevant subList so that we can mark it for
              // update.
              synchronized (headSequenceNumberLock) {
                  synchronized (linkToRemove.list) {
                      if ((linkToRemove.state == ConcurrentSubList.Link.stateAdded)
                          || (linkToRemove.state == ConcurrentSubList.Link.stateToBeAdded && linkToRemove.lockedBy(transaction))) {
                          linkToRemove.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 (!linkToRemove.isLocked())
                              linkToRemove.list.decrementAvailableSize();
  
                          found = true;
  
                          // Update the headSequenceNumber if we just removed the head of the
                          // overall list.
                          if (linkToRemove.sequenceNumber == headSequenceNumber) {
                              incrementHeadSequenceNumber(linkToRemove);
                          } // if (linkToRemove.sequenceNumber == headSequenceNumber ).
  
                          if (LinkedList.gatherStatistics)
                              removeUncontendedCount++;
                      } // if (linkToRemove.state == ConcurrentSubList.Link.stateAdded).
                  } // synchronized (linkToRemove.list).
              } // synchronized (headSequenceNumberLock).
  
              // If the link was deleted meanwhile then have anothther look, but this
              // time take a lock.
              if (!found) {
                  synchronized (headSequenceNumberLock) {
                      linkToRemove = findLink(token,
                                              transaction);
                      if (linkToRemove != null) {
                          synchronized (linkToRemove.list) {
                              linkToRemove.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 (!linkToRemove.isLocked())
                                  linkToRemove.list.decrementAvailableSize();
                              found = true;
  
                              // Update the headSequenceNumber if we just removed the head of
                              // the overall list.
                              if (linkToRemove.sequenceNumber == headSequenceNumber) {
                                  incrementHeadSequenceNumber(linkToRemove);
                              } // synchronized (headSequenceNumberLock)
  
                              if (LinkedList.gatherStatistics)
                                  removeContendedCount++;
                          } // synchronized (linkToRemove.list).
                      } // if (linkToRemove != null).
                  } // synchronized (headSequenceNumberLock).
              } // if (!found)
          } // if (linkToRemove != null).
  
          // We can release the synchronize lock on the list because we dont care if the
          // link which we are going to delete is changed before we write the log record.
          // Anyhow it is now marked as ToBeDeleted.
          // 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.
          if (linkToRemove != null) {
              try {
                  transaction.delete(linkToRemove,
                                     ConcurrentSubList.logSpaceForDelete());
  
              } catch (LogFileFullException exception) {
                  // No FFDC Code Needed, transaction.delete() has already done this.
                  linkToRemove.unRemove(this);
                  if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
                      trace.exit(this, cclass, methodName, exception);
                  throw exception;
  
                  // We should not see ObjectStoreFullException because we have preReserved 
                  // the ObjectStore space.
  //      } catch (ObjectStoreFullException exception) {
  //        // No FFDC Code Needed, transaction.delete() has already done this.
  //        linkToRemove.unRemove(this);
  //        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:912:1.26");
                  linkToRemove.unRemove(this);
                  if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
                      trace.exit(this, cclass, methodName, exception);
                  throw exception;
  
              } // catch (LogFileFullException exception).
          } // if (linkToRemove != null)
  
          if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
              trace.exit(this, cclass, methodName, new Object[] { new Boolean(found) });
          return found;
      }