# All Classes and Interfaces

Class
Description
AbstractAsyncWriter<T>
Abstract class that is designed to be extended and specialized to provide an asynchronous wrapper around any kind of Writer class that takes an object and writes it out somehow.
AbstractBAMFileIndex
Provides basic, generic capabilities to be used reading BAM index files.
AbstractFeatureCodec<FEATURE_TYPE,SOURCE>
Simple basic class providing much of the basic functionality of codecs Every concrete subclass must implement `FeatureCodec.canDecode(String)` to indicate whether it can decode the file.
AbstractFeatureReader<T,SOURCE>
jrobinso
AbstractFeatureReader.ComponentMethods
AbstractIndex
An abstract implementation of the index class.
AbstractIndex.BlockStats
AbstractIndex.IndexType
AbstractIterator<E>
Base class of implementing iterators.
AbstractJavascriptFilter<HEADER,TYPE>
Javascript filter with HEADER type containing TYPE records.
AbstractLocusInfo<E>
The unit of iteration for AbstractLocusIterator.
AbstractLocusIterator<T,K>
Iterator that traverses a SAM File, accumulating information on a per-locus basis.
AbstractProgressLogger
Abstract implementation of a Little progress logging class to facilitate consistent output of useful information when progressing through a stream of SAM records.
AbstractRecordAndOffset
Holds a SAMRecord plus the zero-based offset into that SAMRecord's bases and quality scores that corresponds to the base and quality at the genomic position described the containing AbstractLocusInfo.
AbstractRecordAndOffset.AlignmentType
Classifies whether the given event is a match, insertion, or deletion.
AbstractSAMHeaderRecord
Base class for the various concrete records in a SAM header, providing uniform access to the attributes.
AbstractVCFCodec
AggregateFilter
Aggregates multiple filters and provides a method for applying them all to a given record with one method call.
AlignedFilter
Filter to either include or exclude aligned reads $Id$
AlignmentBlock
Represents the contiguous alignment of a subset of read bases to a reference sequence.
AlignmentContext
An AlignmentContext represents mapping information related to a collection of reads, or a single `CRAMCompressionRecord`, `Slice`, or `Container`.
AlignmentSpan
A span of over a single reference.
Allele
Immutable representation of an allele.
AllRefsTabixIndexCreator
This is a copy of `TabixIndexCreator`, except sequence names are populated from the header, not from the ones that are seen.
ArithmeticDecoder
AsciiFeatureCodec<T>
A convenience base class for codecs that want to read in features from ASCII lines.
AsciiLineReader
A simple class that provides `AsciiLineReader.readLine()` functionality around a PositionalBufferedStream `BufferedReader` and its `BufferedReader.readLine()` method should be used in preference to this class (when the `LocationAware` functionality is not required) because it offers greater performance.
AsciiLineReaderIterator
A class that iterates over the lines and line positions in an `AsciiLineReader`.
AsciiWriter
Fast (I hope) buffered Writer that converts char to byte merely by casting, rather than charset conversion.
AsyncBlockCompressedInputStream
Asynchronous read-ahead implementation of `BlockCompressedInputStream`.
AsyncBufferedIterator<T>
Iterator that uses a dedicated background thread to perform read-ahead to improve throughput at the expense of increased latency.
AsyncFastqWriter
Implementation of a FastqWriter that provides asynchronous output.
AsyncVariantContextWriter
AsyncVariantContextWriter that can be wrapped around an underlying AsyncVariantContextWriter to provide asynchronous output.
AsyncWriterPool
Implementation of an asynchronous writer pool.
BAIEntry
Class used to construct a BAI index for a CRAM file.
BAMCodec
InternalAPI Base class for `BundleResourceType.FMT_READS_BAM` codecs.
BAMCodecV1_0
BAM v1.0 codec.
BAMDecoder
InternalAPI Base class for `BundleResourceType.FMT_READS_BAM` decoders.
BAMDecoderOptions
Decoder options specific to BAM decoders.
BAMDecoderV1_0
BAM v1.0 decoder.
BAMEncoder
InternalAPI Base class for `BundleResourceType.FMT_READS_BAM` encoders.
BAMEncoderOptions
Encoder options specific to BAM encoders.
BAMEncoderV1_0
BAM v1.0 encoder.
BamFileIoUtils
BAMFileReader
Class for reading and querying BAM files.
BAMFileSpan
An ordered list of chunks, capable of representing a set of discontiguous regions in the BAM file.
BAMFileWriter
Concrete implementation of SAMFileWriter for writing gzipped BAM files.
BAMIndex
A basic interface for querying BAM indices.
BAMIndexer
Class for both constructing BAM index content and writing it out.
BAMIndexMerger
Merges BAM index files for (headerless) parts of a BAM file into a single index file.
BAMIndexMetaData
Metadata about the bam index contained within the bam index.
BamIndexValidator
Class to validate (at two different levels of thoroughness) the index for a BAM file.
BamIndexValidator.IndexValidationStringency
BAMQueryMultipleIntervalsIteratorFilter
Filters out records that do not match any of the given intervals and query type.
BAMRecord
Wrapper class for binary BAM records.
BAMRecordCodec
Class for translating between in-memory and disk representation of BAMRecord.
BAMSBIIndexer
Writes SBI files for BAM files, as understood by `SBIIndex`.
BAMStartingAtIteratorFilter
A decorating iterator that filters out records that do not match the given reference and start position.
BAMStreamWriter
Class for writing SAMRecords in BAM format to an output stream.
BaseQualityScore
A read feature representing a single quality score in a read.
Bases
BasicFastqWriter
In general FastqWriterFactory should be used so that AsyncFastqWriter can be enabled, but there are some cases in which that behavior is explicitly not wanted.
BCF2Codec
Decode BCF2 files
BCF2Codec.LazyData
BCF2Codec.SitesInfoForDecoding
BCF2Decoder
BCF2Encoder
See #BCFWriter for documentation on this classes role in encoding BCF2 files
BCF2FieldEncoder
See #BCFWriter for documentation on this classes role in encoding BCF2 files
BCF2FieldEncoder.AtomicInt
Specialized int encoder for atomic (non-list) integers
BCF2FieldEncoder.Flag
BCF2FieldEncoder.Float
BCF2FieldEncoder.GenericInts
BCF2FieldEncoder.IntArray
BCF2FieldEncoder.StringOrCharacter
BCF2FieldWriter
See #BCFWriter for documentation on this classes role in encoding BCF2 files
BCF2FieldWriter.FTGenotypesWriter
BCF2FieldWriter.GenericSiteWriter
BCF2FieldWriter.GenotypesWriter
BCF2FieldWriter.GTWriter
BCF2FieldWriter.IGFGenotypesWriter
BCF2FieldWriter.IntegerTypeGenotypesWriter
BCF2FieldWriter.SiteWriter
BCF2FieldWriter.StaticallyTypeGenotypesWriter
BCF2FieldWriterManager
See #BCFWriter for documentation on this classes role in encoding BCF2 files
BCF2GenotypeFieldDecoders
An efficient scheme for building and obtaining specialized genotype field decoders.
BCF2GenotypeFieldDecoders.Decoder
Decoder a field (implicit from creation) encoded as typeDescriptor in the decoder object in the GenotypeBuilders one for each sample in order.
BCF2LazyGenotypesDecoder
Lazy version of genotypes decoder for BCF2 genotypes
BCF2Type
BCF2 types and associated information
BCF2Utils
Common utilities for working with BCF2 files Includes convenience methods for encoding, decoding BCF2 type descriptors (size + type)
BCFVersion
Simple holder for BCF version information User: depristo Date: 8/2/12 Time: 2:16 PM
BEDCodec
Codec for parsing BED file, as described by UCSC See https://genome.ucsc.edu/FAQ/FAQformat.html#format1
BEDCodec.StartOffset
Indicate whether co-ordinates or 0-based or 1-based.
BEDFeature
BetaAPI
Annotation indicating that a package, class, method, or type is release level "BETA", and is not part of the stable public API.
BetaIntegerCodec
Encodes integers by adding a constant offset value to a range of values in order to reduce the necessary number of bits needed to store each value.
BetaIntegerEncoding
Bin
An individual bin in a BAM file.
BinaryCodec
Encapsulates file representation of various primitive data types.
BinaryFeatureCodec<T>
Implements common methods of `FeatureCodec`s that read from `PositionalBufferedStream`s.
BinaryTagCodec
Converter between disk and in-memory representation of a SAMRecord tag.
BinList
Provides a list of all bins which could exist in the BAM file.
BinningIndexBuilder
Builder for a BinningIndexContent object.
BinningIndexBuilder.FeatureToBeIndexed
coordinates are 1-based, inclusive
BinningIndexContent
In-memory representation of the binning index for a single reference.
BinningIndexContent.BinList
This class is used to encapsulate the list of Bins store in the BAMIndexContent While it is currently represented as an array, we may decide to change it to an ArrayList or other structure
BinomialCoefficientUtil
A modified version of the Apache Math implementation of binomial coefficient calculation Derived from code within the CombinatoricsUtils and FastMath classes within Commons Math3 (https://commons.apache.org/proper/commons-math/) Included here for use in Genotype Likelihoods calculation, instead of adding Commons Math3 as a dependency Commons Math3 is licensed using the Apache License 2.0 Full text of this license can be found here: https://www.apache.org/licenses/LICENSE-2.0.txt This product includes software developed at The Apache Software Foundation (http://www.apache.org/).
BinWithOffset
An individual bin of a CSI index for BAM files.
BitInputStream
An interface to describe the requirements for reading bit data as opposed to bytes.
BitOutputStream
An interface to describe the requirements for writing out bits as opposed to bytes.
Block
Class representing CRAM block concept and some methods to operate with block content.
Block
Represents a contiguous block of bytes in a file, defined by a start position and size (in bytes)
BlockCompressedFilePointerUtil
Static for manipulating virtual file pointers in BGZF files.
BlockCompressedIndexedFastaSequenceFile
A block-compressed FASTA file driven by an index for fast lookups.
BlockCompressedInputStream
Utility class for reading BGZF block compressed files.
BlockCompressedInputStream.DecompressedBlock
BlockCompressedInputStream.FileTermination
BlockCompressedOutputStream
Writer for a file that is a series of gzip blocks (BGZF format).
BlockCompressedStreamConstants
Constants shared by BlockCompressed{Input,Output}Stream classes
BlockCompressionMethod
The block compression methods specified by Section 8 of the CRAM spec.
BlockContentType
The block content types specified by Section 8.1 of the CRAM spec
BlockGunzipper
Alternative to GZIPInputStream, for decompressing GZIP blocks that are already loaded into a byte[].
BrowseableBAMIndex
An index interface with additional functionality for querying and inspecting the structure of a BAM index.
BufferedLineReader
Implementation of LineReader that is a thin wrapper around BufferedReader.
Bundle
An immutable collection of related resources, including a (single, required) primary resource, such as "reads", "variants", "features", or "reference", plus zero or more related secondary resources ("index", "dictionary", "MD5", etc.).
BundleBuilder
A builder class for `Bundle`s.
BundleJSON
Methods for serializing and deserializing Bundles to and from JSON strings.
BundleResource
Interface defined for bundle resource objects that may be included in a `Bundle`.
BundleResourceBase
Base class for `BundleResource` implementations.
BundleResourceType
Constants for specifying standard content types and formats for resources contained in a `Bundle`.
ByteArrayLenEncoding
NOTE: this encoding can be a hybrid encoding in that it ALLOWS for the possibility to split it's data between the core block and an external block (i.e., if lenEncoding is CORE and byteEncoding is EXTERNAL) This has implications for data access, since some of it's data is interleaved with other data in the core block.
ByteArraySeekableStream
Created by vadim on 23/03/2015.
ByteArrayStopEncoding
ByteModel
BZIP2ExternalCompressor
CanonicalHuffmanByteEncoding
CRAMEncoding class for Huffman byte values.
CanonicalHuffmanIntegerEncoding
CRAMEncoding class for Huffman integer values.
ChrIndex
Represents an index on a specific chromosome
Chunk
A [start,stop) file pointer pairing into the BAM file, stored as a BAM file index.
Cigar
A list of CigarElements, which describes how a read aligns with the reference.
CigarElement
One component of a cigar string.
CigarOperator
The operators that can appear in a cigar string, and information about their disk representations.
CigarUtil
ClassFinder
Utility class that can scan for classes in the classpath and find all the ones annotated with a particular annotation.
CloseableIterator<T>
This interface is used by iterators that use releasable resources during iteration.
CloseableTribbleIterator<T>
The basic iterator we use in Tribble, which allows closing and basic iteration.
CloserUtil
Utility to close things that implement Closeable WARNING: This should only be used for Closeable things open for read, because it ignores exceptions, and the caller will probably want to know about exceptions when closing a file being written to, because this may indicate a failure to flush.
CodecLineParsingException
Class CodecLineParsingException a generic exception we use if the codec has trouble parsing the line its given
CodeUtil
Miscellaneous util methods that don't fit anywhere else.
CollectionUtil
Small utility methods for dealing with collection classes.
CollectionUtil.DefaultingMap<K,V>
A defaulting map, which returns a default value when a value that does not exist in the map is looked up.
CollectionUtil.DefaultingMap.Factory<V,K>
CollectionUtil.MultiMap<K,V>
Simple multi-map for convenience of storing collections in map values.
CollectionUtil.Partitioner<V,K>
Deprecated.
use Collectors.groupingBy instead
CommonInfo
Common utility routines for VariantContext and Genotype
ComparableTuple<A,B>
A simple extension of the Tuple class that, for comparable Types, allows comparing Tuples of non-null elements.
CompoundFilter
A Predicate on VariantContexts that returns true when either all its sub-predicates are true, or none are false.
CompressionHeader
CompressionHeaderEncodingMap
Maintains a map of DataSeries to EncodingDescriptor, and a second map that contains the compressor to use for each EncodingDescriptor that represents an EXTERNAL encoding.
CompressionHeaderFactory
Factory for creating CRAM compression headers for containers when writing to a CRAM stream.
CompressionUtils
CompressorCache
Maintain a cache of reusable compressor instances in order to reduce the need to repeatedly instantiate them, since some, like the RANS de/compressor, allocate large numbers (~256k) of small temporary objects every time they're instantiated.
Constants
Constants
Container
Notes: Container will construct a container out of as many CRAMCompressionRecords as it is handed, respecting only the maximum number of slices.
ContainerFactory
Aggregates SAMRecord objects into one or more `Container`s, composed of one or more `Slice`s.
ContainerHeader
ContentDigests
ContentDigests.KNOWN_DIGESTS
CoordinateSortedPairInfoMap<KEY,REC>
Holds info about a mate pair for use when processing a coordinate sorted file.
CoordinateSortedPairInfoMap.Codec<KEY,REC>
Client must implement this class, which defines the way in which records are written to and read from file.
CoordMath
Static methods that encapsulate the standard SAM way of storing ranges: one-based, with both ends inclusive.
CoordSpanInputSteam
An input stream that wraps a `SeekableStream` to produce only bytes specified within coordinates.
CoreCodec<T>
Superclass of Codecs which operate on Core Block bit streams Contrast with `htsjdk.samtools.cram.encoding.external.ExternalCodec<T>` for External Block byte streams
CountingInputStream
An input stream that counts the bytes read from it.
CountRecords
An example of how to index a feature file, and then count all the records in the file.
CRAIEntry
A class representing CRAI index entry: file and alignment offsets for each slice.
CRAIIndex
CRAI index used for CRAM files.
CRAIIndexMerger
Merges CRAM index files for (headerless) parts of a CRAM file into a single index file.
CRAMBAIIndexer
Class for both constructing BAM index content and writing it out.
CRAMCodec
InternalAPI Base class for `BundleResourceType.FMT_READS_CRAM` codecs.
CRAMCodec<T>
An interface that defines requirements for serializing/deserializing objects into and from a stream.
CRAMCodecModelContext
Context model data/accumulators for use by CRAM 3.1 codec write implementations.
CRAMCodecV2_1
CRAM v2.1 codec
CRAMCodecV3_0
CRAM v3.0 codec
CRAMCodecV3_1
CRAM v3.1 codec
CRAMCompressionRecord
A CRAMRecord represents a SAMRecord that has been transformed to CRAM-style representation.
CramContainerHeaderIterator
Iterate over CRAM containers from an input stream, and unlike `CramContainerIterator` only the header of each container is read, rather than the whole stream.
CramContainerIterator
An iterator of CRAM containers read from an `InputStream`.
CRAMContainerStreamWriter
Class for writing SAMRecords into a series of CRAM containers on an output stream, with an optional index.
CRAMCRAIIndexer
Indexer for creating/reading/writing a CRAIIndex for a CRAM file/stream.
CRAMDecoder
InternalAPI Base class for `BundleResourceType.FMT_READS_CRAM` decoders.
CRAMDecoderOptions
Decoder options specific to CRAM decoders.
CRAMDecoderV2_1
CRAM v2.1decoder.
CRAMDecoderV3_0
CRAM v3.0 decoder.
CRAMDecoderV3_1
CRAM v3.1 decoder.
CRAMEncoder
InternalAPI Base class for `BundleResourceType.FMT_READS_CRAM` decoders.
CRAMEncoderOptions
Encoder options specific to CRAM encoders.
CRAMEncoderV2_1
CRAM v2.1 encoder.
CRAMEncoderV3_0
CRAM v3.0 encoder.
CRAMEncoderV3_1
CRAM v3.1 encoder.
CRAMEncoding<T>
A base class for the various CRAM encodings.
CRAMEncodingStrategy
Parameters that can be set to control the encoding strategy used when writing CRAM.
CRAMException
Created by edwardk on 8/13/15.
CRAMFileReader
`BAMFileReader` analogue for CRAM files.
CRAMFileWriter
CramHeader
A CRAM file header, including the file format definition (including CRAM version and content id), and the SAMFileHeader.
CRAMIndexer
Interface for indexing CRAM.
CramInt
Methods to read and write CRAM int values as given in the file format specification.
CramIntArray
Methods to read and write CRAM array of integers data type.
CramIO
A collection of methods to read and write special values to/from CRAM files.
CRAMIterator
CRAMLazyReferenceSource
A lazy CRAMReferenceSource implementation, for use when no explicit reference source has been provided by the user.
CramRecordReader
A reader used to consume and populate encoded `CRAMCompressionRecord`s from a set of streams representing data series/blocks in a Slice.
CRAMRecordReadFeatures
Class for handling the read features for a `CRAMCompressionRecord`.
CramRecordWriter
A writer that emits CRAMCompressionRecord into the various streams that represent a Slice's data series blocks.
CRAMReferenceRegion
Holds a region/fragment of a reference contig.
CRAMReferenceSource
Interface used to supply a reference source when reading CRAM files.
CramSpanContainerIterator
An iterator of CRAM containers read from locations in a `SeekableStream`.
CRAMVersion
A class to represent a version information, 3 number: major, minor and build number.
CramVersions
CRC32InputStream
An input stream that calculates CRC32 of all the bytes passed through it.
CRC32OutputStream
An output stream that calculates CRC32 checksum of all the bytes written through the stream.
CSIIndex
Implementation of the CSI index for BAM files.
CustomGzipOutputStream
Hacky little class used to allow us to set the compression level on a GZIP output stream which, for some bizarre reason, is not exposed in the standard API.
CustomReaderFactory
Factory for creating custom readers for accessing API based resources, e.g.
CustomReaderFactory.ICustomReaderFactory
Interface to be implemented by custom factory classes that register themselves with this factory and are loaded dynamically.
DataSeries
Represents a specific CRAM record data series and its associated type and unique Content ID.
DataSeriesReader<T>
A CRAM Data Series reader for a particular (Encoding, DataSeriesType) and associated parameters
DataSeriesType
Data series types known to CRAM.
DataSeriesWriter<T>
A CRAM Data Series writer for a particular Encoding, DataSeriesType and associated parameters
DateParser
NOTE: This code has been taken from w3.org, and modified slightly to handle timezones of the form [-+]DDDD, and also to fix a bug in the application of time zone to the parsed date.
DateParser.InvalidDateException
DefaultBitInputStream
Must not read from delegate unless no bits left in the buffer!!!
DefaultBitOutputStream
Defaults
Embodies defaults for global values that affect how the SAM JDK operates.
DefaultSAMRecordFactory
Default factory for creating SAM and BAM records used by the `SamReader` classes.
DeflaterFactory
Factory for `Deflater` objects used by `BlockCompressedOutputStream`.
DelegatingIterator<T>
Simple iterator class that delegates all method calls to an underlying iterator.
DeleteOnExitPathHook
Class to hold a set of `Path` to be delete on the JVM exit through a shutdown hook.
Deletion
A read feature representing a deletion of one or more bases similar to `CigarOperator.D`.
DiskBackedQueue<E>
A single-ended FIFO queue.
DiskBasedBAMFileIndex
A class for reading BAM file indices, hitting the disk once per query.
DownsamplingIterator
Abstract base class for all DownsamplingIterators that provides a uniform interface for recording and reporting statistics bout how many records have been kept and discarded.
DownsamplingIteratorFactory
A factory for creating DownsamplingIterators that uses a number of different strategies to achieve downsampling while meeting various criteria.
DownsamplingIteratorFactory.Strategy
Describes the available downsampling strategies.
DuplicateReadFilter
Filter out SAMRecords with DuplicateRead flag set $Id$
DuplicateScoringStrategy
This class helps us compute and compare duplicate scores, which are used for selecting the non-duplicate during duplicate marking (see MarkDuplicates).
DuplicateScoringStrategy.ScoringStrategy
DuplicateSet
Stores a set of records that are duplicates of each other.
DuplicateSetIterator
An iterator of sets of duplicates.
DynamicIndexCreator
A DynamicIndexCreator creates the proper index based on an `IndexFactory.IndexBalanceApproach` and the characteristics of the file.
EdgeReadIterator
Iterator that traverses a SAM File, accumulating information on a per-locus basis.
EdgingRecordAndOffset
Holds a SAMRecord plus the zero-based offset into that SAMRecord's bases and quality scores that corresponds to the base and quality for the start of alignment block at the genomic position described by the AbstractLocusInfo.
EdgingRecordAndOffset.Type
Describes the type of `TypedRecordAndOffset`, whether it represents the start or the end of an alignment block.
EnaRefService
EncodeToken
A token that represents one fragment of a read name that has been tokenized.
EncodeToken.DupOrDiffToken
EncodeToken.EndToken
EncodingDescriptor
A class for representing an encoding, including encoding-specific parameters, suitable for serialization to/from a stream.
EncodingFactory
A helper class to choose and instantiate an appropriate `CRAMEncoding` given a `DataSeriesType` and an `EncodingDescriptor`.
EncodingID
Encoding ID as specified by Section 3 of the CRAM spec.
ExampleBinaryCodec
An example binary codec that encodes / decodes contig / start / stop values via DataInputStreams
ExampleSamUsage
ExternalByteArrayCodec
Encode Byte Arrays using an External Data Block
ExternalByteArrayEncoding
ExternalByteEncoding
ExternalCompressor
ExternalEncoding<T>
ExternalIntegerEncoding
ExternalLongEncoding
FailsVendorReadQualityFilter
Filter for filtering out reads that do not pass the quality filter $Id$
FASTACodecV1_0
The v1.0 FASTA codec.
FASTADecoderV1_0
The v1.0 FASTA decoder.
FastaReferenceWriter
Writes a FASTA formatted reference file.
FastaReferenceWriterBuilder
Buider for a `FastaReferenceWriter`
FastaSequenceFile
Implementation of ReferenceSequenceFile for reading from FASTA files.
FastaSequenceIndex
Reads/writes a fasta index file (.fai), as generated by `samtools faidx`.
FastaSequenceIndexCreator
Static methods to create an `FastaSequenceIndex`.
FastaSequenceIndexEntry
Hold an individual entry in a fasta sequence index file.
FastGenotype
This class encompasses all the basic information about a genotype.
FastLineReader
Line-oriented InputStream reader that uses one buffer for disk buffering and line-termination-finding, in order to improve performance.
FastqConstants
FastqConstants.FastqExtensions
FastqEncoder
Codec for encoding records into FASTQ format.
FastqQualityFormat
Enumeration for FastQ quality score formats formats.
FastqReader
Reads a FASTQ file with four lines per record.
FastqReader.LineType
Enum of the types of lines we see in Fastq.
FastqRecord
Simple representation of a FASTQ record, without any conversion
FastqWriter
Simple interface for a class that can write out fastq records.
FastqWriterFactory
Factory class for creating FastqWriter objects.
Feature
Marker interface for Locatables with Tribble support.
FeatureCodec<FEATURE_TYPE,SOURCE>
The base interface for classes that read in features.
FeatureCodecHeader
A class to represent a header of a feature containing file.
FeatureReader<T>
the basic interface that feature sources need to match
FileAppendStreamLRUCache
LRU cache of OutputStreams to handle situation in which it is necessary to have more FileOutputStreams than resource limits will allow.
FileExtensions
Contains file extension constants for read, alignment, variant and annotation files
FileTruncatedException
Thrown when it is possible to detect that a SAM or BAM file is truncated.
FilteringIterator
Deprecated.
use `FilteringSamIterator` instead
FilteringIterator
Deprecated.
since 2/29/16 use `FilteringVariantContextIterator` instead
FilteringSamIterator
Filtering Iterator which takes a filter and an iterator and iterates through only those records which are not rejected by the filter.
FilteringVariantContextIterator
A filtering iterator for VariantContexts that takes a base iterator and a VariantContextFilter.
FormatUtil
Simple class used to format object values into a standard format for printing.
FQZCompDecode
Decoder for the CRAM 3.1 FQZComp codec, used for compressing quality scores.
FQZCompEncode
Placeholder for the (not yet implemented) CRAM 3.1 FQZComp quality score encoder.
FQZCompExternalCompressor
FQZGlobalFlags
FQZModels
FQZParam
FQZParams
FQZState
FQZUtils
FTPClient
FTPHelper
FTPReply
FTPStream
A "non-seekable" ftp stream.
FTPUtils
FullBEDFeature
Object for full BED file.
GammaIntegerEncoding
GaveUpException
GeneralUtils
Constants and utility methods used throughout the VCF/BCF/VariantContext classes
GenomicIndexUtil
Constants and methods used by BAM and Tribble indices
Genotype
This class encompasses all the basic information about a genotype.
GenotypeBuilder
A builder class for genotypes Provides convenience setter methods for all of the Genotype field values.
GenotypeJEXLContext
GenotypeLikelihoods
GenotypeLikelihoods.GenotypeLikelihoodsAllelePair
GenotypeQualityFilter
A Predicate on VariantContexts that returns true at sites that are either unfiltered, or passing (as variants).
GenotypesContext
Represents an ordered collection of Genotype objects
GenotypeType
Summary types for Genotype objects
Gff3BaseData
Gff3Codec
Codec for parsing Gff3 files, as defined in https://github.com/The-Sequence-Ontology/Specifications/blob/31f62ad469b31769b43af42e0903448db1826925/gff3.md Note that while spec states that all feature types must be defined in sequence ontology, this implementation makes no check on feature types, and allows any string as feature type Each feature line in the Gff3 file will be emitted as a separate feature.
Gff3Codec.DecodeDepth
Gff3Codec.Gff3Directive
Enum for parsing directive lines.
Gff3Constants
Gff3Feature
Gff3 format spec is defined at https://github.com/The-Sequence-Ontology/Specifications/blob/31f62ad469b31769b43af42e0903448db1826925/gff3.md Discontinuous features which are split between multiple lines in the gff files are implemented as separate features linked as "co-features"
Gff3FeatureImpl
Gff3 format spec is defined at https://github.com/The-Sequence-Ontology/Specifications/blob/31f62ad469b31769b43af42e0903448db1826925/gff3.md Discontinuous features which are split between multiple lines in the gff files are implemented as separate features linked as "co-features"
Gff3Writer
A class to write out gff3 files.
GolombIntegerEncoding
GolombLongEncoding
GolombRiceIntegerEncoding
GZIIndex
Represents a .gzi index of a block-compressed file.
GZIIndex.GZIIndexer
Helper class for constructing the GZIindex.
GZIIndex.IndexEntry
Index entry mapping the block-offset (compressed offset) to the uncompressed offset where the block starts.
GZIPExternalCompressor
HaploidReferenceCodec
Base class for all `HtsContentType.HAPLOID_REFERENCE` codecs.
HaploidReferenceDecoder
Base class for all `HtsContentType.HAPLOID_REFERENCE` decoders.
HaploidReferenceDecoderOptions
Class for haploid reference decoder options.
HaploidReferenceEncoder
Base class for all `HtsContentType.HAPLOID_REFERENCE` encoders.
HaploidReferenceEncoderOptions
Class for haploid reference encoder options.
HaploidReferenceFormats
Class with string constants representing the file formats supported by haploid reference codecs.
HaploidReferenceResolver
Class with methods for resolving inputs and outputs to haploid reference encoders and decoders.
HapRefDecoderOptions
Class for haploid reference decoder options.
HardClip
A read feature representing a hard clip similar to `CigarOperator.H`.
HardyWeinbergCalculation
This class calculates a HardyWeinberg p-value given three values representing the observed frequences of homozygous and heterozygous genotypes in the test population.
Header
A header for a metrics file.
HeterozygosityFilter
A Predicate on VariantContexts that either returns true at heterozygous sites (invertible to false).
Histogram<K>
Class for computing and accessing histogram type data.
Histogram.Bin<K>
Represents a bin in the Histogram.
HtsCodec<D,E>
Base interface implemented by all `htsjdk.beta.plugin` codecs.
HtsCodecRegistry
A registry for tracking `HtsCodec` instances.
HtsCodecResolver<C>
Base class for content-type-specific resolvers, with methods for resolving an input or output resource to a codec that can supply an encoder or decoder for that resource.
HtsContentType
The plugin framework defines a set of supported content types, each of which represents a type of HTS data such as "aligned reads".
HtsDecoder<H,R>
Base interface for decoders.
HtsDecoderOptions
Base tag interface for options for `HtsDecoder`s.
HtsDefaultRegistry
A global, static, immutable, public registry for `HtsCodec` instances.
HtsEncoder<H,R>
Base interface for encoders.
HtsEncoderOptions
Base tag interface for options for `HtsEncoder`s.
HtsgetBAMCodec
Base class for concrete implementations of reads codecs that handle `BundleResourceType.FMT_READS_HTSGET_BAM` codecs.
HtsgetBAMCodecV1_2
Version 1.2 of `BundleResourceType.FMT_READS_HTSGET_BAM` codec.
HtsgetBAMDecoder
Base class for concrete implementations of reads decoders that handle `BundleResourceType.FMT_READS_HTSGET_BAM` decoding.
HtsgetBAMDecoderV1_2
Version 1.2 of `BundleResourceType.FMT_READS_HTSGET_BAM` decoder.
HtsgetBAMFileReader
Class for reading and querying BAM files from an htsget source
HtsgetBAMFileReader.BAMQueryMultipleIntervalsIteratorFilter
Filters out records that do not match any of the given intervals and query type.
HtsgetClass
Classes of data that can be requested in an htsget request as defined by the spec
HtsgetErrorResponse
Class allowing deserialization from json htsget error response, as defined in https://samtools.github.io/hts-specs/htsget.html An example response could be as follows { "htsget": { "error": "NotFound", "message": "No such accession 'ENS16232164'" } }
HtsgetFormat
Formats currently supported by htsget as defined by spec
HtsgetMalformedResponseException
HtsgetPOSTRequest
Builder for an htsget POST request that allows opening a connection using the request after validating that it is properly formed.
HtsgetRequest
Builder for an htsget GET request that allows opening a connection using the request after validating that it is properly formed.
HtsgetRequestField
Fields which can be used to filter a htsget request as defined by the spec
HtsgetResponse
Class allowing deserialization from json htsget response, as defined in https://samtools.github.io/hts-specs/htsget.html
HtsgetResponse.Block
HtsHeader
Tagging interface used as a type-bound for codec/encoder/decoder header type params.
HtsInterval
A common interface for 1-based, closed genomic intervals.
HtsIntervalUtils
Methods for interconverting between HtsQueryInterval and existing htsjdk types such as Locatable/QueryInterval
HtsjdkException
Exception type for all exceptions caused at runtime by HTSJDK.
HtsjdkIOException
A RuntimeException-derived class for propagating IOExceptions caught and rethrown by the plugin framework.
HtsjdkPluginException
Base class for unexpected conditions caused by codec plugins.
HtsjdkUnsupportedOperationException
Exception thrown when a requested operation is not supported by a plugin codec.
HtsPath
Default implementation for IOPath.
HtsQuery<RECORD>
Common query interface for `HtsDecoder`s
HtsQueryInterval
An concrete query interval implementation of `HtsInterval` used for random access queries on file formats represented by `HtsDecoder`s that support random access.
HtsQueryRule
Query rule values used to determine signal whether a query should match overlapping or contained records.
HtsRecord
Tagging interface used as a type-bound for codec/encoder/decoder record type params.
HtsVersion
A class for representing 3-part versions with major, minor and patch segments.
HTTPHelper
Simple implementation of URLHelper based on the JDK URL and HttpURLConnection classes.
HttpUtils
User: jrobinso Date: Sep 23, 2009
HuffmanBitCode<T>
Huffman bit code word consisting of a symbol, the corresponding codeword and codeword bit length.
HuffmanCanoncialCodeGenerator<T>
Given a set of `HuffmanParams`, creates the set of canonical codes that are be used to read/write symbols from/to an output/input stream.
HuffmanParams<T>
A class for carrying around encoding parameters for a canonical Huffman encoder.
HuffmanParamsCalculator<T>
A utility class that calculates Huffman encoding parameters based on the frequencies of the symbols to be encoded.
Index
Interface for all index implementations.
IndexCreator
An interface for creating indexes
IndexedFastaSequenceFile
A fasta file driven by an index for fast, concurrent lookups.
IndexFactory
Factory class for creating indexes.
IndexFactory.IndexBalanceApproach
We can optimize index-file-creation for different factors.
IndexFactory.IndexType
an enum that contains all of the information about the index types, and how to create them
IndexMerger<T>
Merges index files for (headerless) parts of a partitioned main file into a single index file.
IndexToTable
IndicesAreEqual
Check with two index files are equal
InflaterFactory
Factory for `Inflater` objects used by `BlockGunzipper`.
InputStreamResource
A `BundleResource` backed by an `InputStream`.
InputStreamUtils
Convenience methods to read from `InputStream`.
InsertBase
A read feature representing a single insert base.
Insertion
A read feature representing a multi-base insertion.
InsertSizeFilter
Filter things that fall outside a specified range of insert sizes.
InternalAPI
Annotation indicating that a package, class, method, or type is release level "internal", even if the access modifier is "public".
Interval
Represents a simple interval on a sequence.
Interval
Quick and dirty interval class Describes a genomic interval and where in a file information for that interval can be obtained
IntervalCodec
IntervalCoordinateComparator
Comparator that orders intervals based on their sequence index, by coordinate then by strand and finally by name.
IntervalFilter
Filter SAMRecords so that only those that overlap the given list of intervals.
IntervalIndexCreator
Creates interval indexes from a stream of features
IntervalKeepPairFilter
Filter out SAMRecords where neither record of a pair overlaps a given set of intervals.
IntervalList
Represents a list of intervals against a reference sequence that can be written to and read from a file.
IntervalList.IntervalMergerIterator
An iterator that feeds on an `Iterator<Interval>` and combines consecutive intervals that need merging.
IntervalListCodec
A tribble codec for IntervalLists.
IntervalListReferenceSequenceMask
Serve up loci of interest based on an interval list.
IntervalListWriter
Writes out the list of intervals to the supplied file.
IntervalTree<V>
A Red-Black tree with intervals for keys.
IntervalTree
An implementation of an interval tree, following the explanation.
IntervalTree.Node<V1>
IntervalTree.ValuesIterator<V1>
IntervalTreeIndex
Index based on an interval tree
IntervalTreeIndex.ChrIndex
IntervalTreeMap<T>
Utility class that implements an interval map.
IntervalUtil
IntervalUtil.IntervalCombiner
IntGenotypeFieldAccessors
A convenient way to provide a single view on the many int and int[] field values we work with, for writing out the values.
IntGenotypeFieldAccessors.Accessor
IntGenotypeFieldAccessors.ADAccessor
IntGenotypeFieldAccessors.DPAccessor
IntGenotypeFieldAccessors.GQAccessor
IntGenotypeFieldAccessors.PLAccessor
InvertFilter
Wraps an existing filter and inverts it.
IOPath
Interface for htsjdk input/output paths/URIs.
IOPathResource
A `BundleResource` backed by an `IOPath`.
IOPathUtils
IOUtil
Miscellaneous stateless static IO-oriented methods.
IOUtils
Class for updated IOUtils methods that use either `IOPath` `Path` in public method argument lists.
ISeekableStreamFactory
Factory for creating `SeekableStream`s based on URLs/paths.
Iso8601Date
Use this type rather than java.util.Date in command-line options in order to get ISO 8601 parsing.
IterableAdapter<T>
Provides an adapter to wrap an Iterator with an Iterable, allowing it to be run through a foreach loop.
IterableOnceIterator<T>
Abstract implementation of an iterator that also implements Iterable (to return itself) so that it can be used if for() loops.
Iterables
ITF8
Methods to read and write int values as per ITF8 specification in CRAM.
JavascriptSamRecordFilter
javascript based read filter The script puts the following variables in the script context: - 'record' a SamRecord ( https://github.com/samtools/htsjdk/blob/master/src/java/htsjdk/samtools/ SAMRecord.java ) - 'header' ( https://github.com/samtools/htsjdk/blob/master/src/java/htsjdk/samtools/ SAMFileHeader.java )
JavascriptVariantFilter
javascript based variant filter The script puts the following variables in the script context: - 'header' a htsjdk.variant.vcf.VCFHeader - 'variant' a htsjdk.variant.variantcontext.VariantContext
JexlMissingValueTreatment
How to treat values that appear in a jexl expression but are missing in the context it's applied to
Lazy<T>
Simple utility for building an on-demand (lazy) object-initializer.
Lazy.LazyInitializer<T>
Deprecated.
since 1/2017 use a `Supplier` instead
LazyGenotypesContext
Lazy-loading GenotypesContext.
LazyGenotypesContext.LazyData
Returns the data used in the full GenotypesContext constructor `GenotypesContext(java.util.ArrayList, java.util.Map, java.util.List)`
LazyGenotypesContext.LazyParser
Simple lazy parser interface.
LiftOver
Java port of UCSC liftOver.
LiftOver.PartialLiftover
Represents a portion of a liftover operation, for use in diagnosing liftover failures.
LinearIndex
The linear index associated with a given reference in a BAM index.
LinearIndex
Index defined by dividing the genome by chromosome, then each chromosome into bins of fixed width (in genomic coordinates).
LinearIndex.ChrIndex
Blocks are organized as a simple flat list:
LinearIndexCreator
For creating a LinearIndex from a stream of features.
LineIterator
A very simple descriptor for line-iterables.
LineIteratorImpl
A simple iterator over the elements in LineReader.
LineReader
Interface allows for implementations that read lines from a String, an ASCII file, or somewhere else.
LineReader
Interface for line-oriented readers.
ListMap<K,V>
A Map class that holds a list of entries under each key instead of a single entry, and provides utility methods for adding an entry under a key.
LittleEndianInputStream
Input stream with methods to convert byte arrays to numeric values using "little endian" order.
LittleEndianOutputStream
Locatable
Any class that has a single logical mapping onto the genome should implement Locatable positions should be reported as 1-based and closed at both ends
LocationAware
Describes API for getting current position in a stream, writer, or underlying file.
Locus
Location info about a locus.
LocusComparator<T>
compares first by sequence index then by position
LocusImpl
Simple implementation of Locus interface for ease of passing as an arg and comparing with other Locus implementations.
Log
A wafer thin wrapper around System.err that uses var-args to make it much more efficient to call the logging methods in without having to surround every call site with calls to Log.isXXXEnabled().
Log.LogLevel
Enumeration for setting log levels.
LongLineBufferedReader
A variant of `BufferedReader` with improved performance reading files with long lines.
LTF8
Methods to read and write LTF8 as per CRAM specs.
LZMAExternalCompressor
MappingQualityFilter
Filter things with low mapping quality.
MathUtils
a collection of functions and classes for various common calculations
MathUtils.RunningStat
a class for calculating moving statistics - this class returns the mean, variance, and std dev after accumulating any number of records.
Md5CalculatingInputStream
Class to generate an MD5 string for a file as it is being read
Md5CalculatingOutputStream
Class to generate an MD5 string for a file as it is being read
MergingIterator<T>
An iterator over Iterators that return Ts.
MergingSamRecordIterator
Provides an iterator interface for merging multiple underlying iterators into a single iterable stream.
MetricBase
A base class from which all Metric classes should inherit.
MetricsFile<BEAN,HKEY>
Contains a set of metrics that can be written to a file and parsed back again.
Murmur3
Provides an implementation of the Murmur3_32 hash algorithm that has desirable properties in terms of randomness and uniformity of the distribution of output values that make it a useful hashing algorithm for downsampling.
MutableFeature
A mutable concrete Feature.
MutableIndex
Some Index implementations can be modified in memory.
MutableInt
Mutable integer class suitable for use with collection classes that take a type parameter.
NameAwareCodec
Created by IntelliJ IDEA.
NamedFeature
An interface for features provided via an interval file, e.g.
NameTokenisationDecode
CRAM 3.1 NameTokenisation decoder, used to compress read names in CRAM files.
NameTokenisationEncode
A very naive implementation of a name tokenization encoder.
NameTokeniserExternalCompressor
NotPrimaryAlignmentFilter
Deprecated.
use `SecondaryAlignmentFilter` instead.
NotPrimarySkippingIterator
Deprecated.
use `SecondaryAlignmentSkippingIterator` instead.
Options
Available writer options for VariantContextWriters
OutputStreamResource
A `BundleResource` backed by an `OutputStream`.
OverclippedReadFilter
Filters out reads with very few unclipped bases, likely due to the read coming from a foreign organism, e.g.
OverlapDetector<T>
Utility class to efficiently do in memory overlap detection between a large set of mapping like objects, and one or more candidate mappings.
Padding
A read feature representing padding, similar to `CigarOperator.P`.
ParsingUtils
PassingVariantFilter
A Predicate on VariantContexts that returns true at sites that are either unfiltered, or passing (as variants).
PeekableIterator<Object>
Generic Closable Iterator that allows you to peek at the next value before calling next
PeekIterator<T>
Wrapper around an iterator that enables non-destructive peeking at the next element that would be returned by next()
Positional
Minimal interface for an object at support getting the current position in the stream / writer / file, as well as a handful of other reader-like features.
PositionalBufferedStream
A wrapper around an `InputStream` which performs it's own buffering, and keeps track of the position.
PositionalOutputStream
Wraps output stream in a manner which keeps track of the position within the file and allowing writes at arbitrary points
PrintReadsExample
This is a example program showing how to use SAM readers and (optionally) writers.
PrintVariantsExample
This is a example program showing how to use Feature readers and (optionally) writers.
ProcessExecutor
Utility class that will execute sub processes via Runtime.getRuntime().exec(...) and read off the output from stderr and stdout of the sub process.
ProcessExecutor.ExitStatusAndOutput
ProfileIndexReading
ProgressLogger
Little progress logging class to facilitate consistent output of useful information when progressing through a stream of SAM records.
ProgressLoggerInterface
An interface defining the record() methods of the Picard-public ProgressLogger implementation.
QualityEncodingDetector
Utility for determining the type of quality encoding/format (see `FastqQualityFormat`) used in a SAM/BAM or Fastq.
QualityEncodingDetector.FileContext
QualityUtil
Utility class for working with quality scores and error probabilities.
QueryInterval
Interval relative to a reference, for querying a BAM file.
RangeCoder
RangeDecode
Decoder for the CRAM 3.1 arithmetic (range) codec.
RangeEncode
Encoder for the CRAM 3.1 arithmetic (range) codec.
RangeExternalCompressor
RangeParams
RangeParams.ORDER
RANS4x8Decode
RANS4x8Encode
RANS4x8ExternalCompressor
RANS4x8Params
RANSDecode
RANSDecodingSymbol
RANSEncode<T>
RANSEncodingSymbol
RANSNx16Decode
Decoder for the CRAM 3.1 rANSNx16 codec with 16-bit state renormalization (as opposed to the rAns4x8 codec, which uses 8-bit state renormalization), and order-0 or order-1 context.
RANSNx16Encode
Encoder for the CRAM 3.1 rANSNx16 codec with 16-bit state renormalization (as opposed to the rAns4x8 codec, which uses 8-bit state renormalization), and order-0 or order-1 context.
RANSNx16ExternalCompressor
RANSNx16Params
RANSParams
RANSParams.ORDER
RAWExternalCompressor
Raw compressor that does no compression.
ReadableSeekableStreamByteChannel
A class to wrap a `SeekableStream` in a read-only `SeekableByteChannel`.
ReadBase
A read feature representing a single base with associated quality score.
ReadFeature
An interface to capture data in read coordinates.
ReadNameFilter
Filter by a set of specified readnames
ReadsBundle<T>
A class for creating a `Bundle` for reads and reads-related resources.
ReadsCodec
Base class for all `HtsContentType.ALIGNED_READS` codecs.
ReadsCodecUtils
InternalAPI Utilities for use by reads encoder/decoder implementations.
ReadsDecoder
Base class for all `HtsContentType.ALIGNED_READS` decoders.
ReadsDecoderOptions
Reads decoder options (shared/common).
ReadsEncoder
Base interface for `HtsContentType.ALIGNED_READS` encoders.
ReadsEncoderOptions
General reads encoder options.
ReadsFormats
Class with string constants for known formats supported by reads codecs.
ReadsQuery<R>
Query methods specific to `ReadsDecoder`s.
ReadsResolver
Class with methods for resolving inputs and outputs to reads encoders and decoders.
ReadTag
CRAM counterpart of `SAMTag`.
ReferenceCache
That is a thread-safe wrapper for a list of cache Reference objects.
ReferenceContext
ReferenceContext defines how a given Slice or Container relates to a reference sequence.
ReferenceContextType
Is this `ReferenceContext` Single Reference, Multiple Reference, or Unmapped? Section 8.5 of the CRAM spec defines the following values for the Slice Header sequence ID field: -2: Multiple Reference Slice -1: Unmapped-Unplaced Slice Any positive integer (including zero): Single Reference Slice
ReferenceSequence
Wrapper around a reference sequence that has been read from a reference file.
ReferenceSequenceFile
An interface for working with files of reference sequences regardless of the file format being used.
ReferenceSequenceFileFactory
Factory class for creating ReferenceSequenceFile instances for reading reference sequences store in various formats.
ReferenceSequenceFileWalker
Manages a ReferenceSequenceFile.
ReferenceSequenceMask
Interface for specifying loci of interest for genotype calling and other operations.
ReferenceSource
Used to represent a CRAM reference, the backing source for which can either be a file or the EBI ENA reference service.
RefSkip
A read feature representing a reference skip similar to `CigarOperator.N`.
RelativeIso8601Date
Like `Iso8601Date`, but also comes in a "lazy now" flavor.
RemoteURLHelper
Implementation of URLHelper designed for remote resources.
ReservedTagConstants
Constants for tags used in our SAM/BAM files
ResourceLimitedMap<Key,Value>
LRU collection class for managing objects that place some resource burden such that not too many of them can existing in the VM at one time, but they can be reconstructed ias necessary.
ResourceLimitedMapFunctor<Key,Value>
c.f.
RuntimeEOFException
Thrown by various codecs to indicate EOF without having to clutter the API with throws clauses
RuntimeIOException
Thrown by various IO classes to indicate IOException without having to clutter the API with throws clauses
RuntimeScriptException
Thrown by classes handling script engines like the javascript-based filters for SAM/VCF
SAMBinaryTagAndUnsignedArrayValue
Simple extension to SAMBinaryTagAndValue in order to distinguish unsigned array values, because signedness cannot be determined by introspection of value.
SAMBinaryTagAndValue
Holds a SAMRecord attribute and the tagname (in binary form) for that attribute.
SAMCodec
InternalAPI Base class for `BundleResourceType.FMT_READS_SAM` codecs.
SAMCodecV1_0
SAM v1.0 codec.
SamConstants
A set of constants defined in the sam-spec (https://github.com/samtools/hts-specs) that need to be referenced in code.
SAMDecoder
InternalAPI Base class for `BundleResourceType.FMT_READS_SAM` decoders.
SAMDecoderV1_0
SAM v1.0 decoder.
SAMEncoder
InternalAPI Base class for `BundleResourceType.FMT_READS_SAM` encoders.
SAMEncoderV1_0
SAM v1.0 encoder.
SAMException
SAMFileHeader
Header information from a SAM or BAM file.
SAMFileHeader.GroupOrder
SAMFileHeader.PgIdGenerator
Little class to generate program group IDs
SAMFileHeader.SortOrder
Ways in which a SAM or BAM may be sorted.
SamFileHeaderMerger
Merges SAMFileHeaders that have the same sequences into a single merged header object while providing read group translation for cases where read groups clash across input headers.
SamFiles
SAMFileSource
Represents the origin of a SAM record.
SAMFileSpan
A interface representing a collection of (possibly) discontinuous segments in the BAM file, possibly representing the results of an index query.
SamFileValidator
Validates SAM files as follows: checks sam file header for sequence dictionary checks sam file header for read groups for each sam record reports error detected by SAMRecord.isValid() validates NM (nucleotide differences) exists and matches reality validates mate fields agree with data in the mate record
SamFileValidator.ValidationMetrics
SAMFileWriter
Interface for SAMText and BAM file writers.
SAMFileWriterFactory
Create a writer for writing SAM, BAM, or CRAM files.
SAMFileWriterImpl
Base class for implementing SAM writer with any underlying format.
SAMFlag
SAM flags as enum, to be used in GUI, menu, etc...
SamFlagField
This determines how flag fields are represented in the SAM file.
SAMFormatException
Thrown when a SAM file being read or decoded (text or binary) looks bad.
SAMHeaderRecordComparator<T>
Provides ordering based on SAM header records' attribute values.
SamIndexes
A helper class to read BAI and CRAI indexes.
SamInputResource
Describes a SAM-like resource, including its data (where the records are), and optionally an index.
SAMLineParser
This class enables creation of a SAMRecord object from a String in SAM text format.
SamLocusAndReferenceIterator
Iterator that traverses a SAM File and a ReferenceFile, accumulating information on a per-locus basis.
SamLocusAndReferenceIterator.SAMLocusAndReference
Small class to hold together a `SamLocusIterator.LocusInfo` and the reference base over that locus.
SamLocusIterator
Iterator that traverses a SAM File, accumulating information on a per-locus basis.
SamLocusIterator.LocusInfo
The unit of iteration.
SamLocusIterator.RecordAndOffset
Implementation of `AbstractRecordAndOffset` class for `SamLocusIterator`.
SamPairUtil
Utility methods for pairs of SAMRecords
SamPairUtil.PairOrientation
The possible orientations of paired reads.
SamPairUtil.SetMateInfoIterator
A class to iterate through SAMRecords and set mate information on the given records, and optionally set the mate cigar tag (true by default).
SAMProgramRecord
In-memory representation of @PG SAM header record.
SamReader
Describes functionality for objects that produce `SAMRecord`s and associated information.
SamReader.AssertingIterator
SamReader.Indexing
Facet for index-related operations.
SamReader.PrimitiveSamReader
The minimal subset of functionality needed for a `SAMRecord` data source.
SamReader.PrimitiveSamReaderToSamReaderAdapter
Decorator for a `SamReader.PrimitiveSamReader` that expands its functionality into a `SamReader`, given the backing `SamInputResource`.
SamReader.ReaderImplementation
Internal interface for SAM/BAM/CRAM file reader implementations, as distinct from non-file-based readers.
SamReader.Type
Describes a type of SAM file.
SamReaderFactory
Describes the functionality for producing `SamReader`, and offers a handful of static generators.
SamReaderFactory.Option
A collection of binary `SamReaderFactory` options.
SAMReadGroupRecord
Header information about a read group.
SAMReadGroupRecord.PlatformValue
SAMRecord
Java binding for a SAM file record.
SAMRecord.SAMTagAndValue
Tag name and value of an attribute, for getAttributes() method.
SAMRecordComparator
Interface for comparators that define the various SAM sort orders.
SAMRecordCoordinateComparator
Comparator for sorting SAMRecords by coordinate.
SAMRecordDuplicateComparator
Compares records based on if they should be considered PCR Duplicates (see MarkDuplicates).
SAMRecordFactory
Factory interface which allows plugging in of different classes for generating instances of SAMRecord and BAMRecord when reading from SAM/BAM files.
SamRecordFilter
API for filtering SAMRecords $Id$
SamRecordIntervalIteratorFactory
Create an iterator over a `SamReader` that only returns reads that overlap one of the intervals in an interval list.
SAMRecordIterator
A general interface that adds functionality to a CloseableIterator of SAMRecords.
SAMRecordPrefetchingIterator
Iterator that uses a dedicated background thread to prefetch SAMRecords, reading ahead by a set number of bases to improve throughput.
SAMRecordQueryHashComparator
SAMRecord comparator that provides an ordering based on a hash of the queryname.
SAMRecordQueryNameComparator
Comparator for "queryname" ordering of SAMRecords.
SAMRecordSetBuilder
Factory class for creating SAMRecords for testing purposes.
SamRecordTrackingBuffer<T>
This class stores SAMRecords for return.
SamRecordWithOrdinal
A little class to store the unique index associated with this record.
SAMSequenceDictionary
Collection of SAMSequenceRecords.
SAMSequenceDictionaryCodec
"On the fly" codec SAMSequenceDictionaryCodec.
SAMSequenceDictionaryExtractor
Small class for loading a SAMSequenceDictionary from a file
SAMSequenceRecord
Header information about a reference sequence.
SAMSortOrderChecker
Encapsulates simple check for SAMRecord order.
SamStreams
Utilities related to processing of `InputStream`s encoding SAM data
SAMTag
The standard tags for a SAM record that are defined in the SAM spec.
SAMTagUtil
Deprecated.
as of 11/2018, the functions in this class have been absorbed by the `SAMTag` enum.
SAMTestUtil
Misc methods for SAM-related unit tests.
SAMTestUtil.SanityCheckFailedException
Indicates that a required sanity-check condition was not met.
SAMTextHeaderCodec
Parser for a SAM text header, and a generator of SAM text header.
SAMTextWriter
Writer for text-format SAM files.
SAMUtils
Utilty methods.
SAMValidationError
Class that encapsulates a validation error message as well as a type code so that errors can be aggregated by type.
SAMValidationError.Severity
SAMValidationError.Type
SBIIndex
SBI is an index into BGZF-compressed data files, which has an entry for the file position of the start of every nth record.
SBIIndex.Header
SBIIndexMerger
Merges SBI files for parts of a file that have been concatenated.
SBIIndexWriter
Writes SBI files as understood by `SBIIndex`.
Scores
A read feature representing a contiguous stretch of quality scores in a read.
SecondaryAlignmentFilter
SamRecordFilter that filters out secondary alignments, but not supplemental alignments.
SecondaryAlignmentSkippingIterator
Wrapper around SAMRecord iterator that skips over secondary elements.
SecondaryOrSupplementaryFilter
Filter out SAMRecords with Secondary or Supplementary flag set This class should be viewed as a replacement for `NotPrimarySkippingIterator`, in that we did not want to change the functionality of NPSI to no longer match its name $Id$
SecondaryOrSupplementarySkippingIterator
Wrapper around SAMRecord iterator that skips over secondary and supplementary elements.
SeekableBufferedStream
A wrapper class to provide buffered read access to a SeekableStream.
SeekableFileStream
SeekableFTPStream
Unfortunately the seekable stream classes exist for both Tribble and Picard, and we need both.
SeekableFTPStreamHelper
SeekableHTTPStream
SeekableMemoryStream
SeekablePathStream
An implementation of `SeekableStream` for `Path`.
SeekableStream
InputStream with random access support (seek).
SeekableStreamFactory
Singleton class for getting `SeekableStream`s from URL/paths Applications using this library can set their own factory
SeekableStreamResource
A `BundleResource` backed by a `SeekableStream`.
SequenceRegion
Represents a sequence region feature in a gff3 file.
SequenceUtil
SequenceUtil.SequenceListsDifferException
SignatureStream
An input stream over the first `signaturePrefixLength` bytes of another input stream, used to allow multiple codecs to probe those bytes for a file format/version signature.
SimpleAllele
An implementation of `Allele` which includes a byte[] of the bases in the allele or the symbolic name.
SimpleBEDFeature
Feature from a BED file without exon blocks.
SimpleFeature
A simple concrete Feature.
Slice
A CRAM slice is a logical construct that is just a subset of the blocks in a Slice.
SliceBlocks
Manage the (logical) set of blocks that constitute a `Slice`, not including the Slice header block, which is managed by `Slice`.
SliceBlocksReadStreams
Provides a layer over a `SliceBlocks` object and acts as a bridge between the DataSeries codecs and their underlying blocks when reading a CRAM stream by presenting a bit (core) or byte (external) stream for each block.
SliceBlocksWriteStreams
Provides a layer over a `SliceBlocks` object and acts as a bridge between the DataSeries codecs and their underlying blocks when writing a CRAM stream by presenting a bit (core) or byte (external) stream for each block.
SliceFactory
Factory for creating `Slice`s when writing a CRAM stream.
SnappyLoader
Checks if Snappy is available, and provides methods for wrapping InputStreams and OutputStreams with Snappy if it is.
SnpFilter
A Predicate on VariantContexts that returns true at sites that are SNPs
SoftClip
A read feature representing a soft clip similar to `CigarOperator.S`.
SolexaNoiseFilter
Filter to determine whether a read is "noisy" due to a poly-A run that is a sequencing artifact.
SolexaQualityConverter
Optimized method for converting Solexa ASCII qualities into Phred scores.
SortingCollection<T>
Collection to which many records can be added.
SortingCollection.Codec<T>
Client must implement this class, which defines the way in which records are written to and read from file.
SortingLongCollection
Accumulate a list of longs that can then be sorted in natural order and iterated over.
SortingVariantContextWriter
Deprecated.
9/2017, this class is completely untested and unsupported, there is no replacement at this time if you use this class please file an issue on github or it will be removed at some point in the future
SQTagUtil
Deprecated.
since 11/2018.
SQTagUtil.SQBase
The ordinals of these are stored in the high-order 2 bits of each byte of the SQ tag.
SRAAccession
Describes a single SRA accession for SRA read collection Also provides app string functionality and allows to check if working SRA is supported on the running platform Important: due to checks performed in SRAAccession.isValid(), we won't recognise any accessions other than ones that follow the pattern "^[SED]RR[0-9]{6,9}$", e.g.
SRAAlignmentIterator
Iterator for aligned reads.
SRAFileReader
SRAIndex
Emulates BAM index so that we can request chunks of records from SRAFileReader Here is how it works: SRA allows reading of alignments by Reference position fast, so we divide our "file" range for alignments as a length of all references.
SRAIndexedSequenceFile
Allows reading Reference data from SRA
SRAIterator
SRA iterator which returns SAMRecords for requested list of chunks
SRAIterator.RecordRangeInfo
Describes record ranges info needed for emulating BAM index
SRALazyRecord
Extends SAMRecord so that any of the fields will be loaded only when needed.
SRAUnalignmentIterator
Iterator for unaligned reads.
SRAUtils
Provides some functionality which can be used by other classes Created by andrii.nikitiuk on 10/28/15.
StopWatch
Utility to help in performance testing.
Strand
Enum for strand, which can be encoded as a string
StreamBasedTabixIndexCreator
A `TabixIndexCreator` that can write to an output stream.
StringHeader
A simple header who's data type is a single String.
StringLineReader
Deprecated.
use `BufferedLineReader.fromString(String)`.
StringUtil
Grab-bag of stateless String-oriented utilities.
StructuralVariantType
Type of Structural Variant as defined in the VCF spec 4.2
SubexponentialIntegerEncoding
Substitution
A substitution event captured in read coordinates.
SubstitutionMatrix
Substitution matrix, used to represent base substitutions for reference-based CRAM compression.
SynchronousLineReader
Implementation of `LineReader` that reads lines directly from the underlying stream or reader.
TabixFeatureReader<T,SOURCE>
TabixFormat
The values in a Tabix header that define the format of the file being indexed, e.g.
TabixIndex
This class represent a Tabix index that has been built in memory or read from a file.
TabixIndexCreator
IndexCreator for Tabix.
TabixIndexMerger
Merges tabix files for parts of a VCF file that have been concatenated.
TabixIteratorLineReader
TabixReader
TabixReader.Iterator
TabixReader.TIndex
TabixReader.TPair64
TabixUtils
classes that have anything to do with tabix
TabixUtils.TIndex
TabixUtils.TIntv
TabixUtils.TPair64
TagFilter
Filter class for matching tag attributes in SAMRecords $Id$
TagValueAndUnsignedArrayFlag
CVO to use as a method return value.
TempStreamFactory
Factory class for wrapping input and output streams for temporary files.
TerminatorlessBlockCompressedOutputStream
An extension of `BlockCompressedOutputStream` that doesn't write an empty BGZF block at the end of the stream.
TestUtil
TextCigarCodec
Convert between String and Cigar class representations of CIGAR.
TextTagCodec
Converter between SAM text representation of a tag, and in-memory Object representation.
TimeChannel
Deprecated.
This is deprecated with no replacement.
TimeRandomAccessFile
Deprecated.
This is deprecated with no replacement.
TokenStreams
Tribble
Common, tribble wide constants and static functions
TribbleException
TribbleException.CorruptedIndexFile
TribbleException.FeatureFileDoesntExist
TribbleException.InternalCodecException
TribbleException.InvalidDecodeLine
TribbleException.InvalidHeader
TribbleException.MalformedFeatureFile
TribbleException.TabixReaderFailure
TribbleException.UnableToCreateCorrectIndexType
TribbleException.UnableToReadIndexFile
TribbleIndexCreator
Base class for Tribble-specific index creators.
TribbleIndexedFeatureReader<T,SOURCE>
A reader for text feature files (i.e.
TrimmingUtil
Utility code for performing quality trimming.
Tuple<A,B>
A simple tuple class.
UnsortedFileException
an exception for when we've discovered that an input file is unsorted; sorted files are required by Tribble
Upgradeable
Placeholder interface for methods for upgrading one version of a format to a newer version.
URLHelper
Interface defining a helper class for dealing with URL resources.
URLHelperFactory
A factory for creating `URLHelper` instances.
UserPasswordInput
Utils
Utils
ValidationStringency
How strict to be when reading a SAM or BAM, beyond bare minimum validation.
ValidationUtils
Simple functions that streamline the checking of values.
VariantContext
High-level overview
VariantContext.Type
VariantContext.Validation
VariantContextBuilder
Builder class for `VariantContext`.
VariantContextComparator
A Comparator that orders VariantContexts by the ordering of the contigs/chromosomes in the List provided at construction time, then by start position with each contig/chromosome.
VariantContextFilter
API for filtering VariantContexts.
VariantContextUtils
VariantContextUtils.JexlVCMatchExp
A simple but common wrapper for matching `VariantContext` objects using JEXL expressions
VariantContextWriter
this class writes VCF files
VariantContextWriterBuilder
VariantContextWriterBuilder.OutputType
VariantsBundle
A `Bundle` for variants and variants-related resources that are backed by on disk files.
VariantsCodec
Base class for all `HtsContentType.VARIANT_CONTEXTS` codecs.
VariantsCodecUtils
Utilities for VCF codec implementations.
VariantsDecoder
Base class for all `HtsContentType.VARIANT_CONTEXTS` decoders.
VariantsDecoderOptions
VariantsEncoder
Base class for all `HtsContentType.VARIANT_CONTEXTS` encoders.
VariantsEncoderOptions
VariantsFormats
Class with string constants representing known formats supported by variants codecs.
VariantsResolver
Class with methods for resolving inputs and outputs to variants encoders and decoders.
VCF3Codec
A feature codec for the VCF3 specification, to read older VCF files.
VCFAltHeaderLine
A class representing ALT fields in the VCF header
VCFCodec
InternalAPI Base class for concrete implementations of `HtsContentType.VARIANT_CONTEXTS` codecs.
VCFCodec
A feature codec for the VCF 4 specification
VCFCodecV3_2
VCF V3.2 codec.
VCFCodecV3_3
VCF V3.3 codec.
VCFCodecV4_0
VCF V4.0 codec.
VCFCodecV4_1
VCF V4.1 codec.
VCFCodecV4_2
VCF V4.2 codec.
VCFCodecV4_3
VCF V4.3 codec.
VCFCompoundHeaderLine
a base class for compound header lines, which include info lines and format lines (so far)
VCFCompoundHeaderLine.SupportedHeaderLineType
VCFConstants
VCFContigHeaderLine
A special class representing a contig VCF header line.
VCFDecoder
InternalAPII Base class for concrete implementations of `HtsContentType.VARIANT_CONTEXTS` decoders.
VCFDecoderV3_2
VCF V3.2 decoder.
VCFDecoderV3_3
VCF V3.3 decoder.
VCFDecoderV4_0
VCF V4.0 decoder.
VCFDecoderV4_1
VCF V4.1 decoder.
VCFDecoderV4_2
VCF V4.2 decoder.
VCFDecoderV4_3
VCF V4.3 decoder.
VCFEncoder
InternalAPI Base class for concrete implementations of `HtsContentType.VARIANT_CONTEXTS` encoders.
VCFEncoder
Functions specific to encoding VCF records.
VCFEncoderV3_2
VCF V3.2 encoder.
VCFEncoderV3_3
VCF V3.3 encoder.
VCFEncoderV4_0
VCF V4.0 encoder.
VCFEncoderV4_1
VCF V4.1 encoder.
VCFEncoderV4_2
VCF V4.2 encoder.
VCFFileReader
Simplified interface for reading from VCF/BCF files.
VCFFilterHeaderLine
VCFFormatHeaderLine
VCFHeader
A class to represent a VCF header
VCFHeader.HEADER_FIELDS
VCFHeaderLine
VCFHeaderLineCount
the count encodings we use for fields in VCF header lines
VCFHeaderLineTranslator
A class for translating between vcf header versions
VCFHeaderLineType
the type encodings we use for fields in VCF header lines
VCFHeaderReader
Utility class to read a VCF header without being told beforehand whether the input is VCF or BCF.
VCFHeaderVersion
information that identifies each header version
VCFIDHeaderLine
an interface for ID-based header lines
VCFInfoHeaderLine
VCFIterator
An iterator of `VariantContext`.
VCFIteratorBuilder
A Class building `VCFIterator` Example:
VCFMetaHeaderLine
A class representing META fields in the VCF header
VCFPassThruTextTransformer
A no-op implementation of VCFTextTransformer for pre-v43 VCFs, when such encodings are not supported and no transformation need be done.
VCFPedigreeHeaderLine
A class representing PEDIGREE fields in the VCF header
VCFPercentEncodedTextTransformer
Text transformer for attribute values embedded in VCF.
VCFReader
Interface for reading VCF/BCF files.
VCFRecordCodec
Writes VariantContext instances to an OutputStream without headers or metadata.
VCFSampleHeaderLine
A class representing SAMPLE fields in the VCF header
VCFSimpleHeaderLine
VCFStandardHeaderLines
Manages header lines for standard VCF
VCFTextTransformer
Interface for transforming attribute values embedded in VCF.
VCFUtils
VersionHeader
Header that stores information about the version of some piece of software or data used to create the metrics file.
WholeGenomeReferenceSequenceMask
Implementation of ReferenceSequenceMask that indicates that all the loci in the sequence dictionary are of interest.
WholeReadClippedFilter
Filter SAMRecords so that only those that have at least one un-clipped base are returned.
Writer<A>