import htsjdk.tribble.bed.BEDCodec; //导入依赖的package包/类
public BedFile reindexBedFile(long bedFileId) throws FeatureIndexException {
    BedFile bedFile = bedFileManager.loadBedFile(bedFileId);
    Reference reference = referenceGenomeManager.loadReferenceGenome(bedFile.getReferenceId());
    Map<String, Chromosome> chromosomeMap = reference.getChromosomes().stream().collect(
            Collectors.toMap(BaseEntity::getName, chromosome -> chromosome));

    try {
        fileManager.deleteFileFeatureIndex(bedFile);
        try (AbstractFeatureReader<BEDFeature, LineIterator> reader =
                     AbstractFeatureReader.getFeatureReader(bedFile.getPath(), new BEDCodec(), false)) {
            featureIndexManager.makeIndexForBedReader(bedFile, reader, chromosomeMap);
        }
    } catch (IOException e) {
        throw new FeatureIndexException(bedFile, e);
    }

    return bedFile;
}
 

import htsjdk.tribble.bed.BEDCodec; //导入依赖的package包/类
/**
 * Gets the set (no duplicates) of chromosomes from a bed file.
 *
 * @param bedFilePath Path to the bed file.
 *
 * @return The set of chromosomes (no duplicates)
 *
 * @throws FileNotFoundException, IOException
 */
public static Set<String> getChromosomes(String bedFilePath) throws FileNotFoundException, IOException {
    Set<String> chrs = new LinkedHashSet<>();
    File bedFile = FileUtils.getFile(bedFilePath);
    try (InputStream is = new FileInputStream(bedFile);
            AsciiLineReader alr = new AsciiLineReader(is);
            LineIteratorImpl lineIterator = new LineIteratorImpl(alr);) {
        BEDCodec bc = new BEDCodec();
        while (!bc.isDone(lineIterator)) {
            BEDFeature bf = bc.decode(lineIterator);
            if (bf != null) {
                //see https://github.com/samtools/htsjdk/issues/197
                chrs.add(bf.getContig());
            }
        }
    }
    return chrs;
}
 

import htsjdk.tribble.bed.BEDCodec; //导入依赖的package包/类
@DataProvider(name = "DetectCorrectFileFormatTestData")
public Object[][] getDetectCorrectFileFormatTestData() {
    return new Object[][] {
            { new File(FEATURE_MANAGER_TEST_DIRECTORY + "minimal_vcf4_file.vcf"), VCFCodec.class },
            { new File(FEATURE_MANAGER_TEST_DIRECTORY + "minimal_vcf3_file.vcf"), VCF3Codec.class },
            { new File(FEATURE_MANAGER_TEST_DIRECTORY + "minimal_bcf_file.bcf"), BCF2Codec.class },
            { new File(FEATURE_MANAGER_TEST_DIRECTORY + "minimal_bed_file.bed"), BEDCodec.class},
            { new File(FEATURE_MANAGER_TEST_DIRECTORY + "minimal_table_file.table"), TableCodec.class}
    };
}
 

import htsjdk.tribble.bed.BEDCodec; //导入依赖的package包/类
public LongISLNDReadAlignmentMap(final Collection<String> readAlignmentMapFiles) throws IOException {
    for (final String readAlignmentMapFileName : readAlignmentMapFiles) {
        log.info("Reading in read map from " + readAlignmentMapFileName);
        final AbstractFeatureReader<BEDFeature, LineIterator> featureReader = AbstractFeatureReader.getFeatureReader(readAlignmentMapFileName, new BEDCodec(), false);
        try {
            final CloseableTribbleIterator<BEDFeature> featureIterator = featureReader.iterator();
            while (featureIterator.hasNext()) {
                final BEDFeature feature = featureIterator.next();
                readAlignmentMap.put(feature.getName(), new LongISLNDReadMapRecord(feature).toReadMapRecord());
            }
        } finally {
            featureReader.close();
        }
    }
}
 

import htsjdk.tribble.bed.BEDCodec; //导入依赖的package包/类
public long getNumNonNBases(final File regions) throws IOException {
    long count = 0;

    final FeatureCodec<BEDFeature, LineIterator> bedCodec = new BEDCodec(BEDCodec.StartOffset.ONE);
    final LineIterator lineIterator = new AsciiLineReaderIterator(new AsciiLineReader(new FileInputStream(regions)));

    while (lineIterator.hasNext()) {
        final BEDFeature bedFeature = bedCodec.decode(lineIterator);
        count += data.get(new ChrString(bedFeature.getContig())).getNumNonNBases(bedFeature.getStart(), bedFeature.getEnd());
    }
    return count;
}
 

import htsjdk.tribble.bed.BEDCodec; //导入依赖的package包/类
public BedFileAnnotator(BedAnnotationOptions options) {
	this.options = options;
	this.featureFile = new File(options.getPathBed());

	try {
		this.reader = new TabixFeatureReader<>(featureFile.getAbsolutePath().toString(),
				featureFile.getAbsolutePath().toString() + ".tbi", new BEDCodec());
	} catch (IOException e) {
		throw new RuntimeException("Problem opening indexed BED file", e);
	}
}
 

import htsjdk.tribble.bed.BEDCodec; //导入依赖的package包/类
@Test
public void testSortBed() throws Exception {
    testSort(getTemplate("invalid/unsorted.bed"), new BEDCodec(), UNSORTED_BED_EXPECTED_LINES);
}
 

import htsjdk.tribble.bed.BEDCodec; //导入依赖的package包/类
@Test
public void testSortBedCompressed() throws Exception {
    testSort(getTemplate("genes_sorted.bed.gz"), new BEDCodec(), GENE_SORTED_BED_EXPECTED_LINES);
}
 

import htsjdk.tribble.bed.BEDCodec; //导入依赖的package包/类
@Test
public void testSortBedCompressedOutOfMemory() throws Exception {
    testSort(getTemplate("big.bed.gz"), new BEDCodec(), BIG_BED_EXPECTED_LINES, 1);
}
 

import htsjdk.tribble.bed.BEDCodec; //导入依赖的package包/类
public BEDFileLookupFileImpl(final String bedFile) {
    reader = getFeatureReader(bedFile, new BEDCodec(), true);
}
 

import htsjdk.tribble.bed.BEDCodec; //导入依赖的package包/类
@Override
protected int doWork() {
    IOUtil.assertFileIsReadable(INPUT);
    IOUtil.assertFileIsReadable(SEQUENCE_DICTIONARY);
    IOUtil.assertFileIsWritable(OUTPUT);
    try {
        // create a new header that we will assign the dictionary provided by the SAMSequenceDictionaryExtractor to.
        final SAMFileHeader header = new SAMFileHeader();
        final SAMSequenceDictionary samSequenceDictionary = SAMSequenceDictionaryExtractor.extractDictionary(SEQUENCE_DICTIONARY.toPath());
        header.setSequenceDictionary(samSequenceDictionary);
        // set the sort order to be sorted by coordinate, which is actually done below
        // by getting the .uniqued() intervals list before we write out the file
        header.setSortOrder(SAMFileHeader.SortOrder.coordinate);
        final IntervalList intervalList = new IntervalList(header);

        /**
         * NB: BED is zero-based, but a BEDCodec by default (since it is returns tribble Features) has an offset of one,
         * so it returns 1-based starts.  Ugh.  Set to zero.
         */
        final FeatureReader<BEDFeature> bedReader = AbstractFeatureReader.getFeatureReader(INPUT.getAbsolutePath(), new BEDCodec(BEDCodec.StartOffset.ZERO), false);
        final CloseableTribbleIterator<BEDFeature> iterator = bedReader.iterator();
        final ProgressLogger progressLogger = new ProgressLogger(LOG, (int) 1e6);

        while (iterator.hasNext()) {
            final BEDFeature bedFeature = iterator.next();
            final String sequenceName = bedFeature.getContig();
            /**
             * NB: BED is zero-based, so we need to add one here to make it one-based.  Please observe we set the start
             * offset to zero when creating the BEDCodec.
             */
            final int start = bedFeature.getStart() + 1;
            /**
             * NB: BED is 0-based OPEN (which, for the end is equivalent to 1-based closed).
             */
            final int end = bedFeature.getEnd();
            // NB: do not use an empty name within an interval
            String name = bedFeature.getName();
            if (name.isEmpty()) name = null;

            final SAMSequenceRecord sequenceRecord = header.getSequenceDictionary().getSequence(sequenceName);

            // Do some validation
            if (null == sequenceRecord) {
                throw new PicardException(String.format("Sequence '%s' was not found in the sequence dictionary", sequenceName));
            } else if (start < 1) {
                throw new PicardException(String.format("Start on sequence '%s' was less than one: %d", sequenceName, start));
            } else if (sequenceRecord.getSequenceLength() < start) {
                throw new PicardException(String.format("Start on sequence '%s' was past the end: %d < %d", sequenceName, sequenceRecord.getSequenceLength(), start));
            } else if (end < 1) {
                throw new PicardException(String.format("End on sequence '%s' was less than one: %d", sequenceName, end));
            } else if (sequenceRecord.getSequenceLength() < end) {
                throw new PicardException(String.format("End on sequence '%s' was past the end: %d < %d", sequenceName, sequenceRecord.getSequenceLength(), end));
            } else if (end < start - 1) {
                throw new PicardException(String.format("On sequence '%s', end < start-1: %d <= %d", sequenceName, end, start));
            }

            final boolean isNegativeStrand = bedFeature.getStrand() == Strand.NEGATIVE;
            final Interval interval = new Interval(sequenceName, start, end, isNegativeStrand, name);
            intervalList.add(interval);

            progressLogger.record(sequenceName, start);
        }
        CloserUtil.close(bedReader);

        // Sort and write the output
        IntervalList out = intervalList;
        if (SORT) out = out.sorted();
        if (UNIQUE) out = out.uniqued();
        out.write(OUTPUT);

    } catch (final IOException e) {
        throw new RuntimeException(e);
    }

    return 0;
}