All Classes

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.

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.

Base class of implementing iterators.

The unit of iteration for AbstractLocusIterator.

Abstract implementation of a Little progress logging class to facilitate consistent output of useful information when progressing through a stream of SAM records.

Base class for the various concrete records in a SAM header, providing uniform access to the attributes.

Aggregates multiple filters and provides a method for applying them all to a given record with one method call.

Represents the contiguous alignment of a subset of read bases to a reference sequence.

Immutable representation of an allele.

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.

Fast (I hope) buffered Writer that converts char to byte merely by casting, rather than charset conversion.

Iterator that uses a dedicated background thread to perform read-ahead to improve throughput at the expense of increased latency.

AsyncVariantContextWriter that can be wrapped around an underlying AsyncVariantContextWriter to provide asynchronous output.

Class for reading and querying BAM files.

Concrete implementation of SAMFileWriter for writing gzipped BAM files.

Class for both constructing BAM index content and writing it out.

Class to validate (at two different levels of thoroughness) the index for a BAM file.

Filters out records that do not match any of the given intervals and query type.

Class for translating between in-memory and disk representation of BAMRecord.

A read feature representing a single quality score in a read.

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.

See #BCFWriter for documentation on this classes role in encoding BCF2 files

See #BCFWriter for documentation on this classes role in encoding BCF2 files

Decoder a field (implicit from creation) encoded as typeDescriptor in the decoder object in the GenotypeBuilders one for each sample in order.

BCF2 types and associated information

Simple holder for BCF version information User: depristo Date: 8/2/12 Time: 2:16 PM

Indicate whether co-ordinates or 0-based or 1-based.

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.

An individual bin in a BAM file.

Implements common methods of FeatureCodecs that read from PositionalBufferedStreams.

Provides a list of all bins which could exist in the BAM file.

coordinates are 1-based, inclusive

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

An interface to describe the requirements for writing out bits as opposed to bytes.

Represents a contiguous block of bytes in a file, defined by a start position and size (in bytes)

A block-compressed FASTA file driven by an index for fast lookups.

Writer for a file that is a series of gzip blocks (BGZF format).

The block compression methods specified by Section 8 of the CRAM spec

Alternative to GZIPInputStream, for decompressing GZIP blocks that are already loaded into a byte[].

Implementation of LineReader that is a thin wrapper around BufferedReader.

Created by vadim on 23/03/2015.

A [start,stop) file pointer pairing into the BAM file, stored as a BAM file index.

One component of a cigar string.

This interface is used by iterators that use releasable resources during iteration.

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.

Miscellaneous util methods that don't fit anywhere else.

A defaulting map, which returns a default value when a value that does not exist in the map is looked up.

Simple multi-map for convenience of storing collections in map values.

Common utility routines for VariantContext and Genotype

A Predicate on VariantContexts that returns true when either all its sub-predicates are true, or none are false.

A class responsible for decisions about which encodings to use for a given set of records.

Client must implement this class, which defines the way in which records are written to and read from file.

An input stream that wraps a SeekableStream to produce only bytes specified within coordinates.

An input stream that counts the bytes read from it.

A class representing CRAI index entry: file and alignment offsets for each slice.

Class for both constructing BAM index content and writing it out.

Iterate over CRAM containers from an input stream, and unlike CramContainerIterator only the header of each container is read, rather than the whole stream.

Class for writing SAMRecords into a series of CRAM containers on an output stream.

An interface to describe how a data series is encoded.

BAMFileReader analogue for CRAM files.

A starting object when dealing with CRAM files.

Methods to read and write CRAM array of integers data type.

Interface used to supply a reference source when reading CRAM files.

The class provides version-dependant rules and policies for CRAM data.

An input stream that calculates CRC32 of all the bytes passed through it.

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.

Interface to be implemented by custom factory classes that register themselves with this factory and are loaded dynamically.

A CRAM Data Series reader for a particular Encoding, DataSeriesType and associated parameters

A CRAM Data Series writer for a particular Encoding, DataSeriesType and associated parameters

Default factory for creating SAM and BAM records used by the SamReader classes.

Simple iterator class that delegates all method calls to an underlying iterator.

A read feature representing a deletion of one or more bases similar to CigarOperator.D.

A class for reading BAM file indices, hitting the disk once per query.

A factory for creating DownsamplingIterators that uses a number of different strategies to achieve downsampling while meeting various criteria.

Filter out SAMRecords with DuplicateRead flag set $Id$

An iterator of sets of duplicates.

Iterator that traverses a SAM File, accumulating information on a per-locus basis.

Describes the type of TypedRecordAndOffset, whether it represents the start or the end of an alignment block.

Encoding ID as specified by Section 3 of the CRAM spec.

An example binary codec that encodes / decodes contig / start / stop values via DataInputStreams

Encode Byte Arrays using an External Data Block

Encode Bytes using an External Data Block

Superclass of Codecs which operate on External Block byte streams Contrast with CoreCodec for Core Block bit streams

Implementation of ReferenceSequenceFile for reading from FASTA files.

Static methods to create an FastaSequenceIndex.

This class encompasses all the basic information about a genotype.

Codec for encoding records into FASTQ format.

Reads a FASTQ file with four lines per record.

Simple representation of a FASTQ record, without any conversion

Factory class for creating FastqWriter objects.

The base interface for classes that read in features.

the basic interface that feature sources need to match

Thrown when it is possible to detect that a SAM or BAM file is truncated.

A filtering iterator for VariantContexts that takes a base iterator and a VariantContextFilter.

Constants and methods used by BAM and Tribble indices

A builder class for genotypes Provides convenience setter methods for all of the Genotype field values.

A Predicate on VariantContexts that returns true at sites that are either unfiltered, or passing (as variants).

Summary types for Genotype objects

Represents a .gzi index of a block-compressed file.

A read feature representing a hard clip similar to CigarOperator.H.

A header for a metrics file.

Class for computing and accessing histogram type data.

Simple implementation of URLHelper based on the JDK URL and HttpURLConnection classes.

An interface for creating indexes

Factory class for creating indexes.

an enum that contains all of the information about the index types, and how to create them

Check with two index files are equal

Convenience methods to read from InputStream.

A read feature representing a multi-base insertion.

Represents a simple interval on a sequence.

Filter SAMRecords so that only those that overlap the given list of intervals.

Filter out SAMRecords where neither record of a pair overlaps a given set of intervals.

Serve up loci of interest based on an interval list.

An implementation of an interval tree, following the explanation.

Miscellaneous stateless static IO-oriented methods.

Use this type rather than java.util.Date in command-line options in order to get ISO 8601 parsing.

Abstract implementation of an iterator that also implements Iterable (to return itself) so that it can be used if for() loops.

Methods to read and write int values as per ITF8 specification in CRAM.

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

Simple utility for building an on-demand (lazy) object-initializer.

Lazy-loading GenotypesContext.

Simple lazy parser interface.

Represents a portion of a liftover operation, for use in diagnosing liftover failures.

Index defined by dividing the genome by chromosome, then each chromosome into bins of fixed width (in genomic coordinates).

For creating a LinearIndex from a stream of features.

A simple iterator over the elements in LineReader.

Interface for line-oriented readers.

Input stream with methods to convert byte arrays to numeric values using "little endian" order.

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

Location info about a locus.

Simple implementation of Locus interface for ease of passing as an arg and comparing with other Locus implementations.

Enumeration for setting log levels.

Methods to read and write LTF8 as per CRAM specs.

a collection of functions and classes for various common calculations

Class to generate an MD5 string for a file as it is being read

An iterator over Iterators that return Ts.

A base class from which all Metric classes should inherit.

A reader that only keeps track of alignment spans.

Some Index implementations can be modified in memory.

Created by IntelliJ IDEA.

Filters out reads with very few unclipped bases, likely due to the read coming from a foreign organism, e.g.

A read feature representing padding, similar to CigarOperator.P.

A Predicate on VariantContexts that returns true at sites that are either unfiltered, or passing (as variants).

Wrapper around an iterator that enables non-destructive peeking at the next element that would be returned by next()

A wrapper around an InputStream which performs it's own buffering, and keeps track of the position.

This is a example program showing how to use Feature readers and (optionally) writers.

Little progress logging class to facilitate consistent output of useful information when progressing through a stream of SAM records.

Utility for determining the type of quality encoding/format (see FastqQualityFormat) used in a SAM/BAM or Fastq.

Interval relative to a reference, for querying a BAM file.

A read feature representing a single base with associated quality score.

Filter by a set of specified readnames

That is a thread-safe wrapper for a list of cache Reference objects.

An interface for working with files of reference sequences regardless of the file format being used.

Manages a ReferenceSequenceFile.

Used to represent a CRAM reference, the backing source for which can either be a file or the EBI ENA reference service.

A read feature representing a reference skip similar to CigarOperator.N.

Implementation of URLHelper designed for remote resources.

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.

Thrown by various codecs to indicate EOF without having to clutter the API with throws clauses

Thrown by classes handling script engines like the javascript-based filters for SAM/VCF

Simple extension to SAMBinaryTagAndValue in order to distinguish unsigned array values, because signedness cannot be determined by introspection of value.

Ways in which a SAM or BAM may be sorted.

A interface representing a collection of (possibly) discontinuous segments in the BAM file, possibly representing the results of an index query.

Create a writer for writing SAM, BAM, or CRAM files.

SAM flags as enum, to be used in GUI, menu, etc...

Thrown when a SAM file being read or decoded (text or binary) looks bad.

A helper class to read BAI and CRAI indexes.

This class enables creation of a SAMRecord object from a String in SAM text format.

Small class to hold together a SamLocusIterator.LocusInfo and the reference base over that locus.

The unit of iteration.

Utility methods for pairs of SAMRecords

A class to iterate through SAMRecords and set mate information on the given records, and optionally set the mate cigar tag (true by default).

Describes functionality for objects that produce SAMRecords and associated information.

Facet for index-related operations.

Decorator for a SamReader.PrimitiveSamReader that expands its functionality into a SamReader, given the backing SamInputResource.

Describes a type of SAM file.

A collection of binary SamReaderFactory options.

Tag name and value of an attribute, for getAttributes() method.

Comparator for sorting SAMRecords by coordinate.

Factory interface which allows plugging in of different classes for generating instances of SAMRecord and BAMRecord when reading from SAM/BAM files.

Create an iterator over a SamReader that only returns reads that overlap one of the intervals in an interval list.

SAMRecord comparator that provides an ordering based on a hash of the queryname.

Factory class for creating SAMRecords for testing purposes.

A little class to store the unique index associated with this record.

"On the fly" codec SAMSequenceDictionaryCodec.

Header information about a reference sequence.

Utilities related to processing of InputStreams encoding SAM data

Indicates that a required sanity-check condition was not met.

Writer for text-format SAM files.

Class that encapsulates a validation error message as well as a type code so that errors can be aggregated by type.

A read feature representing a contiguous stretch of quality scores in a read.

Wrapper around SAMRecord iterator that skips over secondary elements.

Wrapper around SAMRecord iterator that skips over secondary and supplementary elements.

InputStream with random access support (seek).

Feature from a BED file without exon blocks.

CRAM slice is a logical union of blocks into for example alignment slices.

A Predicate on VariantContexts that returns true at sites that are SNPs

Filter to determine whether a read is "noisy" due to a poly-A run that is a sequencing artifact.

Collection to which many records can be added.

Accumulate a list of longs that can then be sorted in natural order and iterated over.

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.

Allows reading Reference data from SRA

Describes record ranges info needed for emulating BAM index

Iterator for unaligned reads.

Utility to help in performance testing.

A simple header who's data type is a single String.

Grab-bag of stateless String-oriented utilities.

This class represent a Tabix index that has been built in memory or read from a file.

CVO to use as a method return value.

Converter between SAM text representation of a tag, and in-memory Object representation.

Base class for Tribble-specific index creators.

Utility code for performing quality trimming.

an exception for when we've discovered that an input file is unsorted; sorted files are required by Tribble

How strict to be when reading a SAM or BAM, beyond bare minimum validation.

Builder class for VariantContext.

API for filtering VariantContexts.

A simple but common wrapper for matching VariantContext objects using JEXL expressions

A feature codec for the VCF3 specification, to read older VCF files.

a base class for compound header lines, which include info lines and format lines (so far)

Functions specific to encoding VCF records.

A class to represent a VCF header

A class for translating between vcf header versions

Utility class to read a VCF header without being told beforehand whether the input is VCF or BCF.

an interface for ID-based header lines

An iterator of `VariantContext`.

Writes VariantContext instances to an OutputStream without headers or metadata.

Manages header lines for standard VCF

A class to represent a version information, 3 number: major, minor and build number.

Implementation of ReferenceSequenceMask that indicates that all the loci in the sequence dictionary are of interest.