public SAMRecordIterator assertSorted(final SAMFileHeader.SortOrder sortOrder) { return i.assertSorted(sortOrder); } }
@Override public SAMRecordIterator assertSorted(SAMFileHeader.SortOrder sortOrder) { return delegate.assertSorted(sortOrder); }
/** * Constructor * * @param iterator the backing iterator * @param filter the filter (which may be a FilterAggregator) * @param filterByPair if true, filter reads in pairs */ public FilteringSamIterator(final Iterator<SAMRecord> iterator, final SamRecordFilter filter, final boolean filterByPair) { if (filterByPair && iterator instanceof SAMRecordIterator) { ((SAMRecordIterator)iterator).assertSorted(SAMFileHeader.SortOrder.queryname); } this.iterator = new PeekableIterator<SAMRecord>(iterator); this.filter = filter; this.filterReadPairs = filterByPair; next = getNextRecord(); }
/** * Constructor * * @param iterator the backing iterator * @param filter the filter (which may be a FilterAggregator) * @param filterByPair if true, filter reads in pairs */ public FilteringSamIterator(final Iterator<SAMRecord> iterator, final SamRecordFilter filter, final boolean filterByPair) { if (filterByPair && iterator instanceof SAMRecordIterator) { ((SAMRecordIterator)iterator).assertSorted(SAMFileHeader.SortOrder.queryname); } this.iterator = new PeekableIterator<SAMRecord>(iterator); this.filter = filter; this.filterReadPairs = filterByPair; next = getNextRecord(); }
/** * Constructor * * @param iterator the backing iterator * @param filter the filter (which may be a FilterAggregator) * @param filterByPair if true, filter reads in pairs */ public FilteringIterator(final Iterator<SAMRecord> iterator, final SamRecordFilter filter, final boolean filterByPair) { if (filterByPair && iterator instanceof SAMRecordIterator) { ((SAMRecordIterator)iterator).assertSorted(SAMFileHeader.SortOrder.queryname); } this.iterator = new PeekableIterator<SAMRecord>(iterator); this.filter = filter; this.filterReadPairs = filterByPair; next = getNextRecord(); }
private CloseableIterator<SAMRecord> getSamReaderIterator(SamReader reader, SortOrder expectedOrder, File file) { SAMRecordIterator rawIterator = reader.iterator(); if (expectedOrder != null && expectedOrder != SortOrder.unsorted) { rawIterator.assertSorted(expectedOrder); } // wrap so we're happy to close as many times as we want CloseableIterator<SAMRecord> safeIterator = new AutoClosingIterator<SAMRecord>(rawIterator, reader); return applyCommonSAMRecordFilters(safeIterator); }
public CloseableIterator<DirectedEvidence> iterator() { SamReader reader = getReader(); SAMRecordIterator it = reader.iterator(); it.assertSorted(SortOrder.coordinate); Iterator<DirectedEvidence> eit = asEvidence(it); return new AutoClosingIterator<>(eit, reader, it); } private SamReader getReader() {
@Test(dataProvider = "sortsCramWithoutIndex") public void testCramSort(String file, String fileReference, SAMFileHeader.SortOrder order) throws Exception { final CRAMFileReader cramFileReader = getCramFileReader(file, fileReference); final SAMRecordIterator samRecordIterator = cramFileReader.getIterator().assertSorted(order); Assert.assertTrue(samRecordIterator.hasNext()); while (samRecordIterator.hasNext()) { Assert.assertNotNull(samRecordIterator.next()); } }
@Test(dataProvider = "sortsFailCramWithoutIndex", expectedExceptions = IllegalStateException.class) public void testCramSortFail(String file, String fileReference, SAMFileHeader.SortOrder order) throws Exception { final CRAMFileReader cramFileReader = getCramFileReader(file, fileReference); final SAMRecordIterator samRecordIterator = cramFileReader.getIterator().assertSorted(order); Assert.assertTrue(samRecordIterator.hasNext()); while (samRecordIterator.hasNext()) { Assert.assertNotNull(samRecordIterator.next()); } }
@Test(expectedExceptions = IllegalStateException.class) public void testSortsDisagree() throws Exception { SAMRecordIterator it = SamReaderFactory.makeDefault().open(new File(COORDINATE_SORTED_FILE)).iterator(); try { it.assertSorted(SAMFileHeader.SortOrder.queryname); while (it.hasNext()) { it.next(); } Assert.fail("Queryname assertion should have failed on coordinate sorted file but didn't"); } finally { it.close(); } }
public void indexBAM(File inputFile, String outputFileName) { final File bamIndexFile = new File(outputFileName); SamReaderFactory.setDefaultValidationStringency(ValidationStringency.SILENT); final SamReader samReader = SamReaderFactory.makeDefault(). enable(SamReaderFactory.Option.INCLUDE_SOURCE_IN_RECORDS). open(inputFile); BAMIndexer indexer = new BAMIndexer(bamIndexFile, samReader.getFileHeader()); long totalRecords = 0; // create and write the content SAMRecordIterator iter = samReader.iterator().assertSorted(SAMFileHeader.SortOrder.coordinate); while(iter.hasNext()) { SAMRecord rec = iter.next(); if (++totalRecords % 1000000 == 0) { if (null != log) log.info(totalRecords + " reads processed ..."); } indexer.processAlignment(rec); } indexer.finish(); }
private List<ReferenceCoverageLookup> createLookup(ProcessingContext context, List<SAMEvidenceSource> sources, int windowSize) { List<ReferenceCoverageLookup> result = new ArrayList<>(); for (SAMEvidenceSource ses : sources) { assert(ses.getSourceCategory() >= 0); assert(ses.getSourceCategory() < context.getCategoryCount()); // one read-ahead thread per input file SamReader reader = SamReaderFactory.makeDefault().referenceSequence(context.getReferenceFile()).open(ses.getFile()); SAMRecordIterator rawIterator = reader.iterator(); rawIterator.assertSorted(SortOrder.coordinate); CloseableIterator<SAMRecord> sit = new AsyncBufferedIterator<SAMRecord>(rawIterator, ses.getFile().getName() + "-Coverage"); toclose.add(sit); // close the async iterator first to prevent aysnc reading from a closed stream toclose.add(rawIterator); toclose.add(reader); sit = new ProgressLoggingSAMRecordIterator(sit, new ProgressLogger(log, 10000000)); SequentialReferenceCoverageLookup sourceLookup = new SequentialReferenceCoverageLookup(sit, ses.getMetrics().getIdsvMetrics(), ses.getReadPairConcordanceCalculator(), windowSize, ses.getSourceCategory(), context.isFilterDuplicates()); context.registerBuffer(ses.getFile().getName(), sourceLookup); result.add(sourceLookup); } return result; } public SequentialCoverageAnnotator(
@Test(dataProvider = "validSorts") public void testSortAssertionValid(String file, SAMFileHeader.SortOrder order) { SAMRecordIterator it = SamReaderFactory.makeDefault().open(new File(file)).iterator(); try { it.assertSorted(order); while (it.hasNext()) { it.next(); } } finally { it.close(); } }
@Test(dataProvider = "invalidSorts", expectedExceptions = IllegalStateException.class) public void testSortAssertionFails(String file, SAMFileHeader.SortOrder order) throws Exception { SAMRecordIterator it = SamReaderFactory.makeDefault().open(new File(file)).iterator(); try { it.assertSorted(order); while (it.hasNext()) { it.next(); } Assert.fail("Iterated successfully over " + file + " with invalid sort assertion: " + order.name()); } finally { it.close(); } }