code: public void performRecovery(ObjectManagerState objectManagerState)
                      throws ObjectManagerException
      {
          final String methodName = "performRecovery";
          if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
              trace.entry(this,
                          cclass,
                          methodName,
                          new Object[] { objectManagerState,
                                        logicalUnitOfWork,
                                        new Integer(transactionState),
                                        token,
                                        new Integer(managedObjectBytes.length) });
  
          // Recover the ManagedObject from its serialized bytes.
          ManagedObject replacementManagedObject = ManagedObject.restoreFromSerializedBytes(managedObjectBytes,
                                                                                            objectManagerState);
  
          // Replace the object using its original transaction.
          Transaction transactionForRecovery = objectManagerState.getTransaction(logicalUnitOfWork);
          ManagedObject existingManagedObject = token.getManagedObject();
          if (existingManagedObject == null) {
              // The object may have already been deleted from the ObjectStore,
              // so create a dummy object to keep the transaction happy.
              // The Token will have the ObjecStore and storedObjectIdentifier so the the correct delete in the
              // ObjectStore can take place.
              DummyManagedObject dummyManagedObject = new DummyManagedObject("Created by TransactionReplaceLogRecord.performRecovery()");
              dummyManagedObject.state = ManagedObject.stateReady;
              dummyManagedObject.owningToken = token;
              existingManagedObject = token.setManagedObject(dummyManagedObject);
              existingManagedObject.state = ManagedObject.stateReady;
          } // if(existingManagedObject == null).
  
          transactionForRecovery.lock(existingManagedObject);
          token.setManagedObject(replacementManagedObject); // Revert to the restored managed object.
  
          transactionForRecovery.replace(existingManagedObject); // Redo the replace.
          // No need to reset the transaction state because Replace can only be executed before
          // the transaction is prepared.
          // transactionForRecovery.internalTransaction.resetState(transactionState);
  
          if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
              trace.exit(this,
                         cclass,
                         methodName);
      }
docs: Called to perform recovery action during a warm start of the ObjectManager.
  
  @param objectManagerState of the ObjectManager performing recovery.
  @throws ObjectManagerException