import htsjdk.tribble.util.LittleEndianOutputStream; //导入依赖的package包/类
private void makeTabixCompressedIndex(final File sourceFile, final File indexFile, final AsciiFeatureCodec codec,
                                      final TabixFormat format) throws IOException {
    TabixIndexCreator indexCreator = new TabixIndexCreator(format);

    try (
        BlockCompressedInputStream inputStream = new BlockCompressedInputStream(
            new FileInputStream(sourceFile));
        LittleEndianOutputStream outputStream = new LittleEndianOutputStream(
            new BlockCompressedOutputStream(indexFile))
    ) {
        long p = 0;
        String line = inputStream.readLine();

        while (line != null) {
            //add the feature to the index
            Feature decode = codec.decode(line);
            if (decode != null) {
                indexCreator.addFeature(decode, p);
            }
            // read the next line if available
            p = inputStream.getFilePointer();
            line = inputStream.readLine();
        }

        // write the index to a file
        Index index = indexCreator.finalizeIndex(p);
        // VERY important! either use write based on input file or pass the little endian a BGZF stream
        index.write(outputStream);
    }
}
 

import htsjdk.tribble.util.LittleEndianOutputStream; //导入依赖的package包/类
public void addFeature(int tid, Node feature, long filepointer, LittleEndianOutputStream los) throws IOException {
		if(tid > BinIndexWriter.SHORT_MAX) throw new IllegalArgumentException("Currently we don't support to index file which has chr numbers larger than 32767.");
		los.writeShort(tid);
		
		//edit for case: start == end
		if(feature.beg > feature.end) {
			 throw new IllegalArgumentException(String.format("Feature start position %d > feature end position %d", feature.beg, feature.end));
		}
		los.writeInt(feature.beg);
		if((feature.end - feature.beg) > BinIndexWriter.SHORT_MAX) {
//			System.out.println("range:" + (feature.end - feature.beg));
			los.writeShort(BinIndexWriter.INT_START);
			los.writeInt(feature.end - feature.beg); 
		} else {
			los.writeShort(feature.end - feature.beg); 
		}
   
		los.writeLong(filepointer);
	}
 

import htsjdk.tribble.util.LittleEndianOutputStream; //导入依赖的package包/类
public void makeIndex(final String plusFile, final String path) {
	try {
		final File tempFile = new File(plusFile + BinIndexWriter.TEMP);
		BlockCompressedInputStream reader = BasicUtils.checkStream(new File(path));
		LittleEndianOutputStream los = new LittleEndianOutputStream(new BlockCompressedOutputStream(tempFile));
		
		readBGZInputstream(reader, los);
		los.writeShort(BinIndexWriter.PLUS_FILE_END);
		writeOthers(los);
		los.close();
		boolean success = tempFile.renameTo(new File(plusFile));
		if (!success) {
		   System.err.println("Make index has completed. But rename from '" + tempFile.getAbsolutePath() + "' to '" + plusFile + "' with error. ");
		   System.exit(1);
		} 
	} catch (IOException e) {
		e.printStackTrace();
	} 
}
 

import htsjdk.tribble.util.LittleEndianOutputStream; //导入依赖的package包/类
public void makeIndex() {
	try {
		final String outputPath = path + IntervalIndex.PLUS_EXTENSION;
		final File outputFile = new File(outputPath + IntervalIndex.TEMP);
			
		BlockCompressedInputStream reader = checkStream(new File(path));
		LittleEndianOutputStream los = new LittleEndianOutputStream(new BlockCompressedOutputStream(outputFile));
		readBGZInputstream(reader, los);
			
		los.writeInt(IntervalIndex.PLUS_FILE_END);
		writeOthers(los);
		los.close();
		
		boolean success = outputFile.renameTo(new File(outputPath));
		if (!success) {
		   System.err.println("Make index has completed. But rename from '" + outputFile.getAbsolutePath() + "' to '" + outputPath + "' with error. ");
		} else {
			throw new IllegalArgumentException("We currently support bgz file format. please use bgzip to compress your file!");
		} 
	} catch (IOException e) {
		e.printStackTrace();
	} 
}
 

import htsjdk.tribble.util.LittleEndianOutputStream; //导入依赖的package包/类
public void readBGZInputstream(BlockCompressedInputStream reader, LittleEndianOutputStream los) throws IOException {
		String s, seqName = "", chr;
		long filepointer = 0;
		int tid = 0, linesSkiped = 0;
		Node feature, preFeature = null;
		while((s = reader.readLine()) != null) {
			if(++linesSkiped > formatSpec.tbiFormat.numHeaderLinesToSkip && (s.trim().charAt(0) != formatSpec.tbiFormat.metaCharacter) && !s.trim().equals("") ) {
				feature = decodeFeature(s);
				chr = feature.chr;
				if(!chr.equals(seqName)) {
					System.out.println("Writing plus file for chr " + chr);
					addSeqsName(chr);
					seqName = chr;
					tid = sequenceNames.size() - 1;
					preFeature = null;
				}
				
				if(preFeature != null) {
					if(feature.beg < preFeature.beg) {
						throw new IllegalArgumentException(String.format("Features added out of order: next start " + feature + " < previous start" + preFeature + ", please sorted features by chr column, start column, end column."));
					} 
//					else if(feature.beg == preFeature.beg) {
//						if(feature.end < preFeature.end) {
//							throw new IllegalArgumentException(String.format("Features added out of order: next end " + feature + " < previous end" + preFeature + ", please sorted features by chr column, start column, end column."));
//						}
//					}
				}
				addFeature(tid, feature, filepointer, los);
				preFeature = feature;
			}
			filepointer = reader.getFilePointer();
		}
		reader.close();
	}
 

import htsjdk.tribble.util.LittleEndianOutputStream; //导入依赖的package包/类
public void addFeature(int tid, Node feature, long filepointer, LittleEndianOutputStream los) throws IOException {
		los.writeInt(tid);
		if(feature.beg >= feature.end) {
			 throw new IllegalArgumentException(String.format("Feature start position %d >= feature end position %d", feature.beg, feature.end));
		}
		los.writeInt(feature.beg);
//		System.out.println(feature.beg + "," + feature.end);
		los.writeInt(feature.end-feature.beg);
		los.writeLong(filepointer);
	}
 

import htsjdk.tribble.util.LittleEndianOutputStream; //导入依赖的package包/类
public void readBGZInputstream(BlockCompressedInputStream reader, LittleEndianOutputStream los) throws IOException {
	String s, seqName = "", chr;
	long filepointer = 0;
	int tid = 0;
	Node feature, preFeature = null;
	while((s = reader.readLine()) != null) {
		if(!s.trim().startsWith(VCFHeader.HEADER_INDICATOR) && !s.trim().equals("")) {
			feature = decodeFeature(s);
			chr = feature.chr;
			if(!chr.equals(seqName)) {
				addSeqsName(chr);
				seqName = chr;
				tid = sequenceNames.size() - 1;
				preFeature = null;
			}
			
			if(preFeature != null) {
				if(feature.beg < preFeature.beg) {
					throw new IllegalArgumentException(String.format("Features added out of order: next start " + feature + " < previous start" + preFeature + ", please sorted features by chr column, start column, end column."));
				} else if(feature.beg == preFeature.beg) {
					if(feature.end < preFeature.end) {
						throw new IllegalArgumentException(String.format("Features added out of order: next end " + feature + " < previous end" + preFeature + ", please sorted features by chr column, start column, end column."));
					}
				}
			}
			addFeature(tid, feature, filepointer, los);
			preFeature = feature;
		}
		filepointer = reader.getFilePointer();
	}
	reader.close();
}
 

import htsjdk.tribble.util.LittleEndianOutputStream; //导入依赖的package包/类
private void createGeneCompressedIndex(File indexFile, File file, GffCodec.GffType gffType) throws IOException {
    AsciiFeatureCodec<GeneFeature> codec = new GffCodec(gffType);
    TabixIndexCreator indexCreator = new TabixIndexCreator(TabixFormat.GFF);

    try (
        BlockCompressedInputStream inputStream = new BlockCompressedInputStream(new FileInputStream(file));
        LittleEndianOutputStream outputStream = new LittleEndianOutputStream(
            new BlockCompressedOutputStream(indexFile))
    ) {
        long p = 0;
        String line = inputStream.readLine();

        while (line != null) {
            //add the feature to the index
            GeneFeature decode = codec.decode(line);
            if (decode != null) {
                indexCreator.addFeature(decode, p);
            }
            // read the next line if available
            p = inputStream.getFilePointer();
            line = inputStream.readLine();
        }

        // write the index to a file
        Index index = indexCreator.finalizeIndex(p);
        // VERY important! either use write based on input file or pass the little endian a BGZF stream
        index.write(outputStream);
    }
}
 

import htsjdk.tribble.util.LittleEndianOutputStream; //导入依赖的package包/类
private static void writeChromosomeData(LittleEndianOutputStream peakWriter,
                                        LinkedHashMap<String, Long> chrIndex,
                                        String currentChr,
                                        List<PeakRecord> records) throws IOException {

    chrIndex.put(currentChr, peakWriter.getWrittenCount());

    // Compress data for chromosome, then write it out.
    BufferedByteWriter buffer = new BufferedByteWriter(100000);

    buffer.putNullTerminatedString(currentChr);
    buffer.putInt(records.size());
    for (PeakRecord record : records) {
        buffer.putInt(record.start);
        buffer.putInt(record.end);
        buffer.putFloat(record.score);
        for (int i = 0; i < record.timeScores.length; i++) {
            buffer.putFloat(record.timeScores[i]);
        }
    }

    byte[] bytes = buffer.getBytes();
    bytes = compressionUtils.compress(bytes);
    peakWriter.writeInt(bytes.length);
    peakWriter.write(bytes);

    records.clear();
}
 

import htsjdk.tribble.util.LittleEndianOutputStream; //导入依赖的package包/类
/**
 * @param inputPath
 * @param outputFile
 * @param chromosomeHandler
 */
public static void convert(String inputPath, String outputFile, ChromosomeHandler chromosomeHandler) throws IOException {

    Map<String, Integer> chromosomeOrdinals = new HashMap<>();
    for (Chromosome c : chromosomeHandler.getChromosomeArray()) {
        chromosomeOrdinals.put(c.getName(), c.getIndex());
    }

    AsciiPairIterator iter = null;
    BufferedOutputStream bos = null;
    try {
        bos = new BufferedOutputStream(new FileOutputStream(outputFile));
        LittleEndianOutputStream les = new LittleEndianOutputStream(bos);
        iter = new AsciiPairIterator(inputPath, chromosomeOrdinals
        );

        while (iter.hasNext()) {
            AlignmentPair pair = iter.next();
            les.writeBoolean(pair.getStrand1());
            les.writeInt(pair.getChr1());
            les.writeInt(pair.getPos1());
            les.writeInt(pair.getFrag1());
            les.writeBoolean(pair.getStrand2());
            les.writeInt(pair.getChr2());
            les.writeInt(pair.getPos2());
            les.writeInt(pair.getFrag2());
        }
        les.flush();
        bos.flush();
    } finally {
        if (iter != null) iter.close();
        if (bos != null) bos.close();

    }
}
 

import htsjdk.tribble.util.LittleEndianOutputStream; //导入依赖的package包/类
private void writeHeader(LittleEndianOutputStream les, int dim, float lower, float upper) throws IOException {

        // Magic number - 4 bytes
        les.writeByte('h');
        les.writeByte('i');
        les.writeByte('c');
        les.writeByte(0);

        // Version number
        les.writeInt(1);

        // Genome --
        les.writeString(dataset.getGenomeId());

        // Chromosomes
        les.writeString(chromosome1.getName());
        les.writeString(chromosome1.getName());

        // Resolution (bin size)
        les.writeInt(binSize);

        // Statistics, other attributes
        les.writeFloat(lower);  // this is supposed to be lower quartile
        les.writeFloat(upper);  // this is supposed to be upper quartile
        les.writeInt(dim);  // # rows
        les.writeInt(dim);  // # cols
        les.writeInt(BLOCK_TILE);
    }
 

import htsjdk.tribble.util.LittleEndianOutputStream; //导入依赖的package包/类
public void writeOthers(final LittleEndianOutputStream los) {
       writeOthers(this.formatSpec, sequenceNames, los);
}
 

import htsjdk.tribble.util.LittleEndianOutputStream; //导入依赖的package包/类
public void writeOthers(LittleEndianOutputStream los) {
       writeOthers(this.formatSpec, sequenceNames, los);
}