All Classes

Provides basic, generic capabilities to be used reading BAM index files.

jrobinso

An abstract implementation of the index class.

Javascript filter with HEADER type containing TYPE records.

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

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.

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.

A span of over a single reference.

This is a copy of TabixIndexCreator, except sequence names are populated from the header, not from the ones that are seen.

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 used to construct a BAI index for a CRAM file.

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.

Metadata about the bam index contained within the bam index.

Wrapper class for binary BAM records.

Writes SBI files for BAM files, as understood by SBIIndex.

Class for writing SAMRecords in BAM format to an output stream.

Decode BCF2 files

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

Specialized int encoder for atomic (non-list) integers

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

An efficient scheme for building and obtaining specialized genotype field decoders.

Lazy version of genotypes decoder for BCF2 genotypes

Common utilities for working with BCF2 files Includes convenience methods for encoding, decoding BCF2 type descriptors (size + type)

Codec for parsing BED file, as described by UCSC See https://genome.ucsc.edu/FAQ/FAQformat.html#format1

Encapsulates file representation of various primitive data types.

Converter between disk and in-memory representation of a SAMRecord tag.

Builder for a BinningIndexContent object.

In-memory representation of the binning index for a single reference.

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/).

An interface to describe the requirements for reading bit data as opposed to bytes.

Class representing CRAM block concept and some methods to operate with block content.

Static for manipulating virtual file pointers in BGZF files.

Utility class for reading BGZF block compressed files.

Constants shared by BlockCompressed{Input,Output}Stream classes

The block content types specified by Section 8.1 of the CRAM spec

An index interface with additional functionality for querying and inspecting the structure of a BAM index.

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.

CRAMEncoding class for Huffman byte values.

Represents an index on a specific chromosome

A list of CigarElements, which describes how a read aligns with the reference.

The operators that can appear in a cigar string, and information about their disk representations.

Utility class that can scan for classes in the classpath and find all the ones annotated with a particular annotation.

The basic iterator we use in Tribble, which allows closing and basic iteration.

Class CodecLineParsingException a generic exception we use if the codec has trouble parsing the line its given

Small utility methods for dealing with collection classes.

A simple extension of the Tuple class that, for comparable Types, allows comparing Tuples of non-null elements.

Factory for creating CRAM compression headers for containers when writing to a CRAM stream.

Notes: Container will construct a container out of as many CRAMCompressionRecords as it is handed, respecting only the maximum number of slices.

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.

Merges CRAM index files for (headerless) parts of a CRAM file into a single index file.

An interface that defines requirements for serializing/deserializing objects into and from a stream.

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, with an optional index.

A base class for the various CRAM encodings.

Created by edwardk on 8/13/15.

Interface for indexing CRAM.

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

A reader used to consume and populate encoded CRAMCompressionRecords from a set of streams representing data series/blocks in a Slice.

A writer that emits CRAMCompressionRecord into the various streams that represent a Slice's data series blocks.

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

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

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

Implementation of the CSI index for BAM files.

Factory for creating custom readers for accessing API based resources, e.g.

Represents a specific CRAM record data series and its associated type and unique Content ID.

Data series types known to CRAM.

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.

Must not read from delegate unless no bits left in the buffer!!!

Embodies defaults for global values that affect how the SAM JDK operates.

Factory for Deflater objects used by BlockCompressedOutputStream.

Class to hold a set of Path to be delete on the JVM exit through a shutdown hook.

A single-ended FIFO queue.

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.

Describes the available downsampling strategies.

This class helps us compute and compare duplicate scores, which are used for selecting the non-duplicate during duplicate marking (see MarkDuplicates).

Stores a set of records that are duplicates of each other.

A DynamicIndexCreator creates the proper index based on an IndexFactory.IndexBalanceApproach and the characteristics of the file.

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.

A helper class to choose and instantiate an appropriate CRAMEncoding given a DataSeriesType and an EncodingDescriptor.

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

Encode Byte Arrays using an External Data Block

Writes a FASTA formatted reference file.

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

Contains file extension constants for read, alignment, variant and annotation files

Filtering Iterator which takes a filter and an iterator and iterates through only those records which are not rejected by the filter.

Simple class used to format object values into a standard format for printing.

A "non-seekable" ftp stream.

Object for full BED file.

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

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.

Enum for parsing directive lines.

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"

A class to write out gff3 files.

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

Index entry mapping the block-offset (compressed offset) to the uncompressed offset where the block starts.

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.

Class for reading and querying BAM files from an htsget source

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'" } }

Fields which can be used to filter a htsget request as defined by the spec

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

Huffman bit code word consisting of a symbol, the corresponding codeword and codeword bit length.

A class for carrying around encoding parameters for a canonical Huffman encoder.

Interface for all index implementations.

A fasta file driven by an index for fast, concurrent lookups.

We can optimize index-file-creation for different factors.

Merges index files for (headerless) parts of a partitioned main file into a single index file.

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.

An iterator that feeds on an Iterator and combines consecutive intervals that need merging.

Serve up loci of interest based on an interval list.

A Red-Black tree with intervals for keys.

Index based on an interval tree

Utility class that implements an interval map.

Interface for htsjdk input/output paths/URIs.

Factory for creating SeekableStreams based on URLs/paths.

Provides an adapter to wrap an Iterator with an Iterable, allowing it to be run through a foreach loop.

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 )

How to treat values that appear in a jexl expression but are missing in the context it's applied to

Returns the data used in the full GenotypesContext constructor GenotypesContext(java.util.ArrayList, java.util.Map, java.util.List)

Java port of UCSC liftOver.

The linear index associated with a given reference in a BAM index.

Blocks are organized as a simple flat list:

A very simple descriptor for line-iterables.

Interface allows for implementations that read lines from a String, an ASCII file, or somewhere else.

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.

Describes API for getting current position in a stream, writer, or underlying file.

compares first by sequence index then by position

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().

A variant of BufferedReader with improved performance reading files with long lines.

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.

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.

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 SAM readers and (optionally) writers.

Utility class that will execute sub processes via Runtime.getRuntime().exec(...) and read off the output from stderr and stdout of the sub process.

An interface defining the record() methods of the Picard-public ProgressLogger implementation.

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

Raw compressor that does no compression.

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.

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

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.

Like Iso8601Date, but also comes in a "lazy now" flavor.

Constants for tags used in our SAM/BAM files

c.f.

Thrown by various IO classes to indicate IOException without having to clutter the API with throws clauses

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

A set of constants defined in the sam-spec (https://github.com/samtools/hts-specs) that need to be referenced in code.

Header information from a SAM or BAM file.

Little class to generate program group IDs

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.

Represents the origin of a SAM record.

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

Interface for SAMText and BAM file writers.

Base class for implementing SAM writer with any underlying format.

This determines how flag fields are represented in the SAM file.

Provides ordering based on SAM header records' attribute values.

Describes a SAM-like resource, including its data (where the records are), and optionally an index.

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

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

Implementation of AbstractRecordAndOffset class for SamLocusIterator.

The possible orientations of paired reads.

In-memory representation of @PG SAM header record.

The minimal subset of functionality needed for a SAMRecord data source.

Internal interface for SAM/BAM/CRAM file reader implementations, as distinct from non-file-based readers.

Describes the functionality for producing SamReader, and offers a handful of static generators.

Header information about a read group.

Java binding for a SAM file record.

Interface for comparators that define the various SAM sort orders.

Compares records based on if they should be considered PCR Duplicates (see MarkDuplicates).

API for filtering SAMRecords $Id$

A general interface that adds functionality to a CloseableIterator of SAMRecords.

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.

Writes SBI files as understood by SBIIndex.

SamRecordFilter that filters out secondary alignments, but not supplemental alignments.

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$

A wrapper class to provide buffered read access to a SeekableStream.

Unfortunately the seekable stream classes exist for both Tribble and Picard, and we need both.

An implementation of SeekableStream for Path.

Singleton class for getting SeekableStreams from URL/paths Applications using this library can set their own factory

Feature from a BED file without exon blocks.

A CRAM slice is a logical construct that is just a subset of the blocks in a Slice.

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.

Factory for creating Slices when writing a CRAM stream.

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 TabixIndexCreator that can write to an output stream.

Type of Structural Variant as defined in the VCF spec 4.2

A substitution event captured in read coordinates.

Implementation of LineReader that reads lines directly from the underlying stream or reader.

The values in a Tabix header that define the format of the file being indexed, e.g.

IndexCreator for Tabix.

CVO to use as a method return value.

An extension of BlockCompressedOutputStream that doesn't write an empty BGZF block at the end of the stream.

Convert between String and Cigar class representations of CIGAR.

Common, tribble wide constants and static functions

A reader for text feature files (i.e.

A simple tuple class.

Interface defining a helper class for dealing with URL resources.

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

High-level overview

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.

this class writes VCF files

A class representing ALT fields in the VCF header

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`.

A class representing META fields in the VCF header

A class representing PEDIGREE fields in the VCF header

Interface for reading VCF/BCF files.

A class representing SAMPLE fields in the VCF header

Manages header lines for standard VCF

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