docs: private void recover(ReadableLogRecord logRecord) throws LogCorruptedException, InternalLogException
      {
          if (tc.isEntryEnabled())
              Tr.entry(tc, "recover", new Object[] { this, logRecord });
  
          // If the parent recovery log instance has experienced a serious internal error then prevent
          // this operation from executing.
          if (_recLog.failed())
          {
              if (tc.isEntryEnabled())
                  Tr.exit(tc, "recover", this);
              throw new InternalLogException(null);
          }
  
          try
          {
              // Read the record type field. 
              short recordType = logRecord.getShort();
  
              if (recordType == RecoverableUnitImpl.RECORDTYPEDELETED)
              {
                  // This record is a marker to indicate that the recoverable unit was deleted at this point
                  // in its lifecycle (ie its lifecycle in relation to the data contained in the recovery
                  // log before and after the deletion record). In order to support re-use of a recoverable
                  // unit identity before a keypoint operaiton occurs and old data is deleted from the recovery
                  // log, we must delete the existing recoverable unit. This ensures that it does not get
                  // confused with later instance that uses the same identity value.
  
                  if (tc.isDebugEnabled())
                      Tr.debug(tc, "This is a DELETION record. Deleting RecoverableUnit from map");
                  _recLog.removeRecoverableUnitMapEntries(_identity);
                  // PI68664 - if the RU being deleted contains any RU Sections then the DataItem recovery will have
                  // caused payload to be added which increments the _totalDataSize of the log.
                  // We must set this back down here.
                  this.removeDuringLogRead();
  
              }
              else
              {
                  // This record is not a deletion record. It contains new data to be recovered for the recoverable
                  // unit. Decode the record accordingly.
                  if (tc.isDebugEnabled())
                      Tr.debug(tc, "This is a NORMAL record. Decoding contents");
  
                  // Determine the identity of the next section. Ideally, we would decode the entire
                  // recoverable unit section from within the RecoverableUnitSectionImpl class, rather
                  // than decoding part of it here. Unfortunatly, we must determine if this class 
                  // already knows about this recoverable unit section and if not create it and place
                  // it into the _recoverableUnitSections map. This means that we must decode both its
                  // identity and 'singleData' flag.
                  int recoverableUnitSectionIdentity = logRecord.getInt();
  
                  while (recoverableUnitSectionIdentity != END_OF_SECTIONS)
                  {
                      // This is a real recoverable unit section record and not just the marker
                      // to indicate that there are no further recoverable unit sections stored
                      // within the record.
                      if (tc.isDebugEnabled())
                          Tr.debug(tc, "Recovering RecoverableUnitSection '" + recoverableUnitSectionIdentity + "'");
  
                      // Read the 'record type' field. Currently this is not used but is provided for future compatibility.
                      // It would be used to distinguish between a 'normal' write and a 'delete' write. The latter would be used
                      // to remove the recoverable unit section from the recovery log. Ignore this field for now.
                      logRecord.getShort();
  
                      // Determine if this section can hold multiple data items.
                      final boolean singleData = logRecord.getBoolean();
  
                      if (tc.isDebugEnabled())
                      {
                          if (singleData)
                          {
                              Tr.debug(tc, "RecoverableUnitSection can hold only a single data item");
                          }
                          else
                          {
                              Tr.debug(tc, "RecoverableUnitSection can hold multiple data items");
                          }
                      }
  
                      // Determine if the identity has been encountered before and either lookup or create
                      // the corrisponding recoverable unit section.
                      RecoverableUnitSectionImpl recoverableUnitSection = (RecoverableUnitSectionImpl) _recoverableUnitSections.get(new Integer(recoverableUnitSectionIdentity));
  
                      if (recoverableUnitSection == null)
                      {
                          if (tc.isDebugEnabled())
                              Tr.debug(tc, "RecoverableUnitSection " + recoverableUnitSectionIdentity + " has not been encountered before. Creating.");
  
                          try
                          {
                              recoverableUnitSection = (RecoverableUnitSectionImpl) createSection(recoverableUnitSectionIdentity, singleData);
                          } catch (RecoverableUnitSectionExistsException exc)
                          {
                              // This exception should not be generated in practice as we are in the single threaded
                              // recovery process and have already checked that the RecoverableUnitSection does not
                              // exist. If this exception was actually generated then ignore it - it simply indicates
                              // that the creation has failed as the section has already been created. Given that
                              // creation is the goal, this does not seem to be a problem.
                              FFDCFilter.processException(exc, "com.ibm.ws.recoverylog.spi.RecoverableUnitImpl.recover", "713", this);
                          } catch (InternalLogException exc)
                          {
                              FFDCFilter.processException(exc, "com.ibm.ws.recoverylog.spi.RecoverableUnitImpl.recover", "717", this);
                              if (tc.isDebugEnabled())
                                  Tr.debug(tc, "An unexpected exception occured when attempting to create a new RecoverableUnitSection");
                              throw exc; // Caught in this method further down.
                          }
                      }
                      else
                      {
                          if (tc.isDebugEnabled())
                              Tr.debug(tc, "RecoverableUnitSection " + recoverableUnitSectionIdentity + " has been encountered before.");
                      }
  
                      // Direct the recoverable unit section to recover further information from the log record.
                      recoverableUnitSection.recover(logRecord);
  
                      // Since this information has been recovered from disk it has been "written to the log". Record this fact
                      // so that any subsequent deletion of the recoverable unit will cause a deletion record to be written
                      // to disk.
                      _storedOnDisk = true;
  
                      // Retrieve the identity of the next recoverable unit section. This may be the 'END_OF_SECTIONS'
                      // marker and hence indicate that there are no further recoverable unit sections to process
                      // in this record.
                      recoverableUnitSectionIdentity = logRecord.getInt();
                  }
              }
          } catch (LogCorruptedException exc)
          {
              FFDCFilter.processException(exc, "com.ibm.ws.recoverylog.spi.RecoverableUnitImpl.recover", "740", this);
              if (tc.isDebugEnabled())
                  Tr.debug(tc, "A LogCorruptedException exception occured reconstructng a RecoverableUnitImpl");
              _recLog.markFailed(exc); /* @MD19484C */
              if (tc.isEntryEnabled())
                  Tr.exit(tc, "recover", exc);
              throw exc;
          } catch (InternalLogException exc)
          {
              FFDCFilter.processException(exc, "com.ibm.ws.recoverylog.spi.RecoverableUnitImpl.recover", "747", this);
              if (tc.isDebugEnabled())
                  Tr.debug(tc, "An InternalLogException exception occured reconstructng a RecoverableUnitImpl");
              _recLog.markFailed(exc); /* @MD19484C */
              if (tc.isEntryEnabled())
                  Tr.exit(tc, "recover", exc);
              throw exc;
          } catch (Throwable exc)
          {
              FFDCFilter.processException(exc, "com.ibm.ws.recoverylog.spi.RecoverableUnitImpl.recover", "753", this);
              if (tc.isDebugEnabled())
                  Tr.debug(tc, "An exception occured reconstructng a RecoverableUnitImpl");
              _recLog.markFailed(exc); /* @MD19484C */
              if (tc.isEntryEnabled())
                  Tr.exit(tc, "recover", "InternalLogException");
              throw new InternalLogException(exc);
          }
  
          if (tc.isEntryEnabled())
              Tr.exit(tc, "recover");
      }