/** * Generate a CRAI Index entry from this Slice and the container offset. * * TODO: investigate why we sometimes need to pass in an external containerStartOffset * because this Slice's containerOffset is incorrect * * @param containerStartOffset the byte offset of this Slice's Container * @return a new CRAI Index Entry */ public CRAIEntry getCRAIEntry(final long containerStartOffset) { return new CRAIEntry(sequenceId, alignmentStart, alignmentSpan, containerStartOffset, offset, size); }
/** * Generate a CRAI Index entry from this Slice * @return a new CRAI Index Entry */ public CRAIEntry getCRAIEntry() { return new CRAIEntry(sequenceId, alignmentStart, alignmentSpan, containerOffset, offset, size); } /**
@Override public CRAIEntry clone() throws CloneNotSupportedException { super.clone(); final CRAIEntry entry = new CRAIEntry(); entry.sequenceId = sequenceId; entry.alignmentStart = alignmentStart; entry.alignmentSpan = alignmentSpan; entry.containerStartOffset = containerStartOffset; entry.sliceOffset = sliceOffset; entry.sliceSize = sliceSize; return entry; }
public static List<CRAIEntry> fromContainer(final Container container) { final List<CRAIEntry> entries = new ArrayList<>(container.slices.length); for (int i = 0; i < container.slices.length; i++) { final Slice s = container.slices[i]; final CRAIEntry e = new CRAIEntry(); e.sequenceId = s.sequenceId; e.alignmentStart = s.alignmentStart; e.alignmentSpan = s.alignmentSpan; e.containerStartOffset = s.containerOffset; e.sliceOffset = container.landmarks[i]; e.sliceSize = s.size; e.sliceIndex = i; entries.add(e); } return entries; }
public static List<CRAIEntry> find(final List<CRAIEntry> list, final int seqId, final int start, final int span) { final boolean whole = start < 1 || span < 1; final CRAIEntry query = new CRAIEntry(); query.sequenceId = seqId; query.alignmentStart = start < 1 ? 1 : start; query.alignmentSpan = span < 1 ? Integer.MAX_VALUE : span; query.containerStartOffset = Long.MAX_VALUE; query.sliceOffset = Integer.MAX_VALUE; query.sliceSize = Integer.MAX_VALUE; final List<CRAIEntry> l = new ArrayList<>(); for (final CRAIEntry e : list) { if (e.sequenceId != seqId) { continue; } if (whole || CRAIEntry.intersect(e, query)) { l.add(e); } } Collections.sort(l, CRAIEntry.byStart); return l; }
public static List<CRAIEntry> find(final List<CRAIEntry> list, final int seqId, final int start, final int span) { final boolean whole = start < 1 || span < 1; final CRAIEntry query = new CRAIEntry(seqId, start < 1 ? 1 : start, span < 1 ? Integer.MAX_VALUE : span, Long.MAX_VALUE, Integer.MAX_VALUE, Integer.MAX_VALUE); final List<CRAIEntry> l = new ArrayList<>(); for (final CRAIEntry e : list) { if (e.getSequenceId() != seqId) { continue; } if (whole || CRAIEntry.intersect(e, query)) { l.add(e); } } Collections.sort(l, CRAIEntry.byStart); return l; }
/** * Return a list of CRAI Entries; one for each reference in the multireference slice. * TODO: this should be refactored and delegate to container/slice */ private static Collection<CRAIEntry> getCRAIEntriesForMultiRefSlice( final Slice slice, final CompressionHeader header, final long containerOffset, final int[] landmarks) { final Map<Integer, AlignmentSpan> spans = slice.getMultiRefAlignmentSpans(header, ValidationStringency.DEFAULT_STRINGENCY); List<CRAIEntry> entries = new ArrayList<>(spans.size()); for (int seqId : spans.keySet()) { CRAIEntry e = new CRAIEntry(); e.sequenceId = seqId; AlignmentSpan span = spans.get(seqId); e.alignmentStart = span.getStart(); e.alignmentSpan = span.getSpan(); e.sliceSize = slice.size; e.sliceIndex = slice.index; e.containerStartOffset = containerOffset; e.sliceOffset = landmarks[slice.index]; entries.add(e); } return entries; }
/** * Read an input stream containing a .crai index and return a CRAIIndex object. * @param is Input stream to read * @return A CRAIIndex object representing the index. */ public static CRAIIndex readIndex(final InputStream is) { CRAIIndex craiIndex = new CRAIIndex(); Scanner scanner = null; try { scanner = new Scanner(new GZIPInputStream(is)); while (scanner.hasNextLine()) { final String line = scanner.nextLine(); craiIndex.addEntry(new CRAIEntry(line)); } } catch (IOException e) { throw new RuntimeIOException("Error reading CRAI index from output stream"); } finally { if (null != scanner) { scanner.close(); } } return craiIndex; }
/** * Read an input stream containing a .crai index and return a CRAIIndex object. * @param is Input stream to read * @return A CRAIIndex object representing the index. */ public static CRAIIndex readIndex(final InputStream is) { CRAIIndex craiIndex = new CRAIIndex(); Scanner scanner = null; try { scanner = new Scanner(new GZIPInputStream(is)); while (scanner.hasNextLine()) { final String line = scanner.nextLine(); craiIndex.addEntry(new CRAIEntry(line)); } } catch (IOException e) { throw new RuntimeIOException("Error reading CRAI index from output stream"); } finally { if (null != scanner) { scanner.close(); } } return craiIndex; }
/** * 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)); } } } }
public static CRAIEntry newEntry(final int sequenceId, final int start, final int span, final int containerStartOffset, final int sliceOffset, final int sliceSize) { return new CRAIEntry(sequenceId, start, span, containerStartOffset, sliceOffset, sliceSize); }
@Test public void testFromCraiLine() { int counter = 1; final int sequenceId = counter++; final int alignmentStart = counter++; final int alignmentSpan = counter++; final int containerOffset = Integer.MAX_VALUE + counter++; final int sliceOffset = counter++; final int sliceSize = counter++; final String line = String.format("%d\t%d\t%d\t%d\t%d\t%d", sequenceId, alignmentStart, alignmentSpan, containerOffset, sliceOffset, sliceSize); final CRAIEntry entry = new CRAIEntry(line); Assert.assertNotNull(entry); Assert.assertEquals(entry.getSequenceId(), sequenceId); Assert.assertEquals(entry.getAlignmentStart(), alignmentStart); Assert.assertEquals(entry.getAlignmentSpan(), alignmentSpan); Assert.assertEquals(entry.getContainerStartByteOffset(), containerOffset); Assert.assertEquals(entry.getSliceByteOffset(), sliceOffset); Assert.assertEquals(entry.getSliceByteSize(), sliceSize); }