docs: private java.io.DataInputStream readNextLogRecord()
                      throws ObjectManagerException
      {
          if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
              trace.entry(this,
                          cclass,
                          "readNextLogRecord",
                          new Object[] { new Long(sectorValidatedInputStream.currentPage),
                                        new Integer(sectorValidatedInputStream.currentByte) });
  
          byte[] logRecordBytes = null;
          short partLength = 0;
          byte partType = FileLogOutput.PART_First;
          byte multiPartID = 0;
          java.io.DataInputStream logRecordDataInputStream = null;
  
          // Keep reading until we have assembled a complete LogRecord.
          while (logRecordDataInputStream == null) {
              try {
                  // Read the part header.
                  partType = dataInputStream.readByte();
                  switch (partType) {
                      case FileLogOutput.PART_Padding:
                          // Padding, do nothing.
                          break;
  
                      case FileLogOutput.PART_First:
                      case FileLogOutput.PART_Middle:
                      case FileLogOutput.PART_Last:
                          multiPartID = dataInputStream.readByte();
                          partLength = dataInputStream.readShort();
  
                          // Now get the logRecord itself.
                          // TODO We could avoid doing this if the logRecord is single part as it is in fact just the next bytes
                          //      in the datastream.
                          logRecordBytes = new byte[partLength];
                          // There is a bug in JVM 1.4.2 such that dataInput.readFully(byte[],int,int)
                          // returns a partial buffer rather than throwing EOFExcepton. 
                          // dataInputStream.readFully(logRecordBytes);
                          // Anyhow we would rather not block if the file has data missing at the end.
                          int bytesRead = dataInputStream.read(logRecordBytes);
                          if (bytesRead != partLength) {
                              if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
                                  trace.exit(this, cclass
                                             , "readNextLogRecord"
                                             , new Object[] { "LogFileExhausted_1", new Integer(bytesRead), new Short(partLength) }
                                                  );
                              throw new LogFileExhaustedException(this, new java.io.EOFException());
                          } // if ( bytesRead != partLength).
  
                          if (multiPartID == 0) {
                              // partType will be PART_Last, this is the only part.
                              java.io.ByteArrayInputStream byteArrayInputStream = new java.io.ByteArrayInputStream(logRecordBytes);
                              logRecordDataInputStream = new java.io.DataInputStream(byteArrayInputStream);
  
                          } else if (partType == FileLogOutput.PART_Last) {
                              if (multiPartLogRecords[multiPartID] != null) {
                                  multiPartLogRecords[multiPartID].add(logRecordBytes);
                                  MultiByteArrayInputStream inputStream = new MultiByteArrayInputStream(multiPartLogRecords[multiPartID]);
                                  logRecordDataInputStream = new java.io.DataInputStream(inputStream);
                                  multiPartLogRecords[multiPartID] = null;
                              } // if (multiPartLogRecords[multiPartID] != null).
  
                          } else if (partType == FileLogOutput.PART_First) {
                              multiPartLogRecords[multiPartID] = new java.util.ArrayList();
                              multiPartLogRecords[multiPartID].add(logRecordBytes);
                          } else {
                              if (multiPartLogRecords[multiPartID] != null) {
                                  multiPartLogRecords[multiPartID].add(logRecordBytes);
                              }
                          }
  
                          break;
                      default:
                          if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
                              trace.exit(this, cclass
                                         , "readNextLogRecord"
                                         , "via InvalidLogPartTypeException partType=" + partType + "(byte)"
                                              );
                          throw new InvalidLogRecordPartTypeException(this
                                                                      , partType);
                          // break;                             // unreachable.
                  } // switch (partType).
  
              } catch (java.io.EOFException exception) {
                  // No FFDC Code Needed, condition expected when end of log seen.
                  if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
                      trace.exit(this, cclass
                                 , "readNextLogRecord"
                                 , new Object[] { "LogFileExhausted_2", new Short(partLength) }
                                      );
                  throw new LogFileExhaustedException(this, exception);
  
              } catch (java.io.IOException exception) {
                  // No FFDC Code Needed.
                  ObjectManager.ffdc.processException(cclass, "readNext", exception, "1:348:1.13");
  
                  if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
                      trace.exit(this, cclass
                                 , "readNextLogRecord"
                                 , new Object[] { new Short(partLength), exception }
                                      );
                  throw new PermanentIOException(this
                                                 , exception);
              } // catch java.io.IOException.
  
          } // while (logRecordDataInputStream == null).
  
          if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
              trace.exit(this,
                         cclass,
                         "readNextLogRecord",
                         new Object[] { logRecordDataInputStream });
          return logRecordDataInputStream;
      }