@Override public boolean hasNext() { if (container != null && container.isEOF()) return false; if (!iterator.hasNext()) { nextContainer(); } return !records.isEmpty(); }
public List<CramCompressionRecord> getRecords(final Container container, ArrayList<CramCompressionRecord> records, final ValidationStringency validationStringency) throws IllegalArgumentException, IllegalAccessException { if (container.isEOF()) { return Collections.emptyList(); } if (records == null) { records = new ArrayList<>(container.nofRecords); } for (final Slice slice : container.slices) { records.addAll(getRecords(slice, container.header, validationStringency)); } return records; }
public List<CramCompressionRecord> getRecords(final Container container, ArrayList<CramCompressionRecord> records, final ValidationStringency validationStringency) { if (container.isEOF()) { return Collections.emptyList(); } if (records == null) { records = new ArrayList<>(container.nofRecords); } for (final Slice slice : container.slices) { records.addAll(getRecords(slice, container.header, validationStringency)); } return records; }
@Override public boolean hasNext() { if (container != null && container.isEOF()) return false; if (!iterator.hasNext()) { try { nextContainer(); } catch (IOException | IllegalAccessException e) { throw new SAMException(e); } } return !records.isEmpty(); }
public void addContainer(Container c) throws IOException, IllegalArgumentException, IllegalAccessException { if (c.isEOF()) return; for (int i = 0; i < c.slices.length; i++) { Slice s = c.slices[i]; if (s.sequenceId == -2) { this.entries.addAll(getMutliRefEntries(c.header, s, c.offset, c.landmarks)); } else { Entry e = new Entry(); e.sequenceId = c.sequenceId; e.alignmentStart = s.alignmentStart; e.alignmentSpan = s.alignmentSpan; e.containerStartOffset = c.offset; e.sliceOffset = c.landmarks[i]; e.sliceSize = s.size; e.sliceIndex = i; entries.add(e); } } }
public static void main(String[] args) throws IOException, IllegalArgumentException, IllegalAccessException { Log.setGlobalLogLevel(LogLevel.INFO); File cramFile = new File(args[0]); InputStream is = new BufferedInputStream(new FileInputStream(cramFile)); CramHeader header = CramIO.readCramHeader(is); Container c = null; while ((c = ContainerIO.readContainer(header.getVersion(), is)) != null && !c.isEOF()) { for (Slice slice : c.slices) { if (slice.sequenceId == Slice.MULTI_REFERENCE) { System.out.println("Read feature B detected."); System.exit(1); } } } } }
/** * Create index entries for a single container. * @param c the container to index */ public void processContainer(final Container c) { // TODO: this should be refactored and delegate to container/slice if (!c.isEOF()) { for (int i = 0; i < c.slices.length; i++) { Slice s = c.slices[i]; if (s.sequenceId == Slice.MULTI_REFERENCE) { this.entries.addAll(getCRAIEntriesForMultiRefSlice(s, c.header, c.offset, c.landmarks)); } else { CRAIEntry e = new CRAIEntry(); e.sequenceId = c.sequenceId; e.alignmentStart = s.alignmentStart; e.alignmentSpan = s.alignmentSpan; e.containerStartOffset = c.offset; e.sliceOffset = c.landmarks[i]; e.sliceSize = s.size; e.sliceIndex = i; entries.add(e); } } } }
/** * Create index entries for a single container. * @param container the container to index */ public void processContainer(final Container container) { // TODO: this should be refactored and delegate to container/slice if (!container.isEOF()) { for (final Slice s: container.slices) { if (s.sequenceId == Slice.MULTI_REFERENCE) { final Map<Integer, AlignmentSpan> spans = s.getMultiRefAlignmentSpans(container.header, ValidationStringency.DEFAULT_STRINGENCY); this.entries.addAll(spans.entrySet().stream() .map(e -> new CRAIEntry(e.getKey(), e.getValue().getStart(), e.getValue().getSpan(), container.offset, container.landmarks[s.index], s.size)) .collect(Collectors.toList())); } else { entries.add(s.getCRAIEntry(container.offset)); } } } }
void readNextContainer() { try { nextContainer = containerFromStream(cramHeader.getVersion(), countingInputStream); final long containerSizeInBytes = countingInputStream.getCount() - offset; nextContainer.offset = offset; offset += containerSizeInBytes; } catch (final IOException e) { throw new RuntimeException(e); } if (nextContainer.isEOF()) { eof = true; nextContainer = null; } }
void readNextContainer() { nextContainer = containerFromStream(cramHeader.getVersion(), countingInputStream); final long containerSizeInBytes = countingInputStream.getCount() - offset; nextContainer.offset = offset; offset += containerSizeInBytes; if (nextContainer.isEOF()) { eof = true; nextContainer = null; } }
@SuppressWarnings("SameParameterValue") private static Container readContainer(final int major, final InputStream inputStream, final int fromSlice, int howManySlices) throws IOException { final Container container = readContainerHeader(major, inputStream); if (container.isEOF()) { return container; } container.header = CompressionHeader.read(major, inputStream); howManySlices = Math.min(container.landmarks.length, howManySlices); if (fromSlice > 0) //noinspection ResultOfMethodCallIgnored inputStream.skip(container.landmarks[fromSlice]); final List<Slice> slices = new ArrayList<Slice>(); for (int sliceCount = fromSlice; sliceCount < howManySlices - fromSlice; sliceCount++) { final Slice slice = new Slice(); SliceIO.read(major, slice, inputStream); slice.index = sliceCount; slices.add(slice); } container.slices = slices.toArray(new Slice[slices.size()]); calculateSliceOffsetsAndSizes(container); log.debug("READ CONTAINER: " + container.toString()); return container; }
/** * Reads a CRAM container from the input stream. Returns an EOF container when there is no more data or the EOF marker found. * * @param version CRAM version to expect * @param inputStream the stream to read from * @return a new container object read from the stream */ public static Container readContainer(final Version version, final InputStream inputStream) { final Container container = readContainer(version.major, inputStream); if (container == null) { // this will cause System.exit(1): CramVersionPolicies.eofNotFound(version); return readContainer(version.major, new ByteArrayInputStream(CramIO.ZERO_B_EOF_MARKER)); } if (container.isEOF()) log.debug("EOF marker found, file/stream is complete."); return container; }
/** * Reads a CRAM container from the input stream. Returns an EOF container when there is no more data or the EOF marker found. * * @param version CRAM version to expect * @param inputStream the stream to read from * @return a new container object read from the stream * @throws IOException as per java IO contract */ public static Container readContainer(final Version version, final InputStream inputStream) throws IOException { final Container container = readContainer(version.major, inputStream); if (container == null) { // this will cause System.exit(1): CramVersionPolicies.eofNotFound(version); return readContainer(version.major, new ByteArrayInputStream(CramIO.ZERO_B_EOF_MARKER)); } if (container.isEOF()) log.debug("EOF marker found, file/stream is complete."); return container; }
@SuppressWarnings("SameParameterValue") private static Container readContainer(final int major, final InputStream inputStream, final int fromSlice, int howManySlices) { final Container container = readContainerHeader(major, inputStream); if (container.isEOF()) { return container; } container.header = CompressionHeader.read(major, inputStream); howManySlices = Math.min(container.landmarks.length, howManySlices); try { if (fromSlice > 0) //noinspection ResultOfMethodCallIgnored inputStream.skip(container.landmarks[fromSlice]); } catch (final IOException e) { throw new RuntimeIOException(e); } final List<Slice> slices = new ArrayList<Slice>(); for (int sliceCount = fromSlice; sliceCount < howManySlices - fromSlice; sliceCount++) { final Slice slice = new Slice(); SliceIO.read(major, slice, inputStream); slice.index = sliceCount; slices.add(slice); } container.slices = slices.toArray(new Slice[slices.size()]); calculateSliceOffsetsAndSizes(container); log.debug("READ CONTAINER: " + container.toString()); return container; }
@Test(dataProvider = "eof") public void testEOF(final Version version) throws IOException { final ContainerParser parser = new ContainerParser(ContainerFactoryTest.getSAMFileHeaderForTests()); try (final ByteArrayOutputStream baos = new ByteArrayOutputStream()) { CramIO.issueEOF(version, baos); final Container container = ContainerIO.readContainer(version, new ByteArrayInputStream(baos.toByteArray())); Assert.assertTrue(container.isEOF()); Assert.assertTrue(parser.getRecords(container, null, ValidationStringency.STRICT).isEmpty()); } }
private static void dist(File file, byte defaultQualityScore) throws IllegalArgumentException, IOException, IllegalAccessException { InputStream is = new FileInputStream(file); CramHeader header = CramIO.readCramHeader(is); Container c = null; ContainerParser parser = new ContainerParser(header.getSamFileHeader()); ArrayList<CramCompressionRecord> records = new ArrayList<CramCompressionRecord>(10000); long[] freq = new long[255]; while ((c = ContainerIO.readContainer(header.getVersion(), is)) != null && !c.isEOF()) { parser.getRecords(c, records, ValidationStringency.SILENT); CramNormalizer.restoreQualityScores(defaultQualityScore, records); for (CramCompressionRecord record : records) { for (byte b : record.qualityScores) freq[b & 0xFF]++; } records.clear(); } print(freq, defaultQualityScore, System.out); }
private boolean nextContainer() throws IOException { long offset = is.getCount(); Container c = ContainerIO.readContainer(cramHeader.getVersion(), is); if (c.isEOF()) return false; c.offset = offset; indexer.processContainer(c, ValidationStringency.DEFAULT_STRINGENCY); log.info("INDEXED: " + c.toString()); return true; }
private boolean nextContainer() throws IOException, IllegalArgumentException, IllegalAccessException { long offset = is.getCount(); Container c = ContainerIO.readContainer(cramHeader.getVersion(), is); if (c.isEOF()) return false; c.offset = offset; index.addContainer(c); log.info("INDEXED: " + c.toString()); return true; }
@Override public OrderedByteArray get() { OrderedByteArray cb = new OrderedByteArray(); Container containerHeader; try { containerHeader = ContainerIO.readContainerHeader(cramHeader.getVersion().major, is); log.debug("Read container: " + containerHeader.toString()); if (containerHeader.isEOF()) { log.info("EOF container"); return null; } ByteArrayOutputStream baos = new ByteArrayOutputStream(containerHeader.containerByteSize + 1024 * 10); ContainerIO.writeContainerHeader(cramHeader.getVersion().major, containerHeader, baos); byte[] blocks = InputStreamUtils.readFully(is, containerHeader.containerByteSize); baos.write(blocks); cb.bytes = baos.toByteArray(); cb.order = order++; return cb; } catch (IOException e) { throw new RuntimeIOException(e); } } }
/** * Generate and write a CRAI index to an output stream from a CRAM input stream * * @param cramStream CRAM stream to index; must be coordinate sorted * @param craiStream stream for output index */ public static void writeIndex(final SeekableStream cramStream, OutputStream craiStream) { try { final CramHeader cramHeader = CramIO.readCramHeader(cramStream); final CRAMCRAIIndexer indexer = new CRAMCRAIIndexer(craiStream, cramHeader.getSamFileHeader()); final Version cramVersion = cramHeader.getVersion(); // get the first container and it's offset long offset = cramStream.position(); Container container = ContainerIO.readContainer(cramVersion, cramStream); while (container != null && !container.isEOF()) { container.offset = offset; indexer.processContainer(container); offset = cramStream.position(); container = ContainerIO.readContainer(cramVersion, cramStream); } indexer.finish(); } catch (IOException e) { throw new RuntimeIOException("Error writing CRAI index to output stream"); } }