import htsjdk.samtools.seekablestream.SeekableStreamFactory; //导入依赖的package包/类
public void initStream(final File plusFile) {
	if(plusFile.exists()) {
		try {
			 final ISeekableStreamFactory ssf = SeekableStreamFactory.getInstance();
	         final SeekableStream seekableStream =
	                    ssf.getBufferedStream(ssf.getStreamFor(plusFile.getAbsolutePath()));
	         BlockCompressedInputStream is = new BlockCompressedInputStream(seekableStream);
	         writeIndex(is);
	     	 is.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	} else {
		throw new IllegalArgumentException("plus file in location:" + path +" is needed to write a plus index.");
	}
}
 

import htsjdk.samtools.seekablestream.SeekableStreamFactory; //导入依赖的package包/类
public static void addFileForPattern(DBRunConfigBean db, List<DBRunConfigBean> dbs) {
	final String path = db.getDbPath().trim();
	if(!SeekableStreamFactory.isFilePath(path) || path.indexOf("*") == -1) {
  		 	db.checkDBConfig();
  		 	dbs.add(db);
	} else {
		final IndexFormat format = db.getIndexFormat();
		final List<String> files = IOutils.readFileWithPattern(db.getDb());
    	
		for (String file : files) {
    		 db = new DBRunConfigBean();
    		 db.setDb(file);
    		 if(format != null) db.setIndexFormat(format); 
			 else db.setDbIndex();
    		 db.checkDBConfig();
    		 dbs.add(db);
    	}
	}
}
 

import htsjdk.samtools.seekablestream.SeekableStreamFactory; //导入依赖的package包/类
public void initStream() {
	File inputFile = new File(path);
	if(inputFile.exists() && inputFile.getName().toLowerCase().endsWith(IntervalIndex.PLUS_EXTENSION)) {
		try {
			 final ISeekableStreamFactory ssf = SeekableStreamFactory.getInstance();
	         final SeekableStream seekableStream =
	                    ssf.getBufferedStream(ssf.getStreamFor(inputFile.getAbsolutePath()));
	         BlockCompressedInputStream is = new BlockCompressedInputStream(seekableStream);
	         writeIndex(is);
	     	 is.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	} else {
		throw new IllegalArgumentException("plus file is needed to write a plus index.");
	}
}
 

import htsjdk.samtools.seekablestream.SeekableStreamFactory; //导入依赖的package包/类
/**
 * Read the bytes between file position posStart and posEnd
 */
private byte[] readBytes(long posStart, long posEnd) throws IOException {

    SeekableStream ss = null;
    try {
        ss = SeekableStreamFactory.getInstance().getStreamFor(path);
        int nBytes = (int) (posEnd - posStart);
        byte[] bytes = new byte[nBytes];
        ss.seek(posStart);
        ss.readFully(bytes);
        return bytes;
    } finally {
        if (ss != null) {
            ss.close();
        }
    }
}
 

import htsjdk.samtools.seekablestream.SeekableStreamFactory; //导入依赖的package包/类
private InputStream createStream(final FileInputStream fileStream) throws IOException {
    // if this looks like a block compressed file and it in fact is, we will use it
    // otherwise we will use the file as is
    if (!AbstractFeatureReader.hasBlockCompressedExtension(inputFile)) {
        return fileStream;
    }

    // make a buffered stream to test that this is in fact a valid block compressed file
    final int bufferSize = Math.max(Defaults.BUFFER_SIZE,
            BlockCompressedStreamConstants.MAX_COMPRESSED_BLOCK_SIZE);
    final BufferedInputStream bufferedStream = new BufferedInputStream(fileStream, bufferSize);

    if (!BlockCompressedInputStream.isValidFile(bufferedStream)) {
        throw new TribbleException.MalformedFeatureFile(
                "Input file is not in valid block compressed format.", inputFile.getAbsolutePath());
    }

    final ISeekableStreamFactory ssf = SeekableStreamFactory.getInstance();
    // if we got here, the file is valid, make a SeekableStream for the BlockCompressedInputStream
    // to read from
    final SeekableStream seekableStream =
            ssf.getBufferedStream(ssf.getStreamFor(inputFile.getAbsolutePath()));
    return new BlockCompressedInputStream(seekableStream);
}
 

import htsjdk.samtools.seekablestream.SeekableStreamFactory; //导入依赖的package包/类
public SweepPlusReader(final String fn, final Index idx, final String plusFn, final AbstractReaderStack stack, Printter printter) throws IOException {
	super(fn, idx, stack);
	plus = new BlockCompressedInputStream(SeekableStreamFactory.getInstance().getBufferedStream(SeekableStreamFactory.getInstance().getStreamFor(plusFn)));

	if(stack.getResultProcessor() instanceof MyResultProcess) {
		((MyResultProcess)stack.getResultProcessor()).setProcessor(this);
	}
	dbPrintter = printter;
}
 

import htsjdk.samtools.seekablestream.SeekableStreamFactory; //导入依赖的package包/类
public MixPlusReader(final String fn, final Index idx, final String plusFn, final AbstractReaderStack stack, Printter printter) throws IOException {
	super(fn, idx, stack);
	
	plus = new BlockCompressedInputStream(SeekableStreamFactory.getInstance().getBufferedStream(SeekableStreamFactory.getInstance().getStreamFor(plusFn)));
	
	if(stack.getResultProcessor() instanceof MyResultProcess) {
		((MyResultProcess)stack.getResultProcessor()).setProcessor(this);
	}
	dbPrintter = printter;
}
 

import htsjdk.samtools.seekablestream.SeekableStreamFactory; //导入依赖的package包/类
public BlockReader(final String fn, final String idxFn, final String plusFn, final AbstractReaderStack stack, Printter printter) throws IOException {
  	super(fn, idxFn);
  	this.stack = stack;
  	plus = new BlockCompressedInputStream(SeekableStreamFactory.getInstance().getBufferedStream(SeekableStreamFactory.getInstance().getStreamFor(plusFn)));

if(stack.getResultProcessor() instanceof MyResultProcess) {
	((MyResultProcess)stack.getResultProcessor()).setProcessor(this);
}
dbPrintter = printter;
  	readAllIndex();
  }
 

import htsjdk.samtools.seekablestream.SeekableStreamFactory; //导入依赖的package包/类
public void readFile() {
       ISeekableStreamFactory ssf = SeekableStreamFactory.getInstance();
       SeekableStream fp;
	try {
		fp = ssf.getBufferedStream(ssf.getStreamFor(mIdxFn), 128000);
		if (fp == null)  return ;
		
		BlockCompressedInputStream is = new BlockCompressedInputStream(fp);
		readFile(is);
        is.close();
	} catch (IOException e) {
		e.printStackTrace();
	}
}
 

import htsjdk.samtools.seekablestream.SeekableStreamFactory; //导入依赖的package包/类
public static boolean isExist(String path) {
	if(!SeekableStreamFactory.isFilePath(path)) {
		return exists(path);
	} else {
		return new File(path).exists();
	}
}
 

import htsjdk.samtools.seekablestream.SeekableStreamFactory; //导入依赖的package包/类
public void setDbIndex() {
	if(!SeekableStreamFactory.isFilePath(db)) {
		if(this.indexFormat == null) {
			throw new IllegalArgumentException("Please set up index format for remote file.");
		} else if(this.indexFormat == IndexFormat.TBI) {
			this.dbIndex = this.db + TabixUtils.STANDARD_INDEX_EXTENSION;
			if(!isExist(this.dbIndex))
				throw new IllegalArgumentException("Index file: " + this.dbIndex + " is not find.");
		} else {
			this.dbIndex = this.db + BinIndexWriter.PLUS_INDEX_EXTENSION;
			this.plusFile = this.db + BinIndexWriter.PLUS_EXTENSION;
			if(!isExist(this.dbIndex)) throw new IllegalArgumentException("Index file: " + this.dbIndex + " is not find.");
			if(!isExist(this.plusFile)) throw new IllegalArgumentException("Plus file: " + this.plusFile + " is not find.");
		}
	} else {
		if(this.indexFormat == IndexFormat.PLUS) {
			checkPlus();
		} else if(this.indexFormat == IndexFormat.TBI){
			checkTbi();
		} else {
			this.dbIndex = this.db + BinIndexWriter.PLUS_INDEX_EXTENSION;
			if(!isExist(this.dbIndex)) {
				this.dbIndex = this.db + TabixUtils.STANDARD_INDEX_EXTENSION;
				if(!isExist(this.dbIndex)) {
					throw new IllegalArgumentException("We support two types of index file. The first is the tabix index file, the second type needs plus file and plus index file both. Please put the index in the same folder with the database file!");
				} else {
					this.indexFormat = IndexFormat.TBI;
				}
			} else {
				this.plusFile = this.db + BinIndexWriter.PLUS_EXTENSION;
				if(!isExist(this.plusFile)) {
					throw new IllegalArgumentException("We cannot find plus file: "+ this.plusFile + ", you must put plus file and plus index file in the same folder!");
				} else {
					this.indexFormat = IndexFormat.PLUS;
				}
			}
		}
	}
	idx = IndexFactory.readIndex(dbIndex);
}
 

import htsjdk.samtools.seekablestream.SeekableStreamFactory; //导入依赖的package包/类
public static VCFHeader getHeader(String filePath) {
    try {
        return VCFHeaderReader.readHeaderFrom(SeekableStreamFactory.getInstance().getStreamFor(filePath));
    } catch (IOException e) {
        throw new UserException("Failed to read VCF header from " + filePath + "\n Caused by:" + e.getMessage(), e);
    }
}
 

import htsjdk.samtools.seekablestream.SeekableStreamFactory; //导入依赖的package包/类
public static void main(String[] args) {	
	    long t1 = System.currentTimeMillis();
		try {
			
//			final BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream("/Users/mulin/Desktop/linlin/out.vcf")));
//			String s;
//			int i=0;
//			while((s = reader.readLine()) != null) {
//				i++;
//			}
//			reader.close();
//			System.out.println(i);
			
//			int core = 6;
//		    BZIP2InputStream bz2_text = new BZIP2InputStream("/Users/mulin/Desktop/linlin/out.vcf", core);
//	
//		    bz2_text.adjustPos();
//		    bz2_text.creatSpider();
//		    
//		    Reducer<Integer, Mapper<Integer>, Integer> r = new Reducer<Integer, Mapper<Integer>, Integer>() {
//				public Integer doReducer(List<Mapper<Integer>> mappers) {
//					for (Mapper<Integer> mapper : mappers) {
//						System.out.println(mapper.getResult());
//					}		
//					return null;
//				}
//			};
//			
//		    SimpleMapReduce mr = new SimpleMapReduce<Integer, Integer>(core, r);
//		    Spider spider;
//		    for (int i = 0; i < core; i++) {
//		    	spider = bz2_text.spider[i];
//		    	mr.addMapper(new TestMapper<Integer>(spider));
//			}
//		    mr.getResult();
//
//
//			long t2 = System.currentTimeMillis();
//
//			System.out.println("Time:" + (t2 - t1));
//			System.out.println(Runtime.getRuntime().availableProcessors());
			
			
			BlockCompressedInputStream plus = new BlockCompressedInputStream(SeekableStreamFactory.getInstance().getBufferedStream(SeekableStreamFactory.getInstance().getStreamFor("/Users/mulin/Desktop/dbNSFP3.0a.ANN.bgz.plus")));
			int tid;
			while(true) {
				tid = BasicUtils.readInt(plus);  if(tid == IntervalIndex.PLUS_FILE_END) break;
				
				BasicUtils.readInt(plus);
				BasicUtils.readInt(plus);
				
		
				System.out.println(BasicUtils.readLong(plus));

			}
		
			long t2 = System.currentTimeMillis();
			System.out.println("Time:" + (t2 - t1));
		} catch (Exception e) {
			e.printStackTrace();
		} 
	}
 

import htsjdk.samtools.seekablestream.SeekableStreamFactory; //导入依赖的package包/类
/**
 * @param fn File name of the data file
 */
public TabixReaderMod(final String fn) throws IOException {
    this(fn, null, SeekableStreamFactory.getInstance().getBufferedStream(SeekableStreamFactory.getInstance().getStreamFor(fn)));
}
 

import htsjdk.samtools.seekablestream.SeekableStreamFactory; //导入依赖的package包/类
/**
 * Read the Tabix index from the default file.
 */
private void readIndex() throws IOException {
    ISeekableStreamFactory ssf = SeekableStreamFactory.getInstance();
    readIndex(ssf.getBufferedStream(ssf.getStreamFor(mIdxFn), 128000));
}
 

import htsjdk.samtools.seekablestream.SeekableStreamFactory; //导入依赖的package包/类
public BBFileReader(String path, BedTrack track) throws IOException {
	
    this(path, SeekableStreamFactory.getInstance().getStreamFor(path), track);

}