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.

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.

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.

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

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

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

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.

Methods to read and write CRAM containers.

Holds info about a mate pair for use when processing a coordinate sorted file.

Static methods that encapsulate the standard SAM way of storing ranges: one-based, with both ends inclusive.

An input stream that counts the bytes read from it.

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

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

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.

Created by edwardk on 8/13/15.

Methods to read and write CRAM int values as given in the file format specification.

An iterator of CRAM containers read from locations in SeekableStream.

An output stream that calculates CRC32 checksum of all the bytes written through the stream.

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

A basic interface for reading data.

A basic interface defining a writer.

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.

An interface to describe how a data series is encoded.

Encoding ID as defined in the CRAM specs.

Methods to provide CRAM external compression/decompression features.

Filter for filtering out reads that do not pass the quality filter $Id$

Reads/writes a fasta index file (.fai), as generated by `samtools faidx`.

Hold an individual entry in a fasta sequence index file.

Line-oriented InputStream reader that uses one buffer for disk buffering and line-termination-finding, in order to improve performance.

Enumeration for FastQ quality score formats formats.

Enum of the types of lines we see in Fastq.

Simple interface for a class that can write out fastq records.

Marker interface for Locatables with Tribble support.

A class to represent a header of a feature containing file.

LRU cache of OutputStreams to handle situation in which it is necessary to have more FileOutputStreams than resource limits will allow.

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

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.

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.

Factory for Inflater objects used by BlockGunzipper.

A read feature representing a single insert base.

Filter things that fall outside a specified range of insert sizes.

Quick and dirty interval class Describes a genomic interval and where in a file information for that interval can be obtained

Creates interval indexes from a stream of features

Represents a list of intervals against a reference sequence that can be written to and read from a file.

A Red-Black tree with intervals for keys.

Index based on an interval tree

Utility class that implements an interval map.

A convenient way to provide a single view on the many int and int[] field values we work with, for writing out the values.

A hash map that uses primitive ints for the key rather than objects.

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.

Filter things with low mapping quality.

a class for calculating moving statistics - this class returns the mean, variance, and std dev after accumulating any number of records.

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

Provides an iterator interface for merging multiple underlying iterators into a single iterable stream.

Contains a set of metrics that can be written to a file and parsed back again.

Some Index implementations can be modified in memory.

Created by IntelliJ IDEA.

Available writer options for VariantContextWriters

Utility class to efficiently do in memory overlap detection between a large set of mapping like objects, and one or more candidate mappings.

Generic Closable Iterator that allows you to peek at the next value before calling next

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.

Wraps output stream in a manner which keeps track of the position within the file and allowing writes at arbitrary points

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.

Utility class for working with quality scores and error probabilities.

A class to wrap a SeekableStream in a read-only SeekableByteChannel.

An interface to capture data in read coordinates.

CRAM counterpart of SAMTag.

Wrapper around a reference sequence that has been read from a reference file.

Factory class for creating ReferenceSequenceFile instances for reading reference sequences store in various formats.

Interface for specifying loci of interest for genotype calling and other operations.

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

Facility for converting between String and short representation of a SAM tag.

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

Writer for text-format SAM files.

Utilty methods.

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.

Utility methods for encoding and decoding the SQ tag value of SAMRecord.

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

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.