docs: void recover(ReadableLogRecord logRecord) throws LogCorruptedException,InternalLogException
    {
      if (tc.isEntryEnabled()) Tr.entry(tc, "recover", new Object[] {logRecord, this});
  
      // 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", "InternalLogException");
        throw new InternalLogException(null);
      }
  
      try
      {
        // Determine the number of data items to be recovered this time.
        int numDataItems = logRecord.getInt();
  
        if (tc.isDebugEnabled()) Tr.debug(tc, "Recovering '" + numDataItems + "' data items");
  
        // Reconstruct each data item in memory.
        for (int d = 0; d < numDataItems; d++)
        {
            if (tc.isDebugEnabled()) Tr.debug(tc, "Recovering data item '" + d + "'");
          
            DataItem dataItem = null;
            
            if (_singleData)
            {
                // Check to see if we are replacing something, or if there is no
                // data in this section.
                if (_writtenData.size() > 0)                  /* @MD19840A*/
                {                                             /* @MD19840A*/
                    dataItem = (DataItem)_writtenData.get(0); /* @MD19840A*/
                }                                             /* @MD19840A*/
  
                if (dataItem == null)                         /* @MD19840A*/
                {                                             /* @MD19840A*/
                    
                    // This recoverable unit section may hold only piece of data. This
                    // must be held by the special DataItem subclass, SingleDataItem. 
                    // Create the wrapper to hold this information.
                    dataItem = new SingleDataItem(_storageMode, logRecord, this);
                    _writtenData.add(dataItem);               /* @MD19994M*/
                }                                             /* @MD19840A*/
                else                                          /* @MD19840A*/
                {                                             /* @MD19840A*/
                    // Replace the existing data in the SingleDataItem /* @MD19840A*/
                    ((SingleDataItem)dataItem).setData(logRecord);     /* @MD19840A*/
                    _writtenData.set(0, dataItem);            /* @MD19994A*/
                }                                             /* @MD19840A*/
            }
            else
            {
                // This recoverable unit section may hold an arbitrary number of pieces
                // of data. These are all cached within the standard DataItem class.
                // Create the wrapper to hold this information.
                dataItem = new DataItem(_storageMode, logRecord, this);
  
                // As this recoverable unit seciton may hold an arbirary number of
                // data items, add the wrapper to the end of the list.
                _writtenData.add(dataItem);        
            }
  
           // However this information is stored inside the recoverable unit, 'dataItem' is the
           // last data block to be added to the recoverable unit section. Preserve this reference
           // in '_lastData' in order to have quick access to it from the lastData() method.
           _lastDataItem = dataItem;
        }
      }
      catch (InternalLogException exc)
      {
        FFDCFilter.processException(exc, "com.ibm.ws.recoverylog.spi.RecoverableUnitSectionImpl.recover", "876", this);
        if (tc.isDebugEnabled()) Tr.debug(tc, "An InternalLogException occured reconstructng a RecoverableUnitSectionImpl");
        _recLog.markFailed(exc); /* @MD19484C*/
        if (tc.isEntryEnabled()) Tr.exit(tc, "recover", "LogCorruptedException");
        throw new LogCorruptedException(exc);
      }
      catch (Throwable exc)
      {
        FFDCFilter.processException(exc, "com.ibm.ws.recoverylog.spi.RecoverableUnitSectionImpl.recover", "884", this);
        if (tc.isDebugEnabled()) Tr.debug(tc, "An exception occured reconstructng a RecoverableUnitSectionImpl");
        _recLog.markFailed(exc); /* @MD19484C*/
        if (tc.isEntryEnabled()) Tr.exit(tc, "recover", "InternalLogException");
        throw new InternalLogException(exc);
      }
      if (tc.isEntryEnabled()) Tr.exit(tc, "recover");
    }