96     private final RecordingInput input;

    96     private final RecordingInput input;

    97     private final ChunkHeader chunkHeader;

    97     private final ChunkHeader chunkHeader;

    98     private final MetadataDescriptor metadata;

    98     private final MetadataDescriptor metadata;

    99     private final TimeConverter timeConverter;

    99     private final TimeConverter timeConverter;

   100     private final MetadataDescriptor previousMetadata;

   100     private final MetadataDescriptor previousMetadata;

   102     private final LongMap<ConstantLookup> constantLookups;

   101     private final LongMap<ConstantLookup> constantLookups;

   103 

   102 

   104     private LongMap<Type> typeMap;

   103     private LongMap<Type> typeMap;

   105     private LongMap<Parser> parsers;

   104     private LongMap<Parser> parsers;

   106     private boolean chunkFinished;

   105     private boolean chunkFinished;

   123     private ChunkParser(ChunkHeader header, ChunkParser previous, ParserConfiguration pc) throws IOException {

   122     private ChunkParser(ChunkHeader header, ChunkParser previous, ParserConfiguration pc) throws IOException {

   124         this.configuration = pc;

   123         this.configuration = pc;

   125         this.input = header.getInput();

   124         this.input = header.getInput();

   126         this.chunkHeader = header;

   125         this.chunkHeader = header;

   127         if (previous == null) {

   126         if (previous == null) {

   129             this.constantLookups = new LongMap<>();

   127             this.constantLookups = new LongMap<>();

   130             this.previousMetadata = null;

   128             this.previousMetadata = null;

   131         } else {

   129         } else {

   132             this.constantLookups = previous.constantLookups;

   130             this.constantLookups = previous.constantLookups;

   133             this.previousMetadata = previous.metadata;

   131             this.previousMetadata = previous.metadata;

   135             this.configuration = previous.configuration;

   132             this.configuration = previous.configuration;

   136         }

   133         }

   137         this.metadata = header.readMetadata(previousMetadata);

   134         this.metadata = header.readMetadata(previousMetadata);

   138         this.timeConverter = new TimeConverter(chunkHeader, metadata.getGMTOffset());

   135         this.timeConverter = new TimeConverter(chunkHeader, metadata.getGMTOffset());

   139         if (metadata != previousMetadata) {

   136         if (metadata != previousMetadata) {

   286                 return false;

   283                 return false;

   287             }

   284             }

   288             if (chunkHeader.isFinished()) {

   285             if (chunkHeader.isFinished()) {

   289                 return true;

   286                 return true;

   290             }

   287             }

   292         }

   289         }

   293     }

   290     }

   294 

   291 

   295     private void fillConstantPools(long abortCP) throws IOException {

   292     private void fillConstantPools(long abortCP) throws IOException {

   296         long thisCP = chunkHeader.getConstantPoolPosition() + chunkHeader.getAbsoluteChunkStart();

   293         long thisCP = chunkHeader.getConstantPoolPosition() + chunkHeader.getAbsoluteChunkStart();