code: protected synchronized void replaceFromCheckpoint(ManagedObject managedObject,
                                                        byte[] serializedBytes,
                                                        Transaction transaction)
                      throws ObjectManagerException {
          final String methodName = "replaceFromCheckpoint";
          if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
              trace.entry(this, cclass, methodName, new Object[] { managedObject,
                                                                  new Integer(serializedBytes.length),
                                                                  transaction });
  
          // Make the ManagedObject ready for a replace operation.
          // Nothing went wrong during forward processing!
          managedObject.preReplace(transaction);
  
          // Only persistent objects are recovered from a checkpoint.
          setState(nextStateForInvolvePersistentObjectFromCheckpoint);
          // The object is now included in the transaction.
          includedManagedObjects.put(managedObject.owningToken, managedObject);
  
          // The ManagedObject was read from the log, give it a low log
          // and ManagedObject sequence number so that any later operation will supercede this one.
          // The loggedSerialisedBytes will be unchanged, possibly null for this Token.
          // If there already a logSequenceNumber known for this token it must have been put
          // there after the checkpoint start and has already been superceded.
          if (!logSequenceNumbers.containsKey(managedObject.owningToken)) {
              logSequenceNumbers.put(managedObject.owningToken,
                                     new Long(0));
              managedObjectSequenceNumbers.put(managedObject.owningToken,
                                               new Long(0));
              // Remember what we originally logged in case we commit this version of the ManagedObject.
              // Replacements are not written to the ObjectStore for a checkpoint becauise that would
              // remove any before image which we would need if the object backed out.
              loggedSerializedBytes.put(managedObject.owningToken
                                        , serializedBytes
                              );
          } // if (!logSequenceNumbers.containsKey(token)).
  
          // Redrive the postReplace method for the object.
          managedObject.postReplace(transaction, true);
  
          if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
              trace.exit(this, cclass, methodName);
      }
docs: Recover a Replace operation from a checkpoint.
  
  @param managedObject recovered from a checkpoint.
  @param serializedBytes representing the serialized form of the ManagedObject originally logged.
  @param transaction the external Transaction.
  @throws ObjectManagerException