The cl-sam Reference Manual

Table of Contents

Next: , Previous: , Up: (dir)   [Contents][Index]

The cl-sam Reference Manual

This is the cl-sam Reference Manual, version 0.16.0, generated automatically by Declt version 3.0 "Montgomery Scott" on Mon Dec 02 09:45:34 2019 GMT+0.


Next: , Previous: , Up: Top   [Contents][Index]

1 Introduction

Introduction

cl-sam is a Common Lisp toolkit for manipulation of DNA sequence
alignment data stored in the Sequence Alignment/Map (SAM) format
(http://samtools.sourceforge.net). cl-sam is de novo implementation of
the SAM spec in Common Lisp, using zlib via a C foreign function
interface.

While cl-sam is slower than the C and Java implementations for some
(but not all) operations, performance is good enough for real work.
Moreover, it offers the advantages of rapid development at all levels
in the SAM/BAM stack (zlib, bgzf, BAM and SAM) not afforded by
scripting language bindings of samtools.

cl-sam is able to create BAM records de novo and may be used to create
a BAM file from scratch or edit a BAM stream. SAM/BAM header
manipulation functions are included so that new headers may be created
and headers from different BAM files may be systematically merged
without redundancy or avoidable conflicts. Where conflicts are
unavoidable, error conditions are raised to alert the user.

The operations supported in this version are:

         SAM    BAM
Read      No    Yes
Write    Yes    Yes

Sorting operations are available using an external merge sort that is
extensible by user-supplied sorting predicates.

Installation

cl-sam uses ASDF for system definition. Copy or symlink cl-sam.asd
(and optionally cl-sam-test.asd) to your asdf:*central-registry* and
load cl-sam with the asdf:load-system function:

 (asdf:load-system :cl-sam)


Tests

To run the unit and regression tests you need to have LIFT
installed. Run the tests with the asdf:operate function:

 (asdf:operate 'asdf:test-op :cl-sam)

or with the equivalent deoxybyte-systems:test-system function:

 (asdf:test-system :cl-sam)


Documentation

See the Lisp docstrings, particularly the package docstrings for an
overview. HTML documentation may be generated with the command:

 (dxs:document-system :cl-sam)

at the REPL, provided that CLDOC is installed.

The components of cl-sam are divided by file as follows:

 bam.lisp          High-level BAM record data reading functions.
 bam-reader.lisp   High-level BAM file reading functions.
 bam-writer.lisp   High-level BAM file writing functions.
 bam-index.lisp    Structures representing a samtools BAM index.

 sam.lisp          High-level SAM record data reading functions.
 sam-reader.lisp   High-level SAM file reading functions.
 sam-writer.lisp   High-level SAM file writing functions.

 bgzf-reader.lisp  Low-level BGZF seek and read functions.
 bgzf-stream.lisp  Low-level BGZF Gray stream implementation. An alternative
                   to the bgzf-reader functions, but roughly 2x slower.

The test suite contains examples of use.


Dependencies

deoxybyte-systems       git://github.com/keithj/deoxybyte-systems.git
deoxybyte-utilities     git://github.com/keithj/deoxybyte-utilities.git
deoxybyte-io            git://github.com/keithj/deoxybyte-io.git
deoxybyte-gzip          git://github.com/keithj/deoxybyte-gzip.git

CFFI                    http://common-lisp.net/project/cffi/


Optional dependencies

LIFT                    http://common-lisp.net/project/lift/
CLDOC                   http://common-lisp.net/project/cldoc/


Next: , Previous: , Up: Top   [Contents][Index]

2 Systems

The main system appears first, followed by any subsystem dependency.


Previous: , Up: Systems   [Contents][Index]

2.1 cl-sam

Author

Keith James

License

GPL v3

Description

Toolkit for manipulation of DNA sequence alignment data stored in the Sequence Alignment/Map (SAM) format.

Version

0.16.0

Dependencies
Source

cl-sam.asd (file)

Component

cl-sam (module)


Next: , Previous: , Up: Top   [Contents][Index]

3 Modules

Modules are listed depth-first from the system components tree.


Previous: , Up: Modules   [Contents][Index]

3.1 cl-sam/cl-sam

Parent

cl-sam (system)

Location

src/

Components

Next: , Previous: , Up: Top   [Contents][Index]

4 Files

Files are sorted by type and then listed depth-first from the systems components trees.


Previous: , Up: Files   [Contents][Index]

4.1 Lisp


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.1 cl-sam.asd

Location

cl-sam.asd

Systems

cl-sam (system)


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.2 cl-sam/cl-sam/package.lisp

Parent

cl-sam (module)

Location

src/package.lisp

Packages

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.3 cl-sam/cl-sam/conditions.lisp

Dependency

package.lisp (file)

Parent

cl-sam (module)

Location

src/conditions.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.4 cl-sam/cl-sam/bgzf.lisp

Dependency

conditions.lisp (file)

Parent

cl-sam (module)

Location

src/bgzf.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.5 cl-sam/cl-sam/bgzf-reader.lisp

Dependency

bgzf.lisp (file)

Parent

cl-sam (module)

Location

src/bgzf-reader.lisp

Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.6 cl-sam/cl-sam/bgzf-writer.lisp

Dependency

bgzf-reader.lisp (file)

Parent

cl-sam (module)

Location

src/bgzf-writer.lisp

Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.7 cl-sam/cl-sam/bgzip-stream.lisp

Dependency

bgzf-writer.lisp (file)

Parent

cl-sam (module)

Location

src/bgzip-stream.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.8 cl-sam/cl-sam/sam.lisp

Dependency

bgzip-stream.lisp (file)

Parent

cl-sam (module)

Location

src/sam.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.9 cl-sam/cl-sam/bam.lisp

Dependency

sam.lisp (file)

Parent

cl-sam (module)

Location

src/bam.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.10 cl-sam/cl-sam/bam-index.lisp

Dependency

bam.lisp (file)

Parent

cl-sam (module)

Location

src/bam-index.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.11 cl-sam/cl-sam/bam-index-reader.lisp

Dependency

bam-index.lisp (file)

Parent

cl-sam (module)

Location

src/bam-index-reader.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.12 cl-sam/cl-sam/bam-index-writer.lisp

Dependency

bam-index-reader.lisp (file)

Parent

cl-sam (module)

Location

src/bam-index-writer.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.13 cl-sam/cl-sam/bam-indexer.lisp

Dependency

bam-index-writer.lisp (file)

Parent

cl-sam (module)

Location

src/bam-indexer.lisp

Exported Definitions

index-bam-file (function)

Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.14 cl-sam/cl-sam/bam-reader.lisp

Dependency

bam-indexer.lisp (file)

Parent

cl-sam (module)

Location

src/bam-reader.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.15 cl-sam/cl-sam/bam-writer.lisp

Dependency

bam-reader.lisp (file)

Parent

cl-sam (module)

Location

src/bam-writer.lisp

Exported Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.16 cl-sam/cl-sam/sam-writer.lisp

Dependency

bam-writer.lisp (file)

Parent

cl-sam (module)

Location

src/sam-writer.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.17 cl-sam/cl-sam/external-bam-sort.lisp

Dependency

sam-writer.lisp (file)

Parent

cl-sam (module)

Location

src/external-bam-sort.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.18 cl-sam/cl-sam/bam-utilities.lisp

Dependency

external-bam-sort.lisp (file)

Parent

cl-sam (module)

Location

src/bam-utilities.lisp

Exported Definitions
Internal Definitions

Previous: , Up: Lisp files   [Contents][Index]

4.1.19 cl-sam/cl-sam/cl-sam.lisp

Dependency

bam-utilities.lisp (file)

Parent

cl-sam (module)

Location

src/cl-sam.lisp

Exported Definitions
Internal Definitions

stream-view-sam (function)


Next: , Previous: , Up: Top   [Contents][Index]

5 Packages

Packages are listed by definition order.


Next: , Previous: , Up: Packages   [Contents][Index]

5.1 bgzf-ffi

A foreign function interface to the block gzip
functions provided by the Broad Institute. See bgzf.h in the SAMtools package for function documentation.

Source

package.lisp (file)

Use List

Previous: , Up: Packages   [Contents][Index]

5.2 sam

cl-sam is a Common Lisp toolkit for manipulation of
DNA sequence alignment data stored in the Sequence Alignment/Map (SAM) format <http://samtools.sourceforge.net>. The SAM specficiation describes text (SAM) and binary (BAM) formats.

cl-sam uses the BGZF block compression code from the SAMtools C toolkit, but is otherwise an independent Lisp implementation capable
of editing every aspect of BAM files or creating BAM data de novo.

The following example implements something similar to samtools flagstat:

;;; (with-bgzf (bgzf "example.bam" :direction :input)
;;; (multiple-value-bind (header num-refs ref-meta)
;;; (read-bam-meta bgzf)
;;; (format t "BAM header: ~s~%" header)
;;; (format t "Number of references: ~d~%" num-refs)
;;; (loop
;;; for (id name length) in ref-meta
;;; do (format t "Reference name: ~s Length: ~d~%" id name length))) ;;; (loop
;;; for alignment = (read-alignment bgzf)
;;; while alignment
;;; for flag = (alignment-flag alignment)
;;; count flag into total
;;; count (fails-platform-qc-p flag) into qc-fail
;;; count (pcr/optical-duplicate-p flag) into duplicates
;;; count (not (query-unmapped-p flag)) into mapped
;;; count (sequenced-pair-p flag) into seq-paired
;;; count (first-in-pair-p flag) into read1
;;; count (second-in-pair-p flag) into read2
;;; count (mapped-proper-pair-p flag) into proper-paired
;;; count (and (not (query-unmapped-p flag))
;;; (not (mate-unmapped-p flag))) into both-mapped
;;; count (mate-unmapped-p flag) into singletons
;;; finally (format t (str "~d in total~%"
;;; "~d QC failure~%"
;;; "~d duplicates~%"
;;; "~d mapped (~$%)~%"
;;; "~d paired in sequencing~%"
;;; "~d read1~%"
;;; "~d read2~%"
;;; "~d properly paired (~$%)~%"
;;; "~d both mapped~%"
;;; "~d singletons (~$%)~%")
;;; total qc-fail duplicates mapped
;;; (* 100 (/ mapped total))
;;; seq-paired read1 read2 proper-paired
;;; (* 100 (/ proper-paired total))
;;; both-mapped singletons
;;; (* 100 (/ singletons total)))))

Source

package.lisp (file)

Use List
Exported Definitions
Internal Definitions

Next: , Previous: , Up: Top   [Contents][Index]

6 Definitions

Definitions are sorted by export status, category, package, and then by lexicographic order.


Next: , Previous: , Up: Definitions   [Contents][Index]

6.1 Exported definitions


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.1 Special variables

Special Variable: *sam-version*

The SAM version written by cl-sam.

Package

sam

Source

sam.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.2 Macros

Macro: define-alignment-tag TAG VALUE-TYPE &optional DOCSTRING

Defines a new alignment tag to hold a datum of a particular SAM type.

Arguments:

- tag (symbol): The tag e.g. :rg
- value-type (symbol): The value type, one of :char , :string , :hex :int32 or :float .

Optional:

- docstring (string): Documentation for the tag.

Package

sam

Source

bam.lisp (file)

Macro: with-bam (VAR (&optional HEADER NUM-REFS REF-META) FILESPEC &rest ARGS &key COMPRESS-HEADER PAD-HEADER INDEX REGIONS &allow-other-keys) &body BODY

Evaluates BODY with VAR bound to a new BAM generator function on pathname designator FILESPEC. The direction (:input versus :output) is determined by the stream-opening arguments in ARGS. The standard generator interface functions NEXT and HAS-MORE-P may be used in operations on the returned generator.

On reading, HEADER, NUM-REFS and REF-META will be automatically bound to the BAM file metadata i.e. the metadata are read automatically and the iterator positioned before the first alignment record.

Optionally, iteration may be restricted to a specific reference, designated by REF-NUM and to alignments that start between reference positions START and END. Furthermore, a BAM-INDEX object INDEX may be provided to allow the stream to seek directly to the desired region of the file.

On writing, HEADER, NUM-REFS and REF-META should be bound to appropriate values for the BAM file metadata, which will be automatically written to the underlying stream.

The COMPRESS-HEADER and PAD-HEADER keyword arguments are only applicable on writing where they control whether the records and header block should be compressed and whether the header string should be padded with nulls to allow space for expansion. Writing an uncompressed, padded header means that a header that fits in the first BGZF block may be updated without re-writing the entire BAM file. The BGZF COMPRESSION keyword is also accepted, permitting the Zlib compression level to be set for the stream.

A list REGIONS may be supplied to limit the returned alignments to specific references and reference coordinates. REGIONS may be region objects or region designators in the form of list tuples

;;; (<reference designator> start end)

where a reference designator is either the reference name string or its identifier number in the BAM file. REGIONS will be normalised automatically by sorting according to reference position in the BAM file (according to the BAM metadata) and then by start and
end. Overlapping regions will be merged.

For example:

To count all records in a BAM file:

;;; (with-bam (in () "in.bam")
;;; (loop
;;; while (has-more-p in)
;;; count (next in)))

To copy only records with a mapping quality of >= 30 to another BAM file:

;;; (with-bam (in (header n ref-meta) "in.bam")
;;; (with-bam (out (header n rer-meta) "out.bam" :direction :output) ;;; (let ((q30 (discarding-if (lambda (x)
;;; (< (mapping-quality x) 30)) in))) ;;; (loop
;;; while (has-more-p q30)
;;; do (consume out (next q30))))))

To count records with mapping quality of >= 30 in a set of genomic ranges, using an index:

;;; (with-bam-index (index "index.bai")
;;; (with-bam (bam () bam-file :index index
;;; :regions ’((0 1000000 1100000) (1 1000000 1100000))) ;;; (loop
;;; while (has-more-p bam)
;;; count (>= (mapping-quality (next bam)) 30))))

Package

sam

Source

bam.lisp (file)

Macro: with-bam-index (VAR FILESPEC) &body BODY

Evaluates BODY with VAR bound to a BAM-INDEX read from file denoted by pathname designator FILESPEC.

Package

sam

Source

bam-index-reader.lisp (file)

Macro: with-bgzf (VAR FILESPEC &rest ARGS) &body BODY

Executes BODY with VAR bound to a BGZF handle structure created by opening the file denoted by FILESPEC.

Arguments:

- var (symbol): The symbol to be bound.
- filespec (pathname designator): The file to open.

Rest:

- args: Arguments applicable to bgzf-open.

Package

sam

Source

bgzf.lisp (file)

Macro: with-open-bgzip (VAR FILESPEC &rest ARGS) &body BODY
Package

sam

Source

bgzip-stream.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.3 Functions

Function: add-pg-record HEADER NEW-RECORD

Returns a copy of HEADER with PG record NEW-RECORD added. If the ID of NEW-RECORD clashes with existing IDs, all IDs are remapped to new, generated sequential integer IDs, starting at 0. PP links are also updated. NEW-RECORD must have its PP field set by the caller.

Package

sam

Source

sam.lisp (file)

Function: alignment-bin ALN

Returns an integer that indicates the alignment bin to which ALN has been assigned.

Package

sam

Source

bam.lisp (file)

Function: alignment-cigar ALN

Returns the CIGAR record list of the alignment described by
ALN. CIGAR operations are given as a list, each member being a list of a CIGAR operation keyword and an integer operation length.

Package

sam

Source

bam.lisp (file)

Function: alignment-core ALN &key VALIDATE

Returns a list of the core data described by ALN. The list elements are comprised of reference-id, alignment-position, read-name length, mapping-quality alignment-bin, cigar length, alignment flag, read length, mate reference-id, mate alignment-position and insert length.

Package

sam

Source

bam.lisp (file)

Function: alignment-core-alist ALN &key VALIDATE

Returns the same data as {defun alignment-core} in the form of an alist.

Package

sam

Source

bam.lisp (file)

Function: alignment-flag ALN &key VALIDATE

Returns an integer whose bits are flags that describe properties of the ALN. If the VALIDATE key is T (the default) the flag’s bits are checked for internal consistency.

Package

sam

Source

bam.lisp (file)

Function: alignment-flag-alist ALN &key VALIDATE

Returns the bitwise flags of ALN in the form of an alist. The primary purpose of this function is debugging.

Package

sam

Source

bam.lisp (file)

Function: alignment-generator REFERENCE-ID READ-GROUP &key READ-LENGTH NAME-SUFFIX INSERT-LENGTH START END STEP-SIZE MAPPING-QUALITY SEQ-FN QUALITY-FN

Returns a new standard generator function which returns pairs of
BAM alignment records.

Arguments:

- reference-id (integer): The BAM reference identifier.
- read-group (string): The read group name.

Key:

- read-length (integer): The read length.
- insert-length (integer): The insert length, defined as the distance between the inner boundaries of the paired alignments.
- start (integer): The position at which to start generating alignments. - end (integer): The position at which to stop generating alignments, expressed in Lisp vector indices (zero-based, half-open), rather than BAM’s (zero-based, closed).
- step-size (integer): The distance between each successive pair of alignments.
- mapping-quality (integer): The mapping quality of the alignments.

Returns

- A function.

Package

sam

Source

bam-utilities.lisp (file)

Function: alignment-name< ALIGNMENT-RECORD1 ALIGNMENT-RECORD2

Returns T if ALIGNMENT-RECORD1 sorts before ALIGNMENT-RECORD2 by read name. Sorting semantics of read names are not fully defined in the SAM spec; whether you should expect natural order or numeric order of read name strings is not defined.

This function compares numerically by read name, then by alignment template region for reads paired in sequencing and finally by alignment strand.

Package

sam

Source

external-bam-sort.lisp (file)

Function: alignment-not-primary-p FLAG

Returns T if FLAG indicates that the read mapping was not the primary mapping to a reference, or NIL otherwise.

Package

sam

Source

bam.lisp (file)

Function: alignment-orphanizer GEN &key TEST

Given an alignment generator function GEN, returns a new function that omits some alignments, yielding orphans. Any alignments for which TEST returns T will be omitted. The default is to omit alternate last fragment alignments.

Package

sam

Source

bam-utilities.lisp (file)

Function: alignment-position ALN

Returns the 0-based sequence coordinate of ALN in the reference sequence of the first base of the clipped read.

Package

sam

Source

bam.lisp (file)

Function: alignment-record< ALIGNMENT-RECORD1 ALIGNMENT-RECORD2

Returns T if ALIGNMENT-RECORD1 sorts before
ALIGNMENT-RECORD2. Sorting semantics are not fully defined in the SAM spec, however, an informal consensus on sequence order sorting seems to be:

- mapped reads should first be sorted by their reference in the order in which reference sequences appear in the header
- unmapped reads should sort after mapped reads
- reads mapped to the same reference must appear in ascending order of their alignment position

This function compares first by reference sequence, then alignment position, by alignment strand and finally by read name. The output is identical to a coordinate sort performed by Picard 1.07.

Package

sam

Source

external-bam-sort.lisp (file)

Function: alignment-reference-end ALN

Returns the end position of the alignment on the reference. Requires decoding the CIGAR string.

Package

sam

Source

bam.lisp (file)

Function: alignment-tag-values ALN

Returns an alist of tag and values described by ALN.

Package

sam

Source

bam.lisp (file)

Function: bam-index-refs INSTANCE
Function: (setf bam-index-refs) VALUE INSTANCE
Package

sam

Source

bam-index.lisp (file)

Function: bam-sort-error PREVIOUS-REF PREVIOUS-POS REF POS &optional MESSAGE &rest MESSAGE-ARGUMENTS
Package

sam

Source

bam.lisp (file)

Function: bgzf-close BGZF

Closes an open block gzip file.

Arguments:

- bgzf (bgzf structure): The file to close.

Returns:

- T on success.

Package

sam

Source

bgzf.lisp (file)

Function: bgzf-eof-p BGZF

Returns T if the BGZF stream is terminated by an empty record.

Package

sam

Source

bgzf.lisp (file)

Function: bgzf-open BGZFSPEC &rest ARGS &key COMPRESSION &allow-other-keys

Opens a block gzip file for reading or writing.

Arguments:

- bgzfspec (pathname designator, open stream or bgzf object): The file to open or an open stream or bgzf object (which is returned unmodified). The *standard-input* or *standard-ouput* streams may be used.

Key:

- compression (keyword): The zlib compression level (for writing).

Also accepts the keyword arguments applicable to CL:OPEN. However,
an :element-type argument will be ignored as the type is always octet.

Returns:

- A BGZF structure.

Package

sam

Source

bgzf.lisp (file)

Function: bgzf-open-p BGZF
Package

sam

Source

bgzf.lisp (file)

Function: bgzf-seek BGZF POSITION

Seeks with the file encapsulated by a block gzip file.

Arguments:

- bgzf (bgzf structure): The handle to seek.

- position (integer): The position to seek. Only values previously returned by {defun bgzf-tell} may be used. The most significant 48 bits denote the real file position and the least significant 16 bits the offset within the uncompressed gzip member (see the SAM spec).

Returns:

- The new position.

Package

sam

Source

bgzf.lisp (file)

Function: bgzf-tell BGZF

Returns the current position in the encapsulated file of a block gzip file.

Arguments:

- bgzf (bgzf structure): The file.

Returns:

- The file position.

Package

sam

Source

bgzf.lisp (file)

Function: bgzip-open FILESPEC &key DIRECTION

Opens a block gzip stream for FILESPEC.

Key:

- direction (symbol): One of :input (the default) or :output

Returns:

- A {defclass bgzip-stream}

Package

sam

Source

bgzip-stream.lisp (file)

Function: bin-chunk BIN CHUNK-NUM

Returns the chunk number CHUNK-NUM in BIN.

Package

sam

Source

bam-index.lisp (file)

Function: bin-chunks INSTANCE
Function: (setf bin-chunks) VALUE INSTANCE
Package

sam

Source

bam-index.lisp (file)

Function: bin-num INSTANCE
Package

sam

Source

bam-index.lisp (file)

Function: chunk-end INSTANCE
Function: (setf chunk-end) VALUE INSTANCE
Package

sam

Source

bam-index.lisp (file)

Function: chunk-start INSTANCE
Function: (setf chunk-start) VALUE INSTANCE
Package

sam

Source

bam-index.lisp (file)

Function: cigar-length ALN

Returns the number of CIGAR operations in ALN.

Package

sam

Source

bam.lisp (file)

Function: coordinate-sorted-p HEADER

Returns T if parsed HEADER indicates that the file is sorted by coordinate, or NIL otherwise.

Package

sam

Source

sam.lisp (file)

Function: copy-alignment-record ALN &key ALIGNMENT-FLAG REFERENCE-ID ALIGNMENT-POS MATE-REFERENCE-ID MATE-ALIGNMENT-POS MAPPING-QUALITY ALIGNMENT-BIN INSERT-LENGTH CIGAR TAG-VALUES

Returns a copy of ALN, optionally setting some fields to new values.

Package

sam

Source

bam.lisp (file)

Function: empty-bin-p BIN

Returns T if BIN contains no chunks, or NIL otherwise.

Package

sam

Source

bam-index.lisp (file)

Function: ensure-mandatory-header-tags RECORD

Returns HEADER-RECORD if all mandatory tags are present, or raises a {define-condition malformed-record-error} .

Package

sam

Source

sam.lisp (file)

Function: ensure-valid-header-tags RECORD

Checks list HEADER-RECORD for tag validity and returns HEADER-RECORD or raises a {define-condition malformed-record-error} if invalid tags are present. Ignores any user tags (lower case tags).

Package

sam

Source

sam.lisp (file)

Function: ensure-valid-programs HEADER

Returns HEADER if its PG records have unique ID tag values and valid PP tag values. A valid PP tag must point to the ID of one of the other PG records in the header.

Package

sam

Source

sam.lisp (file)

Function: fails-platform-qc-p FLAG

Returns T if FLAG indicates that the read failed plaform quality control, or NIL otherwise.

Package

sam

Source

bam.lisp (file)

Function: find-bam-index BAM-FILESPEC

Returns the pathname of an index file for BAM-FILESPEC, if the file is present and conforms to the naming convention of either Picard or Samtools. If both are present, the Picard convention is favoured.

Package

sam

Source

bam-index.lisp (file)

Function: find-bins INDEX REFERENCE-ID START END

Returns a list of all the bins for reference REFERENCE-ID in INDEX, between reference positions START and END.

Package

sam

Source

bam-index.lisp (file)

Function: first-frag-p FLAG

Returns T if FLAG indicates that the read was the first in a pair of reads from one template, or NIL otherwise.

Package

sam

Source

bam.lisp (file)

Function: first-in-pair-p FLAG

Returns T if FLAG indicates that the read was the first in a pair of reads from one template, or NIL otherwise.

Package

sam

Source

bam.lisp (file)

Function: flag-bits FLAG &rest BIT-NAMES

Returns an integer FLAG that had BAM flag bits named by symbols BIT-NAMES set.

Arguments:

- flag (unsigned-byte 8): a BAM alignment flag.

Rest:

- bit-names (symbols): Any number of valid bit flag names:

;;; :sequenced-pair
;;; :mapped-proper-pair
;;; :query-mapped , :query-unmapped
;;; :mate-mapped , :mate-unmapped
;;; :query-forward , :query-reverse
;;; :mate-forward , :mate-reverse
;;; :first-in-pair , :second-in-pair
;;; :alignment-primary , :alignment-not-primary
;;; :fails-platform-qc
;;; :pcr/optical-duplicate

Returns:

- An (unsigned-byte 8)

Package

sam

Source

bam.lisp (file)

Function: flagstat BAM-FILESPEC &optional STREAM

Writes SAM flag counts from BAM-FILESPEC to STREAM.

Package

sam

Source

cl-sam.lisp (file)

Function: frag-forward-p FLAG

Returns T if FLAG indicates that the read was mapped to the forward strand of a reference, or NIL if it was mapped to the reverse strand.

Package

sam

Source

bam.lisp (file)

Function: frag-mapped-p FLAG

Returns T if FLAG indicates that the read’s mate was mapped to a reference, or NIL otherwise.

Package

sam

Source

bam.lisp (file)

Function: frag-reverse-p FLAG

Returns T if FLAG indicates that the read was mapped to the reverse strand of a reference, or NIL if it was mapped to the forward strand.

Package

sam

Source

bam.lisp (file)

Function: frag-unmapped-p FLAG

Returns T if FLAG indicates that the read was not mapped to a reference, or NIL otherwise.

Package

sam

Source

bam.lisp (file)

Function: generate-bam-file FILESPEC NUM-REFS REF-LENGTH READ-GROUPS &rest ALN-GENERATORS

Writes a very uniform BAM file to the file denoted by pathname designator FILESPEC, for testing purposes.

Arguments:

- filespec (pathname designator): The BAM file to be written.
- num-refs (integer): The number of reference sequences in the BAM header. - read-groups (list of string): The read group names in the BAM header. Each reference will have a set of reads generated in each read group.

Rest:

- aln-generators (list of function): A list of alignment generator functions created with {defun alignment-generator} function. All of these functions will be called until exhausted, so they should represent finite sequences.

Returns

- filespec.

Package

sam

Source

bam-utilities.lisp (file)

Function: generate-reference-file FILESPEC NAME LENGTH &optional FN

Creates an artificial reference genome Fasta file to accompany a generated BAM file.

Arguments:

- filespec (pathname designator): The file to create.
- name (string): The name of the reference sequence.
- length (integer): The length of the reference sequence.

Optional:

- fn (function): A function that returns a single base character. The default randomly returns a, c, g or t in equal proportions.

Returns:

- The filespec.

Package

sam

Source

bam-utilities.lisp (file)

Function: hd-record &key VERSION SORT-ORDER

Returns a new HD record.

Package

sam

Source

sam.lisp (file)

Function: header-records HEADER HEADER-TYPE

Returns a list of all records of HEADER-TYPE from HEADER.

Package

sam

Source

sam.lisp (file)

Function: header-tags RECORD

Returns an alist of the tag-values of RECORD.

Package

sam

Source

sam.lisp (file)

Function: header-type RECORD

Returns a symbol indicating the header-type of RECORD, being one of :HD , :SQ , :RG or :PG .

Package

sam

Source

sam.lisp (file)

Function: header-value RECORD TAG

Returns the value associated with TAG in RECORD.

Package

sam

Source

sam.lisp (file)

Function: index-bam-file FILESPEC

Returns a new BAM-INDEX object, given pathname designator FILESPEC.

Package

sam

Source

bam-indexer.lisp (file)

Function: insert-length ALN

Returns the insert length described by ALN.

Package

sam

Source

bam.lisp (file)

Function: last-frag-p FLAG

Returns T if FLAG indicates that the read was the second in a pair of reads from one template, or NIL otherwise.

Package

sam

Source

bam.lisp (file)

Function: last-programs HEADER

Returns a list of the PG ID values from HEADER that are the last programs to act on the data. i.e. these are the leaf programs in the previous program tree.

Package

sam

Source

sam.lisp (file)

Function: make-alignment-record READ-NAME SEQ-STR ALIGNMENT-FLAG &key REFERENCE-ID ALIGNMENT-POS MATE-REFERENCE-ID MATE-ALIGNMENT-POS MAPPING-QUALITY ALIGNMENT-BIN INSERT-LENGTH CIGAR QUALITY-STR TAG-VALUES

Returns a new alignment record array.

Arguments:

- read-name (string): The read name.
- seq-str (string): The read sequence.
- alignment-flag (integer): The binary alignment flag.

Key:

- reference-id (integer): The reference identifier, defaults to -1
- alignment-pos (integer): The 1-based alignment position, defaults to -1. - mate-reference-id (integer): The reference identifier of the mate, defaults to -1.
- mate-alignment-pos (integer): The 1-based alignment position of the mate. - mapping-quality (integer): The mapping quality, defaults to 0.
- alignment-bin (integer): The alignment bin, defaults to 0.
- insert-length (integer): The insert size, defaults to 0.
- cigar (alist): The cigar represented as an alist of operations e.g.

;;; ’((:M . 9) (:I . 1) (:M . 25))

- quality-str (string): The read quality string.
- tag-values (alist): The alignment tags represented as an alist e.g.

;;; ’((:XT . #U) (:NM . 1) (:X0 . 1) (:X1 . 0)
;;; (:XM . 1) (:XO . 0) (:XG . 0) (:MD . "3T31"))

The tags must have been defined with {defmacro define-alignment-tag} .

Returns:

- A vector of ’(unsigned-byte 8).

Package

sam

Source

bam.lisp (file)

Function: make-bam-output BAM

Returns a consumer function that accepts an argument of a BAM record and writes it to BAM output stream BAM. The standard consumer interface function CONSUME may be used in operations on the returned consumer.

Package

sam

Source

bam-writer.lisp (file)

Function: make-header-record STR

Parses a single SAM header record STR and returns a list. May raise a {define-condition malformed-record-error} or {define-condition malformed-field-error} . SAM tags are converted to keyword symbols.

Given a header record of

;;; "@SQ SN:AL096846 LN:6490 SP:Schizosaccharomyces pombe"

the returned list will be

;;; (:SQ (:SN . "AL096846") (:LN . 6490)
;;; (:SP . "Schizosaccharomyces pombe"))

thus the list’s first element is a keyword describing the record type and the rest of the list is itself an alist of record keys and values.

Package

sam

Source

sam.lisp (file)

Function: make-reference-table REF-META-LIST

Returns a hash-table mapping reference identifiers to reference names for the reference data in REF-META-LIST.

Package

sam

Source

bam.lisp (file)

Function: make-sam-header STR

Returns a list containing the data in header STR as Lisp
objects. If the header is NIL (there was no header) this function
returns NIL.

Given a header of

;;; "@HD VN:1.0
;;; @SQ SN:AL096846 LN:6490 SP:Schizosaccharomyces pombe
;;; @PG ID:bwa VN:0.4.6 CL:aln -n 0.04 -o 1 -e -1 -i 5 -d 10 -k 2 -M 3 -O 11 -E 4"

the returned list will be

;;; ((:HD (:VN . "1.0"))
;;; (:SQ (:SN . "AL096846") (:LN . 6490)
;;; (:SP . "Schizosaccharomyces pombe"))
;;; (:PG (:ID . "bwa") (:VN . "0.4.6")
;;; (:CL . "aln -n 0.04 -o 1 -e -1 -i 5 -d 10 -k 2 -M 3 -O 11 -E 4"))))

thus each list element is a list whose first element is a keyword
describing the record type. The rest of each list is itself an alist
of record keys and values.

Package

sam

Source

sam.lisp (file)

Function: mapped-proper-pair-p FLAG

Returns T if FLAG indicates that the read was mapped as a member of a properly oriented read-pair, or NIL otherwise.

Package

sam

Source

bam.lisp (file)

Function: mapping-quality ALN

Returns the integer mapping quality of ALN.

Package

sam

Source

bam.lisp (file)

Function: mate-alignment-position ALN

Returns the 0-based sequence position of the read mate’s alignment described by ALN.

Package

sam

Source

bam.lisp (file)

Function: mate-forward-p FLAG

Returns T if FLAG indicates that the read’s mate was mapped to the forward, or NIL if it was mapped to the reverse strand.

Package

sam

Source

bam.lisp (file)

Function: mate-mapped-p FLAG

Returns T if FLAG indicates that the read’s mate was mapped to a reference, or NIL otherwise.

Package

sam

Source

bam.lisp (file)

Function: mate-reference-id ALN

Returns the integer reference ID of ALN.

Package

sam

Source

bam.lisp (file)

Function: mate-reverse-p FLAG

Returns T if FLAG indicates that the read’s mate was mapped to the reverse, or NIL if it was mapped to the forward strand.

Package

sam

Source

bam.lisp (file)

Function: mate-unmapped-p FLAG

Returns T if FLAG indicates that the read’s mate was not mapped to a reference, or NIL otherwise.

Package

sam

Source

bam.lisp (file)

Function: medial-frag-p FLAG

Returns T if FLAG indicates that the read was sequenced as a non-terminal part of a linear template, or NIL otherwise.

Package

sam

Source

bam.lisp (file)

Function: merge-header-records RECORD1 RECORD2

Returns a new header record created by merging the tags of header-records RECORD1 and RECORD2. Records may be safely merged if they have the same header-type and do not contain any conflicting tag values.

Package

sam

Source

sam.lisp (file)

Function: merge-sam-headers &rest HEADERS

Returns a new SAM header that is the result of merging HEADERS. Headers may be safely merged if none of their constituent records contain conflicting tag values once merged.

Package

sam

Source

sam.lisp (file)

Function: multiple-frags-p FLAG

Returns T if FLAG indicates that the read was sequenced as a member of a pair, or NIL otherwise.

Package

sam

Source

bam.lisp (file)

Function: name-sorted-p HEADER

Returns T if parsed HEADER indicates that the file is sorted by name, or NIL otherwise.

Package

sam

Source

sam.lisp (file)

Function: next-reverse-p FLAG

Returns T if FLAG indicates that the read’s mate was mapped to the reverse, or NIL if it was mapped to the forward strand.

Package

sam

Source

bam.lisp (file)

Function: next-unmapped-p FLAG

Returns T if FLAG indicates that the read’s mate was not mapped to a reference, or NIL otherwise.

Package

sam

Source

bam.lisp (file)

Function: parse-region-string STR

Returns a new region from a string region designator in samtools-style format:

<reference name>:<start coordinate>-<end coordinate>

The reference name must be one of those described in the BAM header metadata. The reference sequence coordinates are zero-based, half open with start < end.

Package

sam

Source

bam-reader.lisp (file)

Function: pcr/optical-duplicate-p FLAG

Returns T if FLAG indicates that the read is a PCR or optical duplicate, or NIL otherwise.

Package

sam

Source

bam.lisp (file)

Function: pg-record IDENTITY &key PROGRAM-NAME PROGRAM-VERSION PREVIOUS-PROGRAM COMMAND-LINE

Returns a new PG record.

Package

sam

Source

sam.lisp (file)

Function: previous-programs HEADER IDENTITY

Returns a list of PG ID values from HEADER that are previous programs with respect to PG ID IDENTITY. The list is ordered with the most recently used program first i.e. reverse chronological order.

Package

sam

Source

sam.lisp (file)

Function: proper-aligned-frags-p FLAG

Returns T if FLAG indicates that the read was mapped as a member of a properly oriented read-pair, or NIL otherwise.

Package

sam

Source

bam.lisp (file)

Function: quality-string ALN

Returns the sequence quality string described by ALN.

Package

sam

Source

bam.lisp (file)

Function: query-forward-p FLAG

Returns T if FLAG indicates that the read was mapped to the forward strand of a reference, or NIL if it was mapped to the reverse strand.

Package

sam

Source

bam.lisp (file)

Function: query-mapped-p FLAG

Returns T if FLAG indicates that the read’s mate was mapped to a reference, or NIL otherwise.

Package

sam

Source

bam.lisp (file)

Function: query-reverse-p FLAG

Returns T if FLAG indicates that the read was mapped to the reverse strand of a reference, or NIL if it was mapped to the forward strand.

Package

sam

Source

bam.lisp (file)

Function: query-unmapped-p FLAG

Returns T if FLAG indicates that the read was not mapped to a reference, or NIL otherwise.

Package

sam

Source

bam.lisp (file)

Function: read-alignment BGZF &key VALIDATE

Reads one alignment block from handle BGZF, returns it as a Lisp array of unsigned-byte 8. The handle is advanced to the next alignment. If no more alignments are available, returns NIL.

This is the preferred function to use for validation. i.e. validate early. A USE-VALUE restart is provided so that an invalid alignment may be modified and re-read without unwinding the stack.

Package

sam

Source

bam-reader.lisp (file)

Function: read-bam-header BGZF

Returns the unparsed BAM header from the handle BGZF as a Lisp string.

Package

sam

Source

bam-reader.lisp (file)

Function: read-bam-index STREAM

Reads a BAM (.bai) index from STREAM.

Package

sam

Source

bam-index-reader.lisp (file)

Function: read-bam-magic BGZF

Reads the BAM magic number from the handle BGZF and returns T if it is valid or raises a {define-condition malformed-file-error} if not.

Package

sam

Source

bam-reader.lisp (file)

Function: read-bam-meta BGZF

Reads all BAM metadata from handle BGZF, leaving the handle pointing at the first alignment record. Returns the header string, the number of references and a list of reference sequence metadata. The list contains one element per reference sequence, each element being a list of reference identifier, reference name and reference length.

Package

sam

Source

bam-reader.lisp (file)

Function: read-bam-terminator BGZF

Reads the EOF from handle BGZF, returning T if it is present, or raising a {define-condition malformed-file-error} otherwise.

Package

sam

Source

bam-reader.lisp (file)

Function: read-length ALN

Returns the length of the read described by ALN.

Package

sam

Source

bam.lisp (file)

Function: read-name ALN

Returns the read name string described by ALN.

Package

sam

Source

bam.lisp (file)

Function: read-name-length ALN

Returns the length in ASCII characters of the read name of ALN.

Package

sam

Source

bam.lisp (file)

Function: read-num-references BGZF

Returns the number of reference sequences described in the BAM header of handle BGZF.

Package

sam

Source

bam-reader.lisp (file)

Function: read-reference-meta BGZF

Returns the reference sequence metadata for a single reference sequence described in the BAM header of handle BGZF. Two values are returned, the reference name as a string and the reference length as an integer,

Package

sam

Source

bam-reader.lisp (file)

Function: ref-index BAM-INDEX REFERENCE-ID

Returns the reference index for reference number REFERENCE-ID in BAM-INDEX.

Package

sam

Source

bam-index.lisp (file)

Function: ref-index-bin REF-INDEX BIN-NUM

Returns the BIN number BIN-NUM in REF-INDEX.

Package

sam

Source

bam-index.lisp (file)

Function: ref-index-bins INSTANCE
Function: (setf ref-index-bins) VALUE INSTANCE
Package

sam

Source

bam-index.lisp (file)

Function: ref-index-intervals INSTANCE
Function: (setf ref-index-intervals) VALUE INSTANCE
Package

sam

Source

bam-index.lisp (file)

Function: reference-id ALN

Returns the reference sequence identifier of ALN. This is an integer locally assigned to a reference sequence within the context of a BAM file.

Package

sam

Source

bam.lisp (file)

Function: repair-mapping-flags ALN

Returns alignment ALN if it has correct mapped-proper-pair, query-mapped and mate-mapped flags, or a modified copy with fixed flags. Also sets the user tag ZF:I:<original flag> if the flags are changed.

Alignments produced by the BWA aligner have been observed to contain invalid flags. This is caused by BWA creating mappings that overhang the end of the reference. The underlying cause is reference concatenation in the Burrows-Wheeler index.

This function attempts to fix invalid mapped-proper-pair flags in cases where query-unmapped and/or mate-unmapped flags are set. Such unmapped reads may also have reference-ids set and good mapping scores. This function does not correct these other fields.

It is necessary to use this function in order to obtain correct flag counts when using samtools flagstat or {defun flagstat} .

Package

sam

Source

bam-utilities.lisp (file)

Function: rg-record IDENTITY SAMPLE &key LIBRARY DESCRIPTION PLATFORM-UNIT INSERT-SIZE SEQUENCING-CENTRE SEQUENCING-DATE PLATFORM-TECH FLOW-ORDER KEY-SEQUENCE

Returns a new RG record.

Package

sam

Source

sam.lisp (file)

Function: second-in-pair-p FLAG

Returns T if FLAG indicates that the read was the second in a pair of reads from one template, or NIL otherwise.

Package

sam

Source

bam.lisp (file)

Function: seq-string ALN

Returns the sequence string described by ALN.

Package

sam

Source

bam.lisp (file)

Function: sequenced-pair-p FLAG

Returns T if FLAG indicates that the read was sequenced as a member of a pair, or NIL otherwise.

Package

sam

Source

bam.lisp (file)

Function: sort-bam-file IN-FILESPEC OUT-FILESPEC &key SORT-ORDER BUFFER-SIZE

Sorts a BAM file by coordinate or by read name.

Arguments:

- in-filespec (pathname designator): The input BAM file.
- out-filespec (pathname designator): The output BAM file.

Key:

- sort-order (symbol): The sort order, either :coordinate
or :queryname .

- buffer-size (fixnum): The maximum number of reads to sort in memory at any one time, defaulting to 1000000.

Returns:

- The number of alignments sorted.
- The number of files used in the external merge sort.

Package

sam

Source

external-bam-sort.lisp (file)

Function: sq-record SEQ-NAME SEQ-LENGTH &key ASSEMBLY-IDENTITY SEQ-MD5 SEQ-URI SEQ-SPECIES

Returns a new SQ record.

Package

sam

Source

sam.lisp (file)

Function: subst-group-order HEADER ORDER

Returns a copy of HEADER with any group order tag initially present substituted by symbol ORDER, which must be one of the valid SAM sort orders. If there is no HD record in HEADER, one is added.

Package

sam

Source

sam.lisp (file)

Function: subst-sam-version HEADER &optional VERSION

Returns a copy of HEADER with any header version tag initially present substituted by string VERSION, defaulting to *SAM-VERSION* .

Package

sam

Source

sam.lisp (file)

Function: subst-sort-order HEADER ORDER

Returns a copy of HEADER with any sort order tag initially present substituted by symbol ORDER, which must be one of the valid SAM sort orders. If there is no HD record in HEADER, one is added.

Package

sam

Source

sam.lisp (file)

Function: unknown-frag-p FLAG

Returns T if FLAG indicates that the read was sequenced as part of a non-linear template or as part of a linear template where the position has been lost, or NIL otherwise.

Package

sam

Source

bam.lisp (file)

Function: valid-flag-p FLAG

Returns T if the paired-read-specific bits of FLAG are internally consistent.

Package

sam

Source

bam.lisp (file)

Function: valid-mapped-pair-p FLAG

Returns T if FLAG indicates valid mapping states for a pair of mapped reads, that is both must be mapped, or NIL otherwise.

Package

sam

Source

bam.lisp (file)

Function: valid-mapped-proper-pair-p FLAG

Returns T if FLAG indicates valid proper mapping states for a pair of mapped reads, that is both must be mapped and on opposite strands, or NIL otherwise.

Package

sam

Source

bam.lisp (file)

Function: valid-reference-name-p STR

Returns T if STR is a valid reference sequence name matching the regex [!-)+-<>-~][!-~]* , or NIL otherwise.

Package

sam

Source

sam.lisp (file)

Function: valid-sam-version-p STR

Returns T if SAM version string STR matches /^[0-9]+.[0-9]$/, or NIL otherwise.

Package

sam

Source

sam.lisp (file)

Function: view-sam BAM-FILESPEC SAM-FILESPEC

Writes the contents of binary BAM file BAM-FILESPEC to SAM text file SAM-FILESPEC.

Package

sam

Source

cl-sam.lisp (file)

Function: write-alignment BGZF ALIGNMENT-RECORD

Writes one ALIGNMENT-RECORD to handle BGZF and returns the number of bytes written.

Package

sam

Source

bam-writer.lisp (file)

Function: write-bam-header BGZF HEADER &key COMPRESS NULL-PADDING MTIME

Writes the BAM header string HEADER to handle BGZF, followed by padding of NULL-PADDING null bytes. This function also writes the header length, including padding, in the 4 bytes preceding the header.

Package

sam

Source

bam-writer.lisp (file)

Function: write-bam-magic BGZF &key COMPRESS

Writes the BAM magic number to the handle BGZF.

Package

sam

Source

bam-writer.lisp (file)

Function: write-bam-meta BGZF HEADER NUM-REFS REF-META &key COMPRESS NULL-PADDING

Writes BAM magic number and then all metadata to handle BGZF. The metadata consist of the HEADER string, number of reference sequences NUM-REFS and a list reference sequence metadata REF-META. The list contains one element per reference sequence, each element being a list of reference identifier, reference name and reference length. Returns the number of bytes written.

Key:

- compress-header (boolean): Compress the header block if T.
- null-padding (fixnum): A number of null bytes to be appended to the end of the header string, as allowed by the SAM spec. This is useful for creating slack space so that BAM headers may be edited in place.

Package

sam

Source

bam-writer.lisp (file)

Function: write-header-record HEADER-RECORD &optional STREAM

Writes alist HEADER-RECORD to STREAM.

Package

sam

Source

sam-writer.lisp (file)

Function: write-num-references BGZF N

Writes the number of reference sequences N to handle BGZF.

Package

sam

Source

bam-writer.lisp (file)

Function: write-reference-meta BGZF REF-NAME REF-LENGTH

Writes the metadata for a single reference sequence named REF-NAME, of length REF-LENGTH bases, to handle BGZF.

Package

sam

Source

bam-writer.lisp (file)

Function: write-sam-alignment ALIGNMENT-RECORD REF-TABLE &optional STREAM

Writes ALIGNMENT-RECORD to STREAM as SAM. REF-TABLE is a hash-table created by {defun make-reference-table} .

Package

sam

Source

sam-writer.lisp (file)

Function: write-sam-header ALIST &optional STREAM

Writes SAM header ALIST as a string to STREAM.

Package

sam

Source

sam-writer.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.4 Generic functions

Generic Function: alignment-tag-documentation TAG

Returns the documentation for TAG or NIL if none is available.

Package

sam

Source

bam.lisp (file)

Methods
Method: alignment-tag-documentation (TAG (eql xt))
Method: alignment-tag-documentation (TAG (eql xs))
Method: alignment-tag-documentation (TAG (eql xo))
Method: alignment-tag-documentation (TAG (eql xn))
Method: alignment-tag-documentation (TAG (eql xm))
Method: alignment-tag-documentation (TAG (eql xg))
Method: alignment-tag-documentation (TAG (eql xf))
Method: alignment-tag-documentation (TAG (eql xe))
Method: alignment-tag-documentation (TAG (eql xc))
Method: alignment-tag-documentation (TAG (eql xa))
Method: alignment-tag-documentation (TAG (eql x1))
Method: alignment-tag-documentation (TAG (eql x0))
Method: alignment-tag-documentation (TAG (eql zf))
Method: alignment-tag-documentation (TAG (eql za))
Method: alignment-tag-documentation (TAG (eql uq))
Method: alignment-tag-documentation (TAG (eql u2))
Method: alignment-tag-documentation (TAG (eql tc))
Method: alignment-tag-documentation (TAG (eql sq))
Method: alignment-tag-documentation (TAG (eql sm))
Method: alignment-tag-documentation (TAG (eql s2))
Method: alignment-tag-documentation (TAG (eql sa))
Method: alignment-tag-documentation (TAG (eql rt))
Method: alignment-tag-documentation (TAG (eql rg))
Method: alignment-tag-documentation (TAG (eql r2))
Method: alignment-tag-documentation (TAG (eql qt))
Method: alignment-tag-documentation (TAG (eql q2))
Method: alignment-tag-documentation (TAG (eql pu))
Method: alignment-tag-documentation (TAG (eql pt))
Method: alignment-tag-documentation (TAG (eql pq))
Method: alignment-tag-documentation (TAG (eql pg))
Method: alignment-tag-documentation (TAG (eql oq))
Method: alignment-tag-documentation (TAG (eql op))
Method: alignment-tag-documentation (TAG (eql oc))
Method: alignment-tag-documentation (TAG (eql nm))
Method: alignment-tag-documentation (TAG (eql nh))
Method: alignment-tag-documentation (TAG (eql mq))
Method: alignment-tag-documentation (TAG (eql mf))
Method: alignment-tag-documentation (TAG (eql md))
Method: alignment-tag-documentation (TAG (eql ih))
Method: alignment-tag-documentation (TAG (eql hi))
Method: alignment-tag-documentation (TAG (eql h2))
Method: alignment-tag-documentation (TAG (eql h1))
Method: alignment-tag-documentation (TAG (eql h0))
Method: alignment-tag-documentation (TAG (eql lb))
Method: alignment-tag-documentation (TAG (eql gq))
Method: alignment-tag-documentation (TAG (eql gs))
Method: alignment-tag-documentation (TAG (eql gc))
Method: alignment-tag-documentation (TAG (eql fz))
Method: alignment-tag-documentation (TAG (eql fs))
Method: alignment-tag-documentation (TAG (eql fi))
Method: alignment-tag-documentation (TAG (eql e2))
Method: alignment-tag-documentation (TAG (eql ct))
Method: alignment-tag-documentation (TAG (eql cs))
Method: alignment-tag-documentation (TAG (eql cq))
Method: alignment-tag-documentation (TAG (eql cp))
Method: alignment-tag-documentation (TAG (eql co))
Method: alignment-tag-documentation (TAG (eql cm))
Method: alignment-tag-documentation (TAG (eql cc))
Method: alignment-tag-documentation (TAG (eql bq))
Method: alignment-tag-documentation (TAG (eql bc))
Method: alignment-tag-documentation (TAG (eql as))
Method: alignment-tag-documentation (TAG (eql am))
Method: alignment-tag-documentation TAG
Generic Function: write-bam-index INDEX STREAM
Package

sam

Source

bam-index-writer.lisp (file)

Methods
Method: write-bam-index (INDEX bam-index) STREAM
Method: write-bam-index (INDEX samtools-bam-index) STREAM

Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.5 Conditions

Condition: bam-error ()

The parent type of all BAM error conditions.

Package

sam

Source

conditions.lisp (file)

Direct superclasses
  • formatted-condition (condition)
  • error (condition)
Direct subclasses

bam-sort-error (condition)

Condition: bam-sort-error ()
Package

sam

Source

conditions.lisp (file)

Direct superclasses

bam-error (condition)

Direct methods
Direct slots
Slot: prev-position
Initargs

:prev-position

Initform

(quote nil)

Readers

prev-position-of (generic function)

Slot: position
Initargs

:position

Initform

(quote nil)

Readers

position-of (generic function)

Slot: prev-reference
Initargs

:prev-reference

Initform

(quote nil)

Readers

prev-reference-of (generic function)

Slot: reference
Initargs

:reference

Initform

(quote nil)

Readers

reference-of (generic function)

Condition: bgzf-io-error ()

A condition raised when an error occurs reading from or writing to a BGZF stream.

Package

sam

Source

conditions.lisp (file)

Direct superclasses
  • simple-text-condition (condition)
  • io-error (condition)
Direct methods
Direct slots
Slot: bgzf

The BGZF stream that caused the error.

Initargs

:bgzf

Initform

(quote nil)

Readers

bgzf-of (generic function)

Slot: errno

The C error number.

Initargs

:errno

Initform

(quote nil)

Readers

errno-of (generic function)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.6 Structures

Structure: bam-index ()

A BAM file index covering all the reference sequences in a BAM file.

Package

sam

Source

bam-index.lisp (file)

Direct superclasses

structure-object (structure)

Direct subclasses

samtools-bam-index (structure)

Direct methods

write-bam-index (method)

Direct slots
Slot: refs
Type

simple-vector

Initform

(make-array 0)

Readers

bam-index-refs (function)

Writers

(setf bam-index-refs) (function)

Structure: bgzf ()

A block gzip file.

- pathname: The file pathname.
- stream: The file stream.
- buffer: A simple-octet-vector used for buffering reads.
- position: The file position component of the BGZF virtual file offset (most significant 48 bits). This is the position in the stream at which this member starts.
- offset: The within-member offset component of the BGZF virtual file offset (least significant 16 bits). This is a position within the uncompressed data of the member.
- pointer: The buffer index after the last usable data element. i.e. the index at which new data may be written to the buffer prior to deflating. Calling (subseq buffer 0 bgzf-pointer) will extract the current usable bytes.
- util-buffer: a 4 byte buffer used internally to store an integer. - loaded-p: T if the bgz data has been loaded into the buffer (used internally in decompression and reading).
- load-seek: On loading the bgz data, proceed immediately to this offset (used internally in decompression and reading).
- eof: T if the decompression process has reached EOF (used internally in decompression and reading).

Package

sam

Source

bgzf.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: pathname
Readers

bgzf-pathname (function)

Writers

(setf bgzf-pathname) (function)

Slot: stream
Readers

bgzf-stream (function)

Writers

(setf bgzf-stream) (function)

Slot: compression
Type

(integer 0 9)

Initform

sam::*default-compression*

Readers

bgzf-compression (function)

Writers

(setf bgzf-compression) (function)

Slot: buffer
Type

uk.co.deoxybyte-utilities:simple-octet-vector

Initform

(make-array sam::+bgz-max-payload-length+ :element-type (quote uk.co.deoxybyte-utilities:octet))

Readers

bgzf-buffer (function)

Writers

(setf bgzf-buffer) (function)

Slot: position
Type

(unsigned-byte 48)

Initform

0

Readers

bgzf-position (function)

Writers

(setf bgzf-position) (function)

Slot: offset
Type

uk.co.deoxybyte-utilities:uint16

Initform

0

Readers

bgzf-offset (function)

Writers

(setf bgzf-offset) (function)

Slot: pointer
Type

(integer 0 65536)

Initform

0

Readers

bgzf-pointer (function)

Writers

(setf bgzf-pointer) (function)

Slot: util-buffer
Type

(simple-array uk.co.deoxybyte-utilities:octet (4))

Initform

(make-array 4 :element-type (quote uk.co.deoxybyte-utilities:octet) :initial-element 0)

Readers

bgzf-util-buffer (function)

Writers

(setf bgzf-util-buffer) (function)

Slot: loaded-p
Readers

bgzf-loaded-p (function)

Writers

(setf bgzf-loaded-p) (function)

Slot: load-seek
Type

uk.co.deoxybyte-utilities:uint16

Initform

0

Readers

bgzf-load-seek (function)

Writers

(setf bgzf-load-seek) (function)

Slot: eof
Readers

bgzf-eof (function)

Writers

(setf bgzf-eof) (function)

Structure: bin ()

A bin within a BAM binning index. A bin is a region on a reference sequence that is identified by a number. The bin location and numbering system used is the UCSC binning scheme by Richard Durbin and Lincoln Stein. A bin contains a vector of chunks.

Package

sam

Source

bam-index.lisp (file)

Direct superclasses

structure-object (structure)

Direct methods

print-object (method)

Direct slots
Slot: num
Type

fixnum

Initform

0

Readers

bin-num (function)

Writers

(setf bin-num) (function)

Slot: chunks
Type

simple-vector

Initform

(make-array 0)

Readers

bin-chunks (function)

Writers

(setf bin-chunks) (function)

Structure: chunk ()

A chunk within a BAM index bin. Chunks are groups of records that lie within a bin and are close together within the BAM file.

Package

sam

Source

bam-index.lisp (file)

Direct superclasses

structure-object (structure)

Direct methods

print-object (method)

Direct slots
Slot: start
Type

(unsigned-byte 64)

Initform

0

Readers

chunk-start (function)

Writers

(setf chunk-start) (function)

Slot: end
Type

(unsigned-byte 64)

Initform

most-positive-fixnum

Readers

chunk-end (function)

Writers

(setf chunk-end) (function)

Structure: ref-index ()

An index for a single reference sequence. An index is composed of a vector of bins (the binning index) and a vector of intervals (the linear index). The bins are sorted by increasing bin number. The binning index is hierarchical, while the linear index is flat, being a projection of reads from all bins onto a single vector.

Package

sam

Source

bam-index.lisp (file)

Direct superclasses

structure-object (structure)

Direct subclasses

samtools-ref-index (structure)

Direct methods
Direct slots
Slot: id
Type

fixnum

Initform

sam::+unknown-reference+

Readers

ref-index-id (function)

Writers

(setf ref-index-id) (function)

Slot: bins
Type

simple-vector

Initform

(make-array 0 :initial-element nil)

Readers

ref-index-bins (function)

Writers

(setf ref-index-bins) (function)

Slot: intervals
Type

(simple-array fixnum (*))

Initform

(make-array 0 :element-type (quote fixnum))

Readers

ref-index-intervals (function)

Writers

(setf ref-index-intervals) (function)


Previous: , Up: Exported definitions   [Contents][Index]

6.1.7 Classes

Class: bgzip-input-stream ()

A stream that reads from a BGZF file.

Package

sam

Source

bgzip-stream.lisp (file)

Direct superclasses
  • fundamental-binary-input-stream (class)
  • bgzip-stream (class)
Direct methods
  • stream-read-sequence (method)
  • stream-read-byte (method)
  • stream-file-position (method)
Direct slots
Slot: buffer

The Lisp buffer from which data are read.

Initargs

:buffer

Slot: num-bytes

The number of bytes that were read into the buffer from the stream.

Initform

0

Slot: offset

The offset in the byte buffer from which the next byte is to be read.

Initform

0

Class: bgzip-stream ()

A BGZF stream capable of reading or writing block compressed data.

Package

sam

Source

bgzip-stream.lisp (file)

Direct superclasses
Direct subclasses

bgzip-input-stream (class)

Direct methods
  • stream-close (method)
  • stream-element-type (method)

Previous: , Up: Definitions   [Contents][Index]

6.2 Internal definitions


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.1 Constants

Constant: +alignment-size-tag+

The size of the BAM alignment size indicator.

Package

sam

Source

bam.lisp (file)

Constant: +bgz-max-payload-length+

The maximium size in bytes of a BGZ member payload. This is dictated by the fact that the SAM spec makes 16 bits are avaliable for addressing positions with the BGZ member.

Package

sam

Source

bgzf.lisp (file)

Constant: +bgzip-buffer-size+

Buffer size for {defclass bgzip-input-stream} internal buffer.

Package

sam

Source

bgzip-stream.lisp (file)

Constant: +linear-bin-size+

The size in bases of intervals in the linear bin index.

Package

sam

Source

bam-index.lisp (file)

Constant: +max-num-bins+

The maximum number of bins possible in the BAM indexing scheme.

Package

sam

Source

bam-index.lisp (file)

Constant: +member-footer-length+

The total number of bytes in the BGZ footer.

Package

sam

Source

bgzf.lisp (file)

Constant: +member-header-length+

The total number of bytes in the BGZ header.

Package

sam

Source

bgzf.lisp (file)

Constant: +null-byte+

The termination byte for BAM strings.

Package

sam

Source

bam.lisp (file)

Constant: +samtools-kludge-bin+

Extra bin with different semantics added by samtools.

Package

sam

Source

bam-index.lisp (file)

Constant: +sf1+

The value of the RCF1952 first extra subfield used by BGZ members.

Package

sam

Source

bgzf.lisp (file)

Constant: +sf2+

The value of the RCF1952 first extra subfield used by BGZ members.

Package

sam

Source

bgzf.lisp (file)

Constant: +slen+

The value of the RFC1952 subfield length field used by BGZ members.

Package

sam

Source

bgzf.lisp (file)

Constant: +tag-size+

The size of a BAM auxilliary tag in bytes.

Package

sam

Source

bam.lisp (file)

Constant: +unknown-position+

The position value for unmapped reads.

Package

sam

Source

bam.lisp (file)

Constant: +unknown-quality+

The value for unavailable quality scores.

Package

sam

Source

bam.lisp (file)

Constant: +unknown-reference+

The reference id for unmapped reads.

Package

sam

Source

bam.lisp (file)

Constant: +xlen+

The value of the RCF1952 eXtra LENgth field used by BGZ members.

Package

sam

Source

bgzf.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.2 Special variables

Special Variable: *bam-index-file-type*
Package

sam

Source

bam-index.lisp (file)

Special Variable: *bam-index-magic*

The BAI index file magic header bytes.

Package

sam

Source

bam-index.lisp (file)

Special Variable: *bam-magic*

The BAM file magic header bytes.

Package

sam

Source

bam.lisp (file)

Special Variable: *default-compression*

The default bgz compression level (Zlib level 5).

Package

sam

Source

bgzf.lisp (file)

Special Variable: *empty-bgz-record*

SAMtools version >0.1.5 appends an empty BGZF record to allow detection of truncated BAM files. These 28 bytes constitute such a record.

Package

sam

Source

bgzf.lisp (file)

Special Variable: *invalid-read-name-chars*
Package

sam

Source

bam.lisp (file)

Special Variable: *mandatory-header-tags*

A mapping that describes the mandatory tags for each SAM header record type.

Package

sam

Source

sam.lisp (file)

Special Variable: *tree-deepening-boundaries*
Package

sam

Source

bam-index.lisp (file)

Special Variable: *valid-group-orders*

Valid values for SAM group order tags. Group order is no longer a valid tag in SAM version 1.3.

Package

sam

Source

sam.lisp (file)

Special Variable: *valid-header-tags*

A mapping that describes the valid tags for each SAM header record type.

Package

sam

Source

sam.lisp (file)

Special Variable: *valid-header-types*

A list of valid SAM header types.

Package

sam

Source

sam.lisp (file)

Special Variable: *valid-sort-orders*

Valid values for SAM sort order tags.

Package

sam

Source

sam.lisp (file)

Special Variable: *voffset-merge-distance*

If two index chunks are this number of bytes or closer to each other, they should be merged.

Package

sam

Source

bam-index.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.3 Macros

Macro: define-header-tag-parser NAME (HEADER-TYPE VAR) TAG-SPECS

Defines a tag parsing function NAME that parses tag values for SAM header HEADER-TYPE.

Package

sam

Source

sam.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.4 Functions

Function: %encode-string-tag VALUE ALN INDEX
Package

sam

Source

bam.lisp (file)

Function: %make-bam-index NUM-REFS REF-INDICES &optional UNASSIGNED
Package

sam

Source

bam-indexer.lisp (file)

Function: %make-ref-index REFERENCE-ID REF-START REF-END CHUNKS INTERVALS &optional MAPPED UNMAPPED
Package

sam

Source

bam-indexer.lisp (file)

Function: %read-bam-alignment STREAM NUM-BYTES
Package

sam

Source

external-bam-sort.lisp (file)

Function: %stream-read-sequence STREAM SEQUENCE &optional START END
Package

sam

Source

bgzip-stream.lisp (file)

Function: %write-int32 N BUFFER STREAM
Package

sam

Source

bam-index-writer.lisp (file)

Function: %write-int64 N BUFFER STREAM
Package

sam

Source

bam-index-writer.lisp (file)

Function: adjacentp CHUNK1 CHUNK2

Returns T if BAM index CHUNK1 and CHUNK2 are adjacent. In this context this means that they are sequential in a file stream and close enough together for it to be more efficient to continue reading across the intervening bytes, rather than seeking.

Package

sam

Source

bam-index.lisp (file)

Function: alignment-indices ALN

Returns 7 integer values which are byte-offsets within ALN at which the various core data lie. See the SAM spec.

Package

sam

Source

bam.lisp (file)

Function: alignment-name-natural< ALIGNMENT-RECORD1 ALIGNMENT-RECORD2
Package

sam

Source

external-bam-sort.lisp (file)

Function: alignment-p OBJECT
Package

sam

Source

bam.lisp (file)

Function: alignment-primary-p FLAG

Returns T if FLAG indicates that the read mapping was the primary mapping to a reference, or NIL otherwise.

Package

sam

Source

bam.lisp (file)

Function: alignment-read-length ALN

Returns the length of the alignment on the read.

Package

sam

Source

bam.lisp (file)

Function: alignment-reference-length ALN

Returns the length of the alignment on the reference.

Package

sam

Source

bam.lisp (file)

Function: alignment-tag-bytes VALUE

Returns the number of bytes required to encode VALUE.

Package

sam

Source

bam.lisp (file)

Function: aln-bin INSTANCE
Function: (setf aln-bin) VALUE INSTANCE
Package

sam

Source

bam.lisp (file)

Function: aln-cigar INSTANCE
Function: (setf aln-cigar) VALUE INSTANCE
Package

sam

Source

bam.lisp (file)

Function: aln-flag INSTANCE
Function: (setf aln-flag) VALUE INSTANCE
Package

sam

Source

bam.lisp (file)

Function: aln-insert-length INSTANCE
Function: (setf aln-insert-length) VALUE INSTANCE
Package

sam

Source

bam.lisp (file)

Function: aln-map-qual INSTANCE
Function: (setf aln-map-qual) VALUE INSTANCE
Package

sam

Source

bam.lisp (file)

Function: aln-mate-pos INSTANCE
Function: (setf aln-mate-pos) VALUE INSTANCE
Package

sam

Source

bam.lisp (file)

Function: aln-mate-ref-id INSTANCE
Function: (setf aln-mate-ref-id) VALUE INSTANCE
Package

sam

Source

bam.lisp (file)

Function: aln-pos INSTANCE
Function: (setf aln-pos) VALUE INSTANCE
Package

sam

Source

bam.lisp (file)

Function: aln-qual-str INSTANCE
Function: (setf aln-qual-str) VALUE INSTANCE
Package

sam

Source

bam.lisp (file)

Function: aln-read-name INSTANCE
Function: (setf aln-read-name) VALUE INSTANCE
Package

sam

Source

bam.lisp (file)

Function: aln-record INSTANCE
Function: (setf aln-record) VALUE INSTANCE
Package

sam

Source

bam.lisp (file)

Function: aln-ref-id INSTANCE
Function: (setf aln-ref-id) VALUE INSTANCE
Package

sam

Source

bam.lisp (file)

Function: aln-ref-len INSTANCE
Function: (setf aln-ref-len) VALUE INSTANCE
Package

sam

Source

bam.lisp (file)

Function: aln-seq-str INSTANCE
Function: (setf aln-seq-str) VALUE INSTANCE
Package

sam

Source

bam.lisp (file)

Function: bam-index-p OBJECT
Package

sam

Source

bam-index.lisp (file)

Function: bam-meta-size FILESPEC

Returns the number of bytes occupied by the metadata in the BAM file FILESPEC. Metadata is defined here as the magic number, header and header padding, reference sequence count and reference sequence names and lengths.

Package

sam

Source

bam-reader.lisp (file)

Function: bam-meta-size2 HEADER &rest REF-META
Package

sam

Source

bam-reader.lisp (file)

Function: bgz-member-bsize INSTANCE
Function: (setf bgz-member-bsize) VALUE INSTANCE
Package

sam

Source

bgzf.lisp (file)

Function: bgz-member-cdata INSTANCE
Function: (setf bgz-member-cdata) VALUE INSTANCE
Package

sam

Source

bgzf.lisp (file)

Function: bgz-member-cend INSTANCE
Function: (setf bgz-member-cend) VALUE INSTANCE
Package

sam

Source

bgzf.lisp (file)

Function: bgz-member-cm INSTANCE
Package

sam

Source

bgzf.lisp (file)

Function: bgz-member-crc32 INSTANCE
Function: (setf bgz-member-crc32) VALUE INSTANCE
Package

sam

Source

bgzf.lisp (file)

Function: bgz-member-flg INSTANCE
Function: (setf bgz-member-flg) VALUE INSTANCE
Package

sam

Source

bgzf.lisp (file)

Function: bgz-member-id1 INSTANCE
Package

sam

Source

bgzf.lisp (file)

Function: bgz-member-id2 INSTANCE
Package

sam

Source

bgzf.lisp (file)

Function: bgz-member-isize INSTANCE
Function: (setf bgz-member-isize) VALUE INSTANCE
Package

sam

Source

bgzf.lisp (file)

Function: bgz-member-mtime INSTANCE
Function: (setf bgz-member-mtime) VALUE INSTANCE
Package

sam

Source

bgzf.lisp (file)

Function: bgz-member-os INSTANCE
Function: (setf bgz-member-os) VALUE INSTANCE
Package

sam

Source

bgzf.lisp (file)

Function: bgz-member-p OBJECT
Package

sam

Source

bgzf.lisp (file)

Function: bgz-member-sf1 INSTANCE
Package

sam

Source

bgzf.lisp (file)

Function: bgz-member-sf2 INSTANCE
Package

sam

Source

bgzf.lisp (file)

Function: bgz-member-slen INSTANCE
Package

sam

Source

bgzf.lisp (file)

Function: bgz-member-udata INSTANCE
Function: (setf bgz-member-udata) VALUE INSTANCE
Package

sam

Source

bgzf.lisp (file)

Function: bgz-member-xfl INSTANCE
Function: (setf bgz-member-xfl) VALUE INSTANCE
Package

sam

Source

bgzf.lisp (file)

Function: bgz-member-xlen INSTANCE
Function: (setf bgz-member-xlen) VALUE INSTANCE
Package

sam

Source

bgzf.lisp (file)

Function: bgzf-buffer INSTANCE
Function: (setf bgzf-buffer) VALUE INSTANCE
Package

sam

Source

bgzf.lisp (file)

Function: bgzf-coffset POSITION

Returns the compressed offset (most significant bits) component of BGZF virtual offset POSITION.

Package

sam

Source

bgzf.lisp (file)

Function: bgzf-compression INSTANCE
Function: (setf bgzf-compression) VALUE INSTANCE
Package

sam

Source

bgzf.lisp (file)

Function: bgzf-empty-p BGZF

Returns T if all decompressed bytes have been read from the current decompressed BGZ block.

Package

sam

Source

bgzf.lisp (file)

Function: bgzf-eof INSTANCE
Function: (setf bgzf-eof) VALUE INSTANCE
Package

sam

Source

bgzf.lisp (file)

Function: bgzf-flush BGZF &key COMPRESS APPEND-EOF MTIME
Package

sam

Source

bgzf-writer.lisp (file)

Function: bgzf-load-seek INSTANCE
Function: (setf bgzf-load-seek) VALUE INSTANCE
Package

sam

Source

bgzf.lisp (file)

Function: bgzf-loaded-p INSTANCE
Function: (setf bgzf-loaded-p) VALUE INSTANCE
Package

sam

Source

bgzf.lisp (file)

Function: bgzf-offset INSTANCE
Function: (setf bgzf-offset) VALUE INSTANCE
Package

sam

Source

bgzf.lisp (file)

Function: bgzf-p OBJECT
Package

sam

Source

bgzf.lisp (file)

Function: bgzf-pathname INSTANCE
Function: (setf bgzf-pathname) VALUE INSTANCE
Package

sam

Source

bgzf.lisp (file)

Function: bgzf-pointer INSTANCE
Function: (setf bgzf-pointer) VALUE INSTANCE
Package

sam

Source

bgzf.lisp (file)

Function: bgzf-position INSTANCE
Function: (setf bgzf-position) VALUE INSTANCE
Package

sam

Source

bgzf.lisp (file)

Function: bgzf-stream INSTANCE
Function: (setf bgzf-stream) VALUE INSTANCE
Package

sam

Source

bgzf.lisp (file)

Function: bgzf-uoffset POSITION

Returns the uncompressed (least significant bits) component of BGZF virtual offset POSITION.

Package

sam

Source

bgzf.lisp (file)

Function: bgzf-util-buffer INSTANCE
Function: (setf bgzf-util-buffer) VALUE INSTANCE
Package

sam

Source

bgzf.lisp (file)

Function: bin-p OBJECT
Package

sam

Source

bam-index.lisp (file)

Function: block-sizes FILESPEC N
Package

sam

Source

bam-reader.lisp (file)

Function: buffer-empty-p STREAM
Package

sam

Source

bgzip-stream.lisp (file)

Function: chunk-p OBJECT
Package

sam

Source

bam-index.lisp (file)

Function: copy-alignment INSTANCE
Package

sam

Source

bam.lisp (file)

Function: copy-bam-index INSTANCE
Package

sam

Source

bam-index.lisp (file)

Function: copy-bgz-member INSTANCE
Package

sam

Source

bgzf.lisp (file)

Function: copy-bgzf INSTANCE
Package

sam

Source

bgzf.lisp (file)

Function: copy-bin INSTANCE
Package

sam

Source

bam-index.lisp (file)

Function: copy-chunk INSTANCE
Package

sam

Source

bam-index.lisp (file)

Function: copy-ref-index INSTANCE
Package

sam

Source

bam-index.lisp (file)

Function: copy-region INSTANCE
Package

sam

Source

bam-index.lisp (file)

Function: copy-samtools-bam-index INSTANCE
Package

sam

Source

bam-index.lisp (file)

Function: copy-samtools-ref-index INSTANCE
Package

sam

Source

bam-index.lisp (file)

Function: decode-cigar ALN INDEX NUM-BYTES

Returns an alist of CIGAR operations from NUM-BYTES bytes within ALN, starting at INDEX. The decoding of the = and X operations is not documented in the spec.

Package

sam

Source

bam.lisp (file)

Function: decode-quality-string ALN INDEX NUM-BYTES

Returns a string containing the alignment query sequence of length NUM-BYTES. The sequence must be present in ALN at INDEX. The SAM spec states that quality data are optional, with absence indicated by 0xff. If the first byte of quality data is 0xff, NIL is returned.

Package

sam

Source

bam.lisp (file)

Function: decode-read-name ALN INDEX NUM-BYTES

Returns a string containing the template/read name of length NUM-BYTES, encoded at byte INDEX in ALN.

Package

sam

Source

bam.lisp (file)

Function: decode-seq-string ALN INDEX NUM-BYTES

Returns a string containing the alignment query sequence of length NUM-BYTES. The sequence must be present in ALN at INDEX.

Package

sam

Source

bam.lisp (file)

Function: decode-tag-values ALN INDEX

Returns a list of auxilliary data from ALN at INDEX. The BAM two-letter data keys are transformed to Lisp keywords.

Package

sam

Source

bam.lisp (file)

Function: default-orphanizer-test ()

Returns a new orphanizer test that causes alternate last fragments to be omitted.

Package

sam

Source

bam-utilities.lisp (file)

Function: default-qual-string LENGTH
Package

sam

Source

bam-utilities.lisp (file)

Function: default-seq-string LENGTH
Package

sam

Source

bam-utilities.lisp (file)

Function: deflate-bgz-member BGZ &key COMPRESSION MTIME BACKOFF
Package

sam

Source

bgzf.lisp (file)

Function: encode-char-tag VALUE ALN INDEX

Returns ALN having encoded character VALUE into it, starting at INDEX.

Package

sam

Source

bam.lisp (file)

Function: encode-cigar CIGAR ALN INDEX

Returns ALN having encoded alist CIGAR into it, starting at INDEX.

Package

sam

Source

bam.lisp (file)

Function: encode-float-tag VALUE ALN INDEX

Returns ALN having encoded float VALUE into it, starting at INDEX.

Package

sam

Source

bam.lisp (file)

Function: encode-hex-tag VALUE ALN INDEX

Returns ALN having encoded hex string VALUE into it, starting at INDEX.

Package

sam

Source

bam.lisp (file)

Function: encode-int-tag VALUE ALN INDEX

Returns ALN having encoded integer VALUE into it, starting at INDEX. BAM format is permitted to use more compact integer storage where possible.

Package

sam

Source

bam.lisp (file)

Function: encode-phred-quality Q

Returns the character encoding Phred quality Q.

Package

sam

Source

bam-utilities.lisp (file)

Function: encode-quality-string STR ALN INDEX

Returns ALN having encoded quality string STR into it, starting at INDEX.

Package

sam

Source

bam.lisp (file)

Function: encode-read-name READ-NAME ALN INDEX

Returns ALN having encoded READ-NAME into it, starting at INDEX.

Package

sam

Source

bam.lisp (file)

Function: encode-seq-string STR ALN INDEX

Returns ALN having encoded STR into it, starting at INDEX.

Package

sam

Source

bam.lisp (file)

Function: encode-string-tag VALUE ALN INDEX

Returns ALN having encoded string VALUE into it, starting at INDEX.

Package

sam

Source

bam.lisp (file)

Function: encode-unknown-quality N ALN INDEX

Returns ALN having encoded N unknown qualities into it, starting at INDEX.

Package

sam

Source

bam.lisp (file)

Function: ensure-order HEADER DOMAIN

Returns a copy of HEADER that is guaranteed to contain a sort tag for DOMAIN, which must be one of :sort or :group .

Package

sam

Source

sam.lisp (file)

Function: ensure-sam-version HEADER &optional VERSION

Returns a copy of HEADER that is guaranteed to contain a version tag.

Package

sam

Source

sam.lisp (file)

Function: ensure-unique-tag-values HEADER RECORD-TYPE TAG

Returns HEADER if all records of RECORD-TYPE have unique TAG values, with respect to each other, or raises a {define-condition malformed-field-error} .

Package

sam

Source

sam.lisp (file)

Function: ensure-valid-flag FLAG &optional ALN
Package

sam

Source

bam.lisp (file)

Function: ensure-valid-read-name STR
Package

sam

Source

bam.lisp (file)

Function: ensure-valid-reference-name STR

Returns STR if it is a valid reference sequence name, or raises a {define-condition malformed-field-error} if not.

Package

sam

Source

bam.lisp (file)

Function: ensure-valid-region REGION

Returns REGION if it is a valid region designator, or raises an {define-condition invalid-argument-error} .

A region designator may be any of the following:

- A list of a string and two integers, being a reference name, start position and end position, respectively.

- A list of three integers, being a reference identifier, start position and end position, respectively.

- A region struct.

The start position must be less than, or equal to the end position.

Package

sam

Source

bam-reader.lisp (file)

Function: fill-buffer STREAM
Package

sam

Source

bgzip-stream.lisp (file)

Function: find-duplicate-header-tags RECORD

Returns a list of duplicate SAM header tags found in RECORD. Each list element contains the tag, followed by a list of the conflicting values.

Package

sam

Source

sam.lisp (file)

Function: find-duplicate-records HEADER HEADER-TYPE

Returns a list of any duplicate records of HEADER-TYPE in HEADER.

Package

sam

Source

sam.lisp (file)

Function: find-interval REF-INDEX START
Package

sam

Source

bam-index.lisp (file)

Function: flag-symbol FLAG

Returns a 3 character string symbolising the read pairing denoted by FLAG. The left character indicates the query strand, the middle the alignment pairing and the right the mate strand.

Query mapped forward >
Query mapped reverse <
Query unmapped .

Not paired .
Mapped proper pair =
Mapped pair -
Singleton ~

Mate mapped forward >
Mate mapped reverse <
Mate unmapped .

Package

sam

Source

bam.lisp (file)

Function: flag-validation-error FLAG MESSAGE &optional ALN

Raised a {define-condition malformed-field-error} for alignment FLAG in ALN, with MESSAGE.

Package

sam

Source

bam.lisp (file)

Function: group-by-tag RECORDS HEADER-TAG

Returns a hash-table of header-records taken from list RECORDS. The hash-table keys are HEADER-TAG values taken from the records and the hash-table values are lists of header-records that share that HEADER-TAG value.

Package

sam

Source

sam.lisp (file)

Function: header-record RECORD-TYPE &rest ARGS

Returns a new header record of HEADER-TYPE. ARGS are tag values in the same order as the tag returned by {defun valid-header-tags} , which is the same order as they are presented in the SAM spec.

Package

sam

Source

sam.lisp (file)

Function: inflate-bgz-member BGZ
Package

sam

Source

bgzf.lisp (file)

Function: make-alignment ALN

Returns a new ALIGNMENT structure given BAM record ALN.

Package

sam

Source

bam.lisp (file)

Function: make-aln READ-NAME SEQ-STR QUAL-STR FLAG REF-ID MATE-REF-ID POS MATE-POS CIGAR REF-LEN MAP-QUAL INSERT-LENGTH BIN RECORD
Package

sam

Source

bam.lisp (file)

Function: make-bam-chunks INDEX REGION

Returns a list of read chunks from INDEX covering REGION, sorted by increasing chunk start.

Package

sam

Source

bam-index.lisp (file)

Function: make-bam-full-scan-input BAM

Returns a generator function that returns BAM alignment records for BAM stream BAM by scanning the entire stream. This to be used in cases where a full scan is necessary, or as a fallback when neither index, nor regions are available. The standard generator interface functions NEXT and HAS-MORE-P may be used in operations on the returned generator.

Package

sam

Source

bam-reader.lisp (file)

Function: make-bam-index &key (REFS REFS)
Package

sam

Source

bam-index.lisp (file)

Function: make-bam-index-input BAM INDEX REGIONS

Returns a generator function that returns BAM alignment records for BAM stream BAM by scanning for alignments in the list of REGIONS. Note that REGIONS are zero-based, closed base coordinates. The standard generator interface functions NEXT and HAS-MORE-P may be used in operations on the returned generator.

Package

sam

Source

bam-reader.lisp (file)

Function: make-bam-scan-input BAM REGIONS

Returns a generator function that returns BAM alignment records for BAM stream BAM by scanning for alignments in the list of REGIONS. Note that REGIONS use zero-based, closed base coordinates. This to be used in cases where a full scan is necessary, or as a fallback when an index is not available. The standard generator interface functions NEXT and HAS-MORE-P may be used in operations on the returned generator.

Package

sam

Source

bam-reader.lisp (file)

Function: make-bgz-member &key (ID1 ID1) (ID2 ID2) (CM CM) (FLG FLG) (MTIME MTIME) (XFL XFL) (OS OS) (XLEN XLEN) (ISIZE ISIZE) (CRC32 CRC32) (CDATA CDATA) (CEND CEND) (SF1 SF1) (SF2 SF2) (SLEN SLEN) (BSIZE BSIZE) (UDATA UDATA)
Package

sam

Source

bgzf.lisp (file)

Function: make-bgzf &key (PATHNAME PATHNAME) (STREAM STREAM) (COMPRESSION COMPRESSION) (BUFFER BUFFER) (POSITION POSITION) (OFFSET OFFSET) (POINTER POINTER) (UTIL-BUFFER UTIL-BUFFER) (LOADED-P LOADED-P) (LOAD-SEEK LOAD-SEEK) (EOF EOF)
Package

sam

Source

bgzf.lisp (file)

Function: make-bin &key (NUM NUM) (CHUNKS CHUNKS)
Package

sam

Source

bam-index.lisp (file)

Function: make-chunk &key (START START) (END END)
Package

sam

Source

bam-index.lisp (file)

Function: make-header-string ALIST

Returns a new SAM header string representing the header data in ALIST.

Package

sam

Source

sam-writer.lisp (file)

Function: make-ref-index &key (ID ID) (BINS BINS) (INTERVALS INTERVALS)
Package

sam

Source

bam-index.lisp (file)

Function: make-region &key REF START END
Package

sam

Source

bam-index.lisp (file)

Function: make-region< REF-META

Returns a new comparator function which sorts regions according to the BAM reference metadata REF-META. Ranges are sorted first by the reference order in the BAM file, then by region start and finally by region end. Regions are sorted before they are normalised.

Package

sam

Source

bam-reader.lisp (file)

Function: make-samtools-bam-index &key (REFS REFS) (UNASSIGNED UNASSIGNED)
Package

sam

Source

bam-index.lisp (file)

Function: make-samtools-ref-index &key (ID ID) (BINS BINS) (INTERVALS INTERVALS) (START START) (END END) (MAPPED MAPPED) (UNMAPPED UNMAPPED)
Package

sam

Source

bam-index.lisp (file)

Function: mandatory-header-tags HEADER-TYPE

Returns a list of the mandatory tags for SAM header
HEADER-TYPE. Both HEADER-TYPE. and the returned tags are represented as symbols.

Package

sam

Source

sam.lisp (file)

Function: max-bin-num REF-LENGTH
Package

sam

Source

bam-index.lisp (file)

Function: merge-chunks CHUNKS

Returns a new list of BAM index chunks created by merging members of list CHUNKS that are {defun adjacentp} .

Package

sam

Source

bam-index.lisp (file)

Function: next-forward-p FLAG

Returns T if FLAG indicates that the read’s mate was mapped to the forward, or NIL if it was mapped to the reverse strand.

Package

sam

Source

bam.lisp (file)

Function: next-mapped-p FLAG

Returns T if FLAG indicates that the read’s mate was mapped to a reference, or NIL otherwise.

Package

sam

Source

bam.lisp (file)

Function: normalise-regions REGIONS REF-META

Returns a list of REGIONS, normalised according to the BAM reference metadata REF-META. Reference names in REGIONS are converted to their corresponding reference ID and REGIONS are sorted first by the reference order in the BAM file, then by region start and finally by region end. Overlapping REGIONS are merged.

Package

sam

Source

bam-reader.lisp (file)

Function: parse-digits BYTES START END
Package

sam

Source

external-bam-sort.lisp (file)

Function: parse-hd-tag STR
Package

sam

Source

sam.lisp (file)

Function: parse-pg-tag STR
Package

sam

Source

sam.lisp (file)

Function: parse-rg-tag STR
Package

sam

Source

sam.lisp (file)

Function: parse-sq-tag STR
Package

sam

Source

sam.lisp (file)

Function: partition-by-type HEADERS

Collects all the header-records in HEADERS by header-type, sorts them and returns 4 values that are lists of the collected :hd , :sq , :rg and :pg header-records, respectively. Does not modify HEADERS.

Package

sam

Source

sam.lisp (file)

Function: partition-regions REGIONS

Partitions a list of normalised REGIONS into lists, each pertaining to a specific reference sequence. The overall order of the REGIONS is maintained.

Package

sam

Source

bam-reader.lisp (file)

Function: print-aln ALN STREAM
Package

sam

Source

bam.lisp (file)

Function: print-bin BIN STREAM

Prints a string representation of BIN to STREAM.

Package

sam

Source

bam-index.lisp (file)

Function: print-chunk CHUNK STREAM

Prints a string representation of CHUNK to STREAM.

Package

sam

Source

bam-index.lisp (file)

Function: print-ref-index REF-INDEX STREAM

Prints a string representation of REF-INDEX to STREAM.

Package

sam

Source

bam-index.lisp (file)

Function: print-region REGION STREAM

Prints a string representation of RANGE to STREAM.

Package

sam

Source

bam-index.lisp (file)

Function: print-samtools-ref-index REF-INDEX STREAM

Prints a string representation of REF-INDEX to STREAM.

Package

sam

Source

bam-index.lisp (file)

Function: read-bgz-member STREAM BUFFER

Reads one BGZ member from STREAM, using BUFFER to hold integers as they are read.

Arguments:

- stream (octet input-stream): An open stream.
- buffer (simple-octet-vector): A re-usable read buffer which must be able to contain at least 4 bytes.

Returns:

- A BGZ structure, or NIL.

Package

sam

Source

bgzf-reader.lisp (file)

Function: read-bin STREAM

Reads an index bin from STREAM.

Package

sam

Source

bam-index-reader.lisp (file)

Function: read-binning-index NUM-BINS STREAM

Reads NUM-BINS bins from STREAM, returning a vector of bins, sorted by increasing bin number.

Package

sam

Source

bam-index-reader.lisp (file)

Function: read-bytes BGZF N &key BUFFER
Package

sam

Source

bgzf-reader.lisp (file)

Function: read-index-magic STREAM

Reads the BAI magic number from STREAM and returns T if it is valid or raises a {define-condition malformed-file-error} if not.

Package

sam

Source

bam-index-reader.lisp (file)

Function: read-linear-index NUM-INTERVALS STREAM

Reads NUM-INTERVALS linear bin intervals from STREAM, returning them in a vector. Identical intervals are run-length compressed.

Package

sam

Source

bam-index-reader.lisp (file)

Function: read-ref-index REFERENCE-ID STREAM

Reads an index for a single reference sequence from STREAM.

Package

sam

Source

bam-index-reader.lisp (file)

Function: read-string BGZF N &key NULL-TERMINATED

Reads N characters from handle BGZF and returns them as a Lisp string. The NULL-TERMINATED keyword is used to indicate whether the C string is null-terminated so that the terminator may be consumed.

Package

sam

Source

bgzf-reader.lisp (file)

Function: ref-index-id INSTANCE
Package

sam

Source

bam-index.lisp (file)

Function: ref-index-p OBJECT
Package

sam

Source

bam-index.lisp (file)

Function: region REF START END
Package

sam

Source

bam-index.lisp (file)

Function: region-end INSTANCE
Function: (setf region-end) VALUE INSTANCE
Package

sam

Source

bam-index.lisp (file)

Function: region-p OBJECT
Package

sam

Source

bam-index.lisp (file)

Function: region-ref INSTANCE
Function: (setf region-ref) VALUE INSTANCE
Package

sam

Source

bam-index.lisp (file)

Function: region-start INSTANCE
Function: (setf region-start) VALUE INSTANCE
Package

sam

Source

bam-index.lisp (file)

Function: region-to-bin START END

Returns a bin number given a 0-based range.

Package

sam

Source

bam-index.lisp (file)

Function: region-to-bins START END

Returns a bit vector with the bits for relevant bins set, given a 0-based range. Each bin may span 2^29, 2^26, 2^23, 2^20, 2^17 or 2^14 bp. Bin 0 spans a 512 Mbp region, bins 1-8 span 64 Mbp, 9-72 8 Mbp, 73-584 1 Mbp, 585-4680 128 Kbp and bins 4681-37449 span 16 Kbp regions.

Package

sam

Source

bam-index.lisp (file)

Function: region-to-interval COORD

Given a coordinate COORD, returns the array index of its interval in the BAM linear index.

Package

sam

Source

bam-index.lisp (file)

Function: run-length-encode INTERVALS

Returns a run-length encoded list representing INTERVALS, a BGZF linear index. Each element of the list has a car of the run-length and a cdr of the BGZF file position. Used in printing text representations of the index.

Package

sam

Source

bam-index.lisp (file)

Function: samtools-bam-index-p OBJECT
Package

sam

Source

bam-index.lisp (file)

Function: samtools-bam-index-refs INSTANCE
Function: (setf samtools-bam-index-refs) VALUE INSTANCE
Package

sam

Source

bam-index.lisp (file)

Function: samtools-bam-index-unassigned INSTANCE
Function: (setf samtools-bam-index-unassigned) VALUE INSTANCE
Package

sam

Source

bam-index.lisp (file)

Function: samtools-ref-index-bins INSTANCE
Function: (setf samtools-ref-index-bins) VALUE INSTANCE
Package

sam

Source

bam-index.lisp (file)

Function: samtools-ref-index-end INSTANCE
Function: (setf samtools-ref-index-end) VALUE INSTANCE
Package

sam

Source

bam-index.lisp (file)

Function: samtools-ref-index-id INSTANCE
Package

sam

Source

bam-index.lisp (file)

Function: samtools-ref-index-intervals INSTANCE
Function: (setf samtools-ref-index-intervals) VALUE INSTANCE
Package

sam

Source

bam-index.lisp (file)

Function: samtools-ref-index-mapped INSTANCE
Function: (setf samtools-ref-index-mapped) VALUE INSTANCE
Package

sam

Source

bam-index.lisp (file)

Function: samtools-ref-index-p OBJECT
Package

sam

Source

bam-index.lisp (file)

Function: samtools-ref-index-start INSTANCE
Function: (setf samtools-ref-index-start) VALUE INSTANCE
Package

sam

Source

bam-index.lisp (file)

Function: samtools-ref-index-unmapped INSTANCE
Function: (setf samtools-ref-index-unmapped) VALUE INSTANCE
Package

sam

Source

bam-index.lisp (file)

Function: simplify-records RECORDS HEADER-TAG

Returns a simplified list of header-records copied from
RECORDS. The RECORDS must all be of the same type. The simplifications are: removal of perfect duplicates, grouping of header-records by HEADER-TAG value and subsequent merging of header-records that share that HEADER-TAG value. RECORDS may be an empty list.

Package

sam

Source

sam.lisp (file)

Function: sort-bam-alignments BGZF-IN BGZF-OUT PREDICATE &key KEY BUFFER-SIZE

Sorts alignments from block gzip input stream BGZF-IN and writes them to block gzip output stream BGZF-OUT, sorted by PREDICATE. A function KEY may be supplied to transform alignments into arguments for PREDICATE. The BUFFER-SIZE argument declares the maximum number of alignments that will be sorted in memory at any time, defaulting to 1000000.

Package

sam

Source

external-bam-sort.lisp (file)

Function: stream-view-sam BAM &optional STREAM

Writes the binary BAM records from BGZF stream BAM to STREAM, in SAM text format.

Package

sam

Source

cl-sam.lisp (file)

Function: update-pg-records CURRENT-RECORDS NEW-RECORD

Returns a copy of CURRENT-RECORDS with NEW-RECORD added.

Package

sam

Source

sam.lisp (file)

Function: user-header-tag-p TAG

Returns T if TAG is a SAM 1.4 user-defined header tag. User-defined tags are recognised by containing lower case letters.

Package

sam

Source

sam.lisp (file)

Function: valid-header-tags HEADER-TYPE

Returns a list of the valid tags for SAM header HEADER-TYPE. Both HEADER-TYPE and the returned tags are represented as symbols.

Package

sam

Source

sam.lisp (file)

Function: valid-read-name-p STR

Returns T if STR is a valid read name matching the regex [!-?A-~]1,255 , or NIL otherwise. The length limit is implicit in the BAM format, there being 8 bits to store the read name length. This function is not used as it is not clear that this check is accepted by other implementations.

Package

sam

Source

bam.lisp (file)

Function: voffset-merge-p VOFFSET1 VOFFSET2

Returns T if BGZF virtual offsets are close enough to save disk seeks. Continuing to read from the current position may be faster than seeking forward a short distance.

Package

sam

Source

bam-index.lisp (file)

Function: write-bgz-member BGZ STREAM BUFFER

Writes one BGZ member to STREAM.

Arguments:

- bgz (bgz member): A bgz member to write.
- stream (octet output-stream): An open stream.
- buffer (simple-octet-vector): A re-usable read buffer which must be able to contain at least 4 bytes.

Returns:

- The number of bytes written.

Package

sam

Source

bgzf-writer.lisp (file)

Function: write-bin BIN STREAM
Package

sam

Source

bam-index-writer.lisp (file)

Function: write-binning-index BINS STREAM
Package

sam

Source

bam-index-writer.lisp (file)

Function: write-bytes BGZF BYTES N &key COMPRESS MTIME

Write N elements from vector BYTES to stream BGZF.

Key:

- compress (boolean): If T, compress at current BGZF compression level when the current block becomes full. Defaults to T.
- mtime (uint32): The zlib mtime. Defaults to 0.

Returns:

- The number of bytes written.

Package

sam

Source

bgzf-writer.lisp (file)

Function: write-chunked-bytes BGZF BYTES N &key COMPRESS MTIME
Package

sam

Source

bgzf-writer.lisp (file)

Function: write-cigar ALIGNMENT-RECORD INDEX NUM-BYTES &optional STREAM

Writes the CIGAR string of ALIGNMENT-RECORD at INDEX as NUM-BYTES bytes, to STREAM.

Package

sam

Source

sam-writer.lisp (file)

Function: write-index-magic STREAM
Package

sam

Source

bam-index-writer.lisp (file)

Function: write-linear-index INTERVALS STREAM
Package

sam

Source

bam-index-writer.lisp (file)

Function: write-quality-string ALIGNMENT-RECORD INDEX NUM-BYTES &optional STREAM

Writes the quality string of ALIGNMENT-RECORD at INDEX as NUM-BYTES, to STREAM.

Package

sam

Source

sam-writer.lisp (file)

Function: write-seq-string ALIGNMENT-RECORD INDEX NUM-BYTES &optional STREAM

Writes the sequence string of ALIGNMENT-RECORD at INDEX as NUM-BYTES bytes, to STREAM.

Package

sam

Source

sam-writer.lisp (file)

Function: write-tag-values ALIGNMENT-RECORD INDEX &optional STREAM

Writes the auxilliary data of ALIGNMENT-RECORD at INDEX to STREAM.

Package

sam

Source

sam-writer.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.5 Generic functions

Generic Function: bgzf-of CONDITION
Package

sam

Methods
Method: bgzf-of (CONDITION bgzf-io-error)
Source

conditions.lisp (file)

Generic Function: buffer-of OBJECT
Package

sam

Methods
Method: buffer-of (BAM-MERGE-STREAM bam-merge-stream)

automatically generated reader method

Source

external-bam-sort.lisp (file)

Generic Function: encode-alignment-tag VALUE TAG VECTOR INDEX

Performs binary encoding of VALUE into VECTOR under TAG at INDEX, returning VECTOR.

Package

sam

Source

bam.lisp (file)

Methods
Method: encode-alignment-tag VALUE (TAG (eql xt)) ALN INDEX
Method: encode-alignment-tag VALUE (TAG (eql xs)) ALN INDEX
Method: encode-alignment-tag VALUE (TAG (eql xo)) ALN INDEX
Method: encode-alignment-tag VALUE (TAG (eql xn)) ALN INDEX
Method: encode-alignment-tag VALUE (TAG (eql xm)) ALN INDEX
Method: encode-alignment-tag VALUE (TAG (eql xg)) ALN INDEX
Method: encode-alignment-tag VALUE (TAG (eql xf)) ALN INDEX
Method: encode-alignment-tag VALUE (TAG (eql xe)) ALN INDEX
Method: encode-alignment-tag VALUE (TAG (eql xc)) ALN INDEX
Method: encode-alignment-tag VALUE (TAG (eql xa)) ALN INDEX
Method: encode-alignment-tag VALUE (TAG (eql x1)) ALN INDEX
Method: encode-alignment-tag VALUE (TAG (eql x0)) ALN INDEX
Method: encode-alignment-tag VALUE (TAG (eql zf)) ALN INDEX
Method: encode-alignment-tag VALUE (TAG (eql za)) ALN INDEX
Method: encode-alignment-tag VALUE (TAG (eql uq)) ALN INDEX
Method: encode-alignment-tag VALUE (TAG (eql u2)) ALN INDEX
Method: encode-alignment-tag VALUE (TAG (eql tc)) ALN INDEX
Method: encode-alignment-tag VALUE (TAG (eql sq)) ALN INDEX
Method: encode-alignment-tag VALUE (TAG (eql sm)) ALN INDEX
Method: encode-alignment-tag VALUE (TAG (eql s2)) ALN INDEX
Method: encode-alignment-tag VALUE (TAG (eql sa)) ALN INDEX
Method: encode-alignment-tag VALUE (TAG (eql rt)) ALN INDEX
Method: encode-alignment-tag VALUE (TAG (eql rg)) ALN INDEX
Method: encode-alignment-tag VALUE (TAG (eql r2)) ALN INDEX
Method: encode-alignment-tag VALUE (TAG (eql qt)) ALN INDEX
Method: encode-alignment-tag VALUE (TAG (eql q2)) ALN INDEX
Method: encode-alignment-tag VALUE (TAG (eql pu)) ALN INDEX
Method: encode-alignment-tag VALUE (TAG (eql pt)) ALN INDEX
Method: encode-alignment-tag VALUE (TAG (eql pq)) ALN INDEX
Method: encode-alignment-tag VALUE (TAG (eql pg)) ALN INDEX
Method: encode-alignment-tag VALUE (TAG (eql oq)) ALN INDEX
Method: encode-alignment-tag VALUE (TAG (eql op)) ALN INDEX
Method: encode-alignment-tag VALUE (TAG (eql oc)) ALN INDEX
Method: encode-alignment-tag VALUE (TAG (eql nm)) ALN INDEX
Method: encode-alignment-tag VALUE (TAG (eql nh)) ALN INDEX
Method: encode-alignment-tag VALUE (TAG (eql mq)) ALN INDEX
Method: encode-alignment-tag VALUE (TAG (eql mf)) ALN INDEX
Method: encode-alignment-tag VALUE (TAG (eql md)) ALN INDEX
Method: encode-alignment-tag VALUE (TAG (eql ih)) ALN INDEX
Method: encode-alignment-tag VALUE (TAG (eql hi)) ALN INDEX
Method: encode-alignment-tag VALUE (TAG (eql h2)) ALN INDEX
Method: encode-alignment-tag VALUE (TAG (eql h1)) ALN INDEX
Method: encode-alignment-tag VALUE (TAG (eql h0)) ALN INDEX
Method: encode-alignment-tag VALUE (TAG (eql lb)) ALN INDEX
Method: encode-alignment-tag VALUE (TAG (eql gq)) ALN INDEX
Method: encode-alignment-tag VALUE (TAG (eql gs)) ALN INDEX
Method: encode-alignment-tag VALUE (TAG (eql gc)) ALN INDEX
Method: encode-alignment-tag VALUE (TAG (eql fz)) ALN INDEX
Method: encode-alignment-tag VALUE (TAG (eql fs)) ALN INDEX
Method: encode-alignment-tag VALUE (TAG (eql fi)) ALN INDEX
Method: encode-alignment-tag VALUE (TAG (eql e2)) ALN INDEX
Method: encode-alignment-tag VALUE (TAG (eql ct)) ALN INDEX
Method: encode-alignment-tag VALUE (TAG (eql cs)) ALN INDEX
Method: encode-alignment-tag VALUE (TAG (eql cq)) ALN INDEX
Method: encode-alignment-tag VALUE (TAG (eql cp)) ALN INDEX
Method: encode-alignment-tag VALUE (TAG (eql co)) ALN INDEX
Method: encode-alignment-tag VALUE (TAG (eql cm)) ALN INDEX
Method: encode-alignment-tag VALUE (TAG (eql cc)) ALN INDEX
Method: encode-alignment-tag VALUE (TAG (eql bq)) ALN INDEX
Method: encode-alignment-tag VALUE (TAG (eql bc)) ALN INDEX
Method: encode-alignment-tag VALUE (TAG (eql as)) ALN INDEX
Method: encode-alignment-tag VALUE (TAG (eql am)) ALN INDEX
Method: encode-alignment-tag VALUE TAG VECTOR INDEX
Generic Function: errno-of CONDITION
Package

sam

Methods
Method: errno-of (CONDITION bgzf-io-error)
Source

conditions.lisp (file)

Generic Function: position-of CONDITION
Package

sam

Methods
Method: position-of (CONDITION bam-sort-error)
Source

conditions.lisp (file)

Generic Function: prev-position-of CONDITION
Package

sam

Methods
Method: prev-position-of (CONDITION bam-sort-error)
Source

conditions.lisp (file)

Generic Function: prev-reference-of CONDITION
Package

sam

Methods
Method: prev-reference-of (CONDITION bam-sort-error)
Source

conditions.lisp (file)

Generic Function: reference-of CONDITION
Package

sam

Methods
Method: reference-of (CONDITION bam-sort-error)
Source

conditions.lisp (file)

Generic Function: write-ref-index REF-INDEX STREAM
Package

sam

Source

bam-index-writer.lisp (file)

Methods
Method: write-ref-index (REF-INDEX ref-index) STREAM
Method: write-ref-index (REF-INDEX samtools-ref-index) STREAM

Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.6 Structures

Structure: alignment ()
Package

sam

Source

bam.lisp (file)

Direct superclasses

structure-object (structure)

Direct methods

print-object (method)

Direct slots
Slot: bin
Type

uk.co.deoxybyte-utilities:uint16

Initform

0

Readers

aln-bin (function)

Writers

(setf aln-bin) (function)

Slot: flag
Type

uk.co.deoxybyte-utilities:uint16

Initform

0

Readers

aln-flag (function)

Writers

(setf aln-flag) (function)

Slot: pos
Type

uk.co.deoxybyte-utilities:int32

Initform

sam::+unknown-position+

Readers

aln-pos (function)

Writers

(setf aln-pos) (function)

Slot: mate-pos
Type

uk.co.deoxybyte-utilities:int32

Initform

sam::+unknown-position+

Readers

aln-mate-pos (function)

Writers

(setf aln-mate-pos) (function)

Slot: ref-id
Type

uk.co.deoxybyte-utilities:int32

Initform

sam::+unknown-reference+

Readers

aln-ref-id (function)

Writers

(setf aln-ref-id) (function)

Slot: mate-ref-id
Type

uk.co.deoxybyte-utilities:int32

Initform

sam::+unknown-reference+

Readers

aln-mate-ref-id (function)

Writers

(setf aln-mate-ref-id) (function)

Slot: ref-len
Type

fixnum

Initform

0

Readers

aln-ref-len (function)

Writers

(setf aln-ref-len) (function)

Slot: map-qual
Type

uk.co.deoxybyte-utilities:uint8

Initform

0

Readers

aln-map-qual (function)

Writers

(setf aln-map-qual) (function)

Slot: insert-length
Type

uk.co.deoxybyte-utilities:int32

Initform

0

Readers

aln-insert-length (function)

Writers

(setf aln-insert-length) (function)

Slot: read-name
Type

simple-string

Initform

"*"

Readers

aln-read-name (function)

Writers

(setf aln-read-name) (function)

Slot: seq-str
Type

simple-string

Initform

"*"

Readers

aln-seq-str (function)

Writers

(setf aln-seq-str) (function)

Slot: qual-str
Type

simple-string

Initform

"*"

Readers

aln-qual-str (function)

Writers

(setf aln-qual-str) (function)

Slot: cigar
Type

list

Readers

aln-cigar (function)

Writers

(setf aln-cigar) (function)

Slot: record
Type

uk.co.deoxybyte-utilities:simple-octet-vector

Initform

(make-array 0 :element-type (quote uk.co.deoxybyte-utilities:octet))

Readers

aln-record (function)

Writers

(setf aln-record) (function)

Structure: bgz-member ()

A block-gzip data chunk; a gzip member with extensions, as defined
by RFC1952. The extensions are described in RFC1952 and the SAM format specification.

- sf1: RCF1952 first extra SubField.
- sf2: RCF1952 second extra SubField.
- slen: RFC1952 Subfield LENgth.
- bsize: SAM spec total Block (member) SIZE. The serialized value is (1- bsize). - udata: Uncompressed DATA.

Package

sam

Source

bgzf.lisp (file)

Direct superclasses

gz-member (structure)

Direct slots
Slot: sf1
Type

uk.co.deoxybyte-utilities:uint8

Initform

sam::+sf1+

Readers

bgz-member-sf1 (function)

Writers

(setf bgz-member-sf1) (function)

Slot: sf2
Type

uk.co.deoxybyte-utilities:uint8

Initform

sam::+sf2+

Readers

bgz-member-sf2 (function)

Writers

(setf bgz-member-sf2) (function)

Slot: slen
Type

uk.co.deoxybyte-utilities:uint16

Initform

sam::+slen+

Readers

bgz-member-slen (function)

Writers

(setf bgz-member-slen) (function)

Slot: bsize
Type

uk.co.deoxybyte-utilities:uint16

Initform

0

Readers

bgz-member-bsize (function)

Writers

(setf bgz-member-bsize) (function)

Slot: udata
Type

uk.co.deoxybyte-utilities:simple-octet-vector

Initform

(make-array 0 :element-type (quote uk.co.deoxybyte-utilities:octet))

Readers

bgz-member-udata (function)

Writers

(setf bgz-member-udata) (function)

Structure: region ()

A range of bases over a reference sequence. A region is expressed in zero-based, half-open, interbase coordinates.

Package

sam

Source

bam-index.lisp (file)

Direct superclasses

structure-object (structure)

Direct methods

print-object (method)

Direct slots
Slot: ref
Readers

region-ref (function)

Writers

(setf region-ref) (function)

Slot: start
Type

fixnum

Initform

0

Readers

region-start (function)

Writers

(setf region-start) (function)

Slot: end
Type

fixnum

Initform

0

Readers

region-end (function)

Writers

(setf region-end) (function)

Structure: samtools-bam-index ()

A samtools-specific index containing extra, undocumented data: - unassigned: number of unmapped reads not assigned to a reference

Package

sam

Source

bam-index.lisp (file)

Direct superclasses

bam-index (structure)

Direct methods

write-bam-index (method)

Direct slots
Slot: unassigned
Type

(unsigned-byte 64)

Initform

0

Readers

samtools-bam-index-unassigned (function)

Writers

(setf samtools-bam-index-unassigned) (function)

Structure: samtools-ref-index ()

A samtools-specific reference index containing extra, undocumented data:

- start: the start offset of the reference
- end: the end offset of the reference
- mapped: number of reads mapped to the reference
- unmapped: number of unmapped reads assigned to the reference by magic

Package

sam

Source

bam-index.lisp (file)

Direct superclasses

ref-index (structure)

Direct methods
Direct slots
Slot: start
Type

(unsigned-byte 64)

Initform

0

Readers

samtools-ref-index-start (function)

Writers

(setf samtools-ref-index-start) (function)

Slot: end
Type

(unsigned-byte 64)

Initform

0

Readers

samtools-ref-index-end (function)

Writers

(setf samtools-ref-index-end) (function)

Slot: mapped
Type

(unsigned-byte 64)

Initform

0

Readers

samtools-ref-index-mapped (function)

Writers

(setf samtools-ref-index-mapped) (function)

Slot: unmapped
Type

(unsigned-byte 64)

Initform

0

Readers

samtools-ref-index-unmapped (function)

Writers

(setf samtools-ref-index-unmapped) (function)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.7 Classes

Class: bam-merge-stream ()
Package

sam

Source

external-bam-sort.lisp (file)

Direct superclasses
  • wrapped-stream-mixin (class)
  • merge-stream (class)
Direct methods
  • stream-merge (method)
  • initialize-instance (method)
  • buffer-of (method)
Direct slots
Slot: buffer
Initform

(make-array 4 :element-type (quote uk.co.deoxybyte-utilities:octet) :initial-element 0)

Readers

buffer-of (generic function)

Class: bam-sort-input-stream ()
Package

sam

Source

external-bam-sort.lisp (file)

Direct superclasses
Direct methods
  • make-merge-stream (method)
  • stream-read-element (method)
Class: bam-sort-output-stream ()
Package

sam

Source

external-bam-sort.lisp (file)

Direct superclasses
Direct methods

stream-write-element (method)

Class: bgzf-handle-mixin ()
Package

sam

Source

bgzip-stream.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses
Direct slots
Slot: bgzf

The BGZF file handle.

Initargs

:bgzf


Previous: , Up: Internal definitions   [Contents][Index]

6.2.8 Types

Type: bgzip-buffer ()

Buffer type for {defclass bgzip-input-stream} internal buffer.

Package

sam

Source

bgzip-stream.lisp (file)

Type: bgzip-buffer-index ()

Index type for {defclass bgzf-input-stream} internal buffer.

Package

sam

Source

bgzip-stream.lisp (file)


Previous: , Up: Top   [Contents][Index]

Appendix A Indexes


Next: , Previous: , Up: Indexes   [Contents][Index]

A.1 Concepts

Jump to:   C   F   L   M  
Index Entry  Section

C
cl-sam.asd: The cl-sam․asd file
cl-sam/cl-sam: The cl-sam/cl-sam module
cl-sam/cl-sam/bam-index-reader.lisp: The cl-sam/cl-sam/bam-index-reader․lisp file
cl-sam/cl-sam/bam-index-writer.lisp: The cl-sam/cl-sam/bam-index-writer․lisp file
cl-sam/cl-sam/bam-index.lisp: The cl-sam/cl-sam/bam-index․lisp file
cl-sam/cl-sam/bam-indexer.lisp: The cl-sam/cl-sam/bam-indexer․lisp file
cl-sam/cl-sam/bam-reader.lisp: The cl-sam/cl-sam/bam-reader․lisp file
cl-sam/cl-sam/bam-utilities.lisp: The cl-sam/cl-sam/bam-utilities․lisp file
cl-sam/cl-sam/bam-writer.lisp: The cl-sam/cl-sam/bam-writer․lisp file
cl-sam/cl-sam/bam.lisp: The cl-sam/cl-sam/bam․lisp file
cl-sam/cl-sam/bgzf-reader.lisp: The cl-sam/cl-sam/bgzf-reader․lisp file
cl-sam/cl-sam/bgzf-writer.lisp: The cl-sam/cl-sam/bgzf-writer․lisp file
cl-sam/cl-sam/bgzf.lisp: The cl-sam/cl-sam/bgzf․lisp file
cl-sam/cl-sam/bgzip-stream.lisp: The cl-sam/cl-sam/bgzip-stream․lisp file
cl-sam/cl-sam/cl-sam.lisp: The cl-sam/cl-sam/cl-sam․lisp file
cl-sam/cl-sam/conditions.lisp: The cl-sam/cl-sam/conditions․lisp file
cl-sam/cl-sam/external-bam-sort.lisp: The cl-sam/cl-sam/external-bam-sort․lisp file
cl-sam/cl-sam/package.lisp: The cl-sam/cl-sam/package․lisp file
cl-sam/cl-sam/sam-writer.lisp: The cl-sam/cl-sam/sam-writer․lisp file
cl-sam/cl-sam/sam.lisp: The cl-sam/cl-sam/sam․lisp file

F
File, Lisp, cl-sam.asd: The cl-sam․asd file
File, Lisp, cl-sam/cl-sam/bam-index-reader.lisp: The cl-sam/cl-sam/bam-index-reader․lisp file
File, Lisp, cl-sam/cl-sam/bam-index-writer.lisp: The cl-sam/cl-sam/bam-index-writer․lisp file
File, Lisp, cl-sam/cl-sam/bam-index.lisp: The cl-sam/cl-sam/bam-index․lisp file
File, Lisp, cl-sam/cl-sam/bam-indexer.lisp: The cl-sam/cl-sam/bam-indexer․lisp file
File, Lisp, cl-sam/cl-sam/bam-reader.lisp: The cl-sam/cl-sam/bam-reader․lisp file
File, Lisp, cl-sam/cl-sam/bam-utilities.lisp: The cl-sam/cl-sam/bam-utilities․lisp file
File, Lisp, cl-sam/cl-sam/bam-writer.lisp: The cl-sam/cl-sam/bam-writer․lisp file
File, Lisp, cl-sam/cl-sam/bam.lisp: The cl-sam/cl-sam/bam․lisp file
File, Lisp, cl-sam/cl-sam/bgzf-reader.lisp: The cl-sam/cl-sam/bgzf-reader․lisp file
File, Lisp, cl-sam/cl-sam/bgzf-writer.lisp: The cl-sam/cl-sam/bgzf-writer․lisp file
File, Lisp, cl-sam/cl-sam/bgzf.lisp: The cl-sam/cl-sam/bgzf․lisp file
File, Lisp, cl-sam/cl-sam/bgzip-stream.lisp: The cl-sam/cl-sam/bgzip-stream․lisp file
File, Lisp, cl-sam/cl-sam/cl-sam.lisp: The cl-sam/cl-sam/cl-sam․lisp file
File, Lisp, cl-sam/cl-sam/conditions.lisp: The cl-sam/cl-sam/conditions․lisp file
File, Lisp, cl-sam/cl-sam/external-bam-sort.lisp: The cl-sam/cl-sam/external-bam-sort․lisp file
File, Lisp, cl-sam/cl-sam/package.lisp: The cl-sam/cl-sam/package․lisp file
File, Lisp, cl-sam/cl-sam/sam-writer.lisp: The cl-sam/cl-sam/sam-writer․lisp file
File, Lisp, cl-sam/cl-sam/sam.lisp: The cl-sam/cl-sam/sam․lisp file

L
Lisp File, cl-sam.asd: The cl-sam․asd file
Lisp File, cl-sam/cl-sam/bam-index-reader.lisp: The cl-sam/cl-sam/bam-index-reader․lisp file
Lisp File, cl-sam/cl-sam/bam-index-writer.lisp: The cl-sam/cl-sam/bam-index-writer․lisp file
Lisp File, cl-sam/cl-sam/bam-index.lisp: The cl-sam/cl-sam/bam-index․lisp file
Lisp File, cl-sam/cl-sam/bam-indexer.lisp: The cl-sam/cl-sam/bam-indexer․lisp file
Lisp File, cl-sam/cl-sam/bam-reader.lisp: The cl-sam/cl-sam/bam-reader․lisp file
Lisp File, cl-sam/cl-sam/bam-utilities.lisp: The cl-sam/cl-sam/bam-utilities․lisp file
Lisp File, cl-sam/cl-sam/bam-writer.lisp: The cl-sam/cl-sam/bam-writer․lisp file
Lisp File, cl-sam/cl-sam/bam.lisp: The cl-sam/cl-sam/bam․lisp file
Lisp File, cl-sam/cl-sam/bgzf-reader.lisp: The cl-sam/cl-sam/bgzf-reader․lisp file
Lisp File, cl-sam/cl-sam/bgzf-writer.lisp: The cl-sam/cl-sam/bgzf-writer․lisp file
Lisp File, cl-sam/cl-sam/bgzf.lisp: The cl-sam/cl-sam/bgzf․lisp file
Lisp File, cl-sam/cl-sam/bgzip-stream.lisp: The cl-sam/cl-sam/bgzip-stream․lisp file
Lisp File, cl-sam/cl-sam/cl-sam.lisp: The cl-sam/cl-sam/cl-sam․lisp file
Lisp File, cl-sam/cl-sam/conditions.lisp: The cl-sam/cl-sam/conditions․lisp file
Lisp File, cl-sam/cl-sam/external-bam-sort.lisp: The cl-sam/cl-sam/external-bam-sort․lisp file
Lisp File, cl-sam/cl-sam/package.lisp: The cl-sam/cl-sam/package․lisp file
Lisp File, cl-sam/cl-sam/sam-writer.lisp: The cl-sam/cl-sam/sam-writer․lisp file
Lisp File, cl-sam/cl-sam/sam.lisp: The cl-sam/cl-sam/sam․lisp file

M
Module, cl-sam/cl-sam: The cl-sam/cl-sam module

Jump to:   C   F   L   M  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.2 Functions

Jump to:   %   (  
A   B   C   D   E   F   G   H   I   L   M   N   P   Q   R   S   U   V   W  
Index Entry  Section

%
%encode-string-tag: Internal functions
%make-bam-index: Internal functions
%make-ref-index: Internal functions
%read-bam-alignment: Internal functions
%stream-read-sequence: Internal functions
%write-int32: Internal functions
%write-int64: Internal functions

(
(setf aln-bin): Internal functions
(setf aln-cigar): Internal functions
(setf aln-flag): Internal functions
(setf aln-insert-length): Internal functions
(setf aln-map-qual): Internal functions
(setf aln-mate-pos): Internal functions
(setf aln-mate-ref-id): Internal functions
(setf aln-pos): Internal functions
(setf aln-qual-str): Internal functions
(setf aln-read-name): Internal functions
(setf aln-record): Internal functions
(setf aln-ref-id): Internal functions
(setf aln-ref-len): Internal functions
(setf aln-seq-str): Internal functions
(setf bam-index-refs): Exported functions
(setf bgz-member-bsize): Internal functions
(setf bgz-member-cdata): Internal functions
(setf bgz-member-cend): Internal functions
(setf bgz-member-crc32): Internal functions
(setf bgz-member-flg): Internal functions
(setf bgz-member-isize): Internal functions
(setf bgz-member-mtime): Internal functions
(setf bgz-member-os): Internal functions
(setf bgz-member-udata): Internal functions
(setf bgz-member-xfl): Internal functions
(setf bgz-member-xlen): Internal functions
(setf bgzf-buffer): Internal functions
(setf bgzf-compression): Internal functions
(setf bgzf-eof): Internal functions
(setf bgzf-load-seek): Internal functions
(setf bgzf-loaded-p): Internal functions
(setf bgzf-offset): Internal functions
(setf bgzf-pathname): Internal functions
(setf bgzf-pointer): Internal functions
(setf bgzf-position): Internal functions
(setf bgzf-stream): Internal functions
(setf bgzf-util-buffer): Internal functions
(setf bin-chunks): Exported functions
(setf chunk-end): Exported functions
(setf chunk-start): Exported functions
(setf ref-index-bins): Exported functions
(setf ref-index-intervals): Exported functions
(setf region-end): Internal functions
(setf region-ref): Internal functions
(setf region-start): Internal functions
(setf samtools-bam-index-refs): Internal functions
(setf samtools-bam-index-unassigned): Internal functions
(setf samtools-ref-index-bins): Internal functions
(setf samtools-ref-index-end): Internal functions
(setf samtools-ref-index-intervals): Internal functions
(setf samtools-ref-index-mapped): Internal functions
(setf samtools-ref-index-start): Internal functions
(setf samtools-ref-index-unmapped): Internal functions

A
add-pg-record: Exported functions
adjacentp: Internal functions
alignment-bin: Exported functions
alignment-cigar: Exported functions
alignment-core: Exported functions
alignment-core-alist: Exported functions
alignment-flag: Exported functions
alignment-flag-alist: Exported functions
alignment-generator: Exported functions
alignment-indices: Internal functions
alignment-name-natural<: Internal functions
alignment-name<: Exported functions
alignment-not-primary-p: Exported functions
alignment-orphanizer: Exported functions
alignment-p: Internal functions
alignment-position: Exported functions
alignment-primary-p: Internal functions
alignment-read-length: Internal functions
alignment-record<: Exported functions
alignment-reference-end: Exported functions
alignment-reference-length: Internal functions
alignment-tag-bytes: Internal functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-documentation: Exported generic functions
alignment-tag-values: Exported functions
aln-bin: Internal functions
aln-cigar: Internal functions
aln-flag: Internal functions
aln-insert-length: Internal functions
aln-map-qual: Internal functions
aln-mate-pos: Internal functions
aln-mate-ref-id: Internal functions
aln-pos: Internal functions
aln-qual-str: Internal functions
aln-read-name: Internal functions
aln-record: Internal functions
aln-ref-id: Internal functions
aln-ref-len: Internal functions
aln-seq-str: Internal functions

B
bam-index-p: Internal functions
bam-index-refs: Exported functions
bam-meta-size: Internal functions
bam-meta-size2: Internal functions
bam-sort-error: Exported functions
bgz-member-bsize: Internal functions
bgz-member-cdata: Internal functions
bgz-member-cend: Internal functions
bgz-member-cm: Internal functions
bgz-member-crc32: Internal functions
bgz-member-flg: Internal functions
bgz-member-id1: Internal functions
bgz-member-id2: Internal functions
bgz-member-isize: Internal functions
bgz-member-mtime: Internal functions
bgz-member-os: Internal functions
bgz-member-p: Internal functions
bgz-member-sf1: Internal functions
bgz-member-sf2: Internal functions
bgz-member-slen: Internal functions
bgz-member-udata: Internal functions
bgz-member-xfl: Internal functions
bgz-member-xlen: Internal functions
bgzf-buffer: Internal functions
bgzf-close: Exported functions
bgzf-coffset: Internal functions
bgzf-compression: Internal functions
bgzf-empty-p: Internal functions
bgzf-eof: Internal functions
bgzf-eof-p: Exported functions
bgzf-flush: Internal functions
bgzf-load-seek: Internal functions
bgzf-loaded-p: Internal functions
bgzf-of: Internal generic functions
bgzf-of: Internal generic functions
bgzf-offset: Internal functions
bgzf-open: Exported functions
bgzf-open-p: Exported functions
bgzf-p: Internal functions
bgzf-pathname: Internal functions
bgzf-pointer: Internal functions
bgzf-position: Internal functions
bgzf-seek: Exported functions
bgzf-stream: Internal functions
bgzf-tell: Exported functions
bgzf-uoffset: Internal functions
bgzf-util-buffer: Internal functions
bgzip-open: Exported functions
bin-chunk: Exported functions
bin-chunks: Exported functions
bin-num: Exported functions
bin-p: Internal functions
block-sizes: Internal functions
buffer-empty-p: Internal functions
buffer-of: Internal generic functions
buffer-of: Internal generic functions

C
chunk-end: Exported functions
chunk-p: Internal functions
chunk-start: Exported functions
cigar-length: Exported functions
coordinate-sorted-p: Exported functions
copy-alignment: Internal functions
copy-alignment-record: Exported functions
copy-bam-index: Internal functions
copy-bgz-member: Internal functions
copy-bgzf: Internal functions
copy-bin: Internal functions
copy-chunk: Internal functions
copy-ref-index: Internal functions
copy-region: Internal functions
copy-samtools-bam-index: Internal functions
copy-samtools-ref-index: Internal functions

D
decode-cigar: Internal functions
decode-quality-string: Internal functions
decode-read-name: Internal functions
decode-seq-string: Internal functions
decode-tag-values: Internal functions
default-orphanizer-test: Internal functions
default-qual-string: Internal functions
default-seq-string: Internal functions
define-alignment-tag: Exported macros
define-header-tag-parser: Internal macros
deflate-bgz-member: Internal functions

E
empty-bin-p: Exported functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-alignment-tag: Internal generic functions
encode-char-tag: Internal functions
encode-cigar: Internal functions
encode-float-tag: Internal functions
encode-hex-tag: Internal functions
encode-int-tag: Internal functions
encode-phred-quality: Internal functions
encode-quality-string: Internal functions
encode-read-name: Internal functions
encode-seq-string: Internal functions
encode-string-tag: Internal functions
encode-unknown-quality: Internal functions
ensure-mandatory-header-tags: Exported functions
ensure-order: Internal functions
ensure-sam-version: Internal functions
ensure-unique-tag-values: Internal functions
ensure-valid-flag: Internal functions
ensure-valid-header-tags: Exported functions
ensure-valid-programs: Exported functions
ensure-valid-read-name: Internal functions
ensure-valid-reference-name: Internal functions
ensure-valid-region: Internal functions
errno-of: Internal generic functions
errno-of: Internal generic functions

F
fails-platform-qc-p: Exported functions
fill-buffer: Internal functions
find-bam-index: Exported functions
find-bins: Exported functions
find-duplicate-header-tags: Internal functions
find-duplicate-records: Internal functions
find-interval: Internal functions
first-frag-p: Exported functions
first-in-pair-p: Exported functions
flag-bits: Exported functions
flag-symbol: Internal functions
flag-validation-error: Internal functions
flagstat: Exported functions
frag-forward-p: Exported functions
frag-mapped-p: Exported functions
frag-reverse-p: Exported functions
frag-unmapped-p: Exported functions
Function, %encode-string-tag: Internal functions
Function, %make-bam-index: Internal functions
Function, %make-ref-index: Internal functions
Function, %read-bam-alignment: Internal functions
Function, %stream-read-sequence: Internal functions
Function, %write-int32: Internal functions
Function, %write-int64: Internal functions
Function, (setf aln-bin): Internal functions
Function, (setf aln-cigar): Internal functions
Function, (setf aln-flag): Internal functions
Function, (setf aln-insert-length): Internal functions
Function, (setf aln-map-qual): Internal functions
Function, (setf aln-mate-pos): Internal functions
Function, (setf aln-mate-ref-id): Internal functions
Function, (setf aln-pos): Internal functions
Function, (setf aln-qual-str): Internal functions
Function, (setf aln-read-name): Internal functions
Function, (setf aln-record): Internal functions
Function, (setf aln-ref-id): Internal functions
Function, (setf aln-ref-len): Internal functions
Function, (setf aln-seq-str): Internal functions
Function, (setf bam-index-refs): Exported functions
Function, (setf bgz-member-bsize): Internal functions
Function, (setf bgz-member-cdata): Internal functions
Function, (setf bgz-member-cend): Internal functions
Function, (setf bgz-member-crc32): Internal functions
Function, (setf bgz-member-flg): Internal functions
Function, (setf bgz-member-isize): Internal functions
Function, (setf bgz-member-mtime): Internal functions
Function, (setf bgz-member-os): Internal functions
Function, (setf bgz-member-udata): Internal functions
Function, (setf bgz-member-xfl): Internal functions
Function, (setf bgz-member-xlen): Internal functions
Function, (setf bgzf-buffer): Internal functions
Function, (setf bgzf-compression): Internal functions
Function, (setf bgzf-eof): Internal functions
Function, (setf bgzf-load-seek): Internal functions
Function, (setf bgzf-loaded-p): Internal functions
Function, (setf bgzf-offset): Internal functions
Function, (setf bgzf-pathname): Internal functions
Function, (setf bgzf-pointer): Internal functions
Function, (setf bgzf-position): Internal functions
Function, (setf bgzf-stream): Internal functions
Function, (setf bgzf-util-buffer): Internal functions
Function, (setf bin-chunks): Exported functions
Function, (setf chunk-end): Exported functions
Function, (setf chunk-start): Exported functions
Function, (setf ref-index-bins): Exported functions
Function, (setf ref-index-intervals): Exported functions
Function, (setf region-end): Internal functions
Function, (setf region-ref): Internal functions
Function, (setf region-start): Internal functions
Function, (setf samtools-bam-index-refs): Internal functions
Function, (setf samtools-bam-index-unassigned): Internal functions
Function, (setf samtools-ref-index-bins): Internal functions
Function, (setf samtools-ref-index-end): Internal functions
Function, (setf samtools-ref-index-intervals): Internal functions
Function, (setf samtools-ref-index-mapped): Internal functions
Function, (setf samtools-ref-index-start): Internal functions
Function, (setf samtools-ref-index-unmapped): Internal functions
Function, add-pg-record: Exported functions
Function, adjacentp: Internal functions
Function, alignment-bin: Exported functions
Function, alignment-cigar: Exported functions
Function, alignment-core: Exported functions
Function, alignment-core-alist: Exported functions
Function, alignment-flag: Exported functions
Function, alignment-flag-alist: Exported functions
Function, alignment-generator: Exported functions
Function, alignment-indices: Internal functions
Function, alignment-name-natural<: Internal functions
Function, alignment-name<: Exported functions
Function, alignment-not-primary-p: Exported functions
Function, alignment-orphanizer: Exported functions
Function, alignment-p: Internal functions
Function, alignment-position: Exported functions
Function, alignment-primary-p: Internal functions
Function, alignment-read-length: Internal functions
Function, alignment-record<: Exported functions
Function, alignment-reference-end: Exported functions
Function, alignment-reference-length: Internal functions
Function, alignment-tag-bytes: Internal functions
Function, alignment-tag-values: Exported functions
Function, aln-bin: Internal functions
Function, aln-cigar: Internal functions
Function, aln-flag: Internal functions
Function, aln-insert-length: Internal functions
Function, aln-map-qual: Internal functions
Function, aln-mate-pos: Internal functions
Function, aln-mate-ref-id: Internal functions
Function, aln-pos: Internal functions
Function, aln-qual-str: Internal functions
Function, aln-read-name: Internal functions
Function, aln-record: Internal functions
Function, aln-ref-id: Internal functions
Function, aln-ref-len: Internal functions
Function, aln-seq-str: Internal functions
Function, bam-index-p: Internal functions
Function, bam-index-refs: Exported functions
Function, bam-meta-size: Internal functions
Function, bam-meta-size2: Internal functions
Function, bam-sort-error: Exported functions
Function, bgz-member-bsize: Internal functions
Function, bgz-member-cdata: Internal functions
Function, bgz-member-cend: Internal functions
Function, bgz-member-cm: Internal functions
Function, bgz-member-crc32: Internal functions
Function, bgz-member-flg: Internal functions
Function, bgz-member-id1: Internal functions
Function, bgz-member-id2: Internal functions
Function, bgz-member-isize: Internal functions
Function, bgz-member-mtime: Internal functions
Function, bgz-member-os: Internal functions
Function, bgz-member-p: Internal functions
Function, bgz-member-sf1: Internal functions
Function, bgz-member-sf2: Internal functions
Function, bgz-member-slen: Internal functions
Function, bgz-member-udata: Internal functions
Function, bgz-member-xfl: Internal functions
Function, bgz-member-xlen: Internal functions
Function, bgzf-buffer: Internal functions
Function, bgzf-close: Exported functions
Function, bgzf-coffset: Internal functions
Function, bgzf-compression: Internal functions
Function, bgzf-empty-p: Internal functions
Function, bgzf-eof: Internal functions
Function, bgzf-eof-p: Exported functions
Function, bgzf-flush: Internal functions
Function, bgzf-load-seek: Internal functions
Function, bgzf-loaded-p: Internal functions
Function, bgzf-offset: Internal functions
Function, bgzf-open: Exported functions
Function, bgzf-open-p: Exported functions
Function, bgzf-p: Internal functions
Function, bgzf-pathname: Internal functions
Function, bgzf-pointer: Internal functions
Function, bgzf-position: Internal functions
Function, bgzf-seek: Exported functions
Function, bgzf-stream: Internal functions
Function, bgzf-tell: Exported functions
Function, bgzf-uoffset: Internal functions
Function, bgzf-util-buffer: Internal functions
Function, bgzip-open: Exported functions
Function, bin-chunk: Exported functions
Function, bin-chunks: Exported functions
Function, bin-num: Exported functions
Function, bin-p: Internal functions
Function, block-sizes: Internal functions
Function, buffer-empty-p: Internal functions
Function, chunk-end: Exported functions
Function, chunk-p: Internal functions
Function, chunk-start: Exported functions
Function, cigar-length: Exported functions
Function, coordinate-sorted-p: Exported functions
Function, copy-alignment: Internal functions
Function, copy-alignment-record: Exported functions
Function, copy-bam-index: Internal functions
Function, copy-bgz-member: Internal functions
Function, copy-bgzf: Internal functions
Function, copy-bin: Internal functions
Function, copy-chunk: Internal functions
Function, copy-ref-index: Internal functions
Function, copy-region: Internal functions
Function, copy-samtools-bam-index: Internal functions
Function, copy-samtools-ref-index: Internal functions
Function, decode-cigar: Internal functions
Function, decode-quality-string: Internal functions
Function, decode-read-name: Internal functions
Function, decode-seq-string: Internal functions
Function, decode-tag-values: Internal functions
Function, default-orphanizer-test: Internal functions
Function, default-qual-string: Internal functions
Function, default-seq-string: Internal functions
Function, deflate-bgz-member: Internal functions
Function, empty-bin-p: Exported functions
Function, encode-char-tag: Internal functions
Function, encode-cigar: Internal functions
Function, encode-float-tag: Internal functions
Function, encode-hex-tag: Internal functions
Function, encode-int-tag: Internal functions
Function, encode-phred-quality: Internal functions
Function, encode-quality-string: Internal functions
Function, encode-read-name: Internal functions
Function, encode-seq-string: Internal functions
Function, encode-string-tag: Internal functions
Function, encode-unknown-quality: Internal functions
Function, ensure-mandatory-header-tags: Exported functions
Function, ensure-order: Internal functions
Function, ensure-sam-version: Internal functions
Function, ensure-unique-tag-values: Internal functions
Function, ensure-valid-flag: Internal functions
Function, ensure-valid-header-tags: Exported functions
Function, ensure-valid-programs: Exported functions
Function, ensure-valid-read-name: Internal functions
Function, ensure-valid-reference-name: Internal functions
Function, ensure-valid-region: Internal functions
Function, fails-platform-qc-p: Exported functions
Function, fill-buffer: Internal functions
Function, find-bam-index: Exported functions
Function, find-bins: Exported functions
Function, find-duplicate-header-tags: Internal functions
Function, find-duplicate-records: Internal functions
Function, find-interval: Internal functions
Function, first-frag-p: Exported functions
Function, first-in-pair-p: Exported functions
Function, flag-bits: Exported functions
Function, flag-symbol: Internal functions
Function, flag-validation-error: Internal functions
Function, flagstat: Exported functions
Function, frag-forward-p: Exported functions
Function, frag-mapped-p: Exported functions
Function, frag-reverse-p: Exported functions
Function, frag-unmapped-p: Exported functions
Function, generate-bam-file: Exported functions
Function, generate-reference-file: Exported functions
Function, group-by-tag: Internal functions
Function, hd-record: Exported functions
Function, header-record: Internal functions
Function, header-records: Exported functions
Function, header-tags: Exported functions
Function, header-type: Exported functions
Function, header-value: Exported functions
Function, index-bam-file: Exported functions
Function, inflate-bgz-member: Internal functions
Function, insert-length: Exported functions
Function, last-frag-p: Exported functions
Function, last-programs: Exported functions
Function, make-alignment: Internal functions
Function, make-alignment-record: Exported functions
Function, make-aln: Internal functions
Function, make-bam-chunks: Internal functions
Function, make-bam-full-scan-input: Internal functions
Function, make-bam-index: Internal functions
Function, make-bam-index-input: Internal functions
Function, make-bam-output: Exported functions
Function, make-bam-scan-input: Internal functions
Function, make-bgz-member: Internal functions
Function, make-bgzf: Internal functions
Function, make-bin: Internal functions
Function, make-chunk: Internal functions
Function, make-header-record: Exported functions
Function, make-header-string: Internal functions
Function, make-ref-index: Internal functions
Function, make-reference-table: Exported functions
Function, make-region: Internal functions
Function, make-region<: Internal functions
Function, make-sam-header: Exported functions
Function, make-samtools-bam-index: Internal functions
Function, make-samtools-ref-index: Internal functions
Function, mandatory-header-tags: Internal functions
Function, mapped-proper-pair-p: Exported functions
Function, mapping-quality: Exported functions
Function, mate-alignment-position: Exported functions
Function, mate-forward-p: Exported functions
Function, mate-mapped-p: Exported functions
Function, mate-reference-id: Exported functions
Function, mate-reverse-p: Exported functions
Function, mate-unmapped-p: Exported functions
Function, max-bin-num: Internal functions
Function, medial-frag-p: Exported functions
Function, merge-chunks: Internal functions
Function, merge-header-records: Exported functions
Function, merge-sam-headers: Exported functions
Function, multiple-frags-p: Exported functions
Function, name-sorted-p: Exported functions
Function, next-forward-p: Internal functions
Function, next-mapped-p: Internal functions
Function, next-reverse-p: Exported functions
Function, next-unmapped-p: Exported functions
Function, normalise-regions: Internal functions
Function, parse-digits: Internal functions
Function, parse-hd-tag: Internal functions
Function, parse-pg-tag: Internal functions
Function, parse-region-string: Exported functions
Function, parse-rg-tag: Internal functions
Function, parse-sq-tag: Internal functions
Function, partition-by-type: Internal functions
Function, partition-regions: Internal functions
Function, pcr/optical-duplicate-p: Exported functions
Function, pg-record: Exported functions
Function, previous-programs: Exported functions
Function, print-aln: Internal functions
Function, print-bin: Internal functions
Function, print-chunk: Internal functions
Function, print-ref-index: Internal functions
Function, print-region: Internal functions
Function, print-samtools-ref-index: Internal functions
Function, proper-aligned-frags-p: Exported functions
Function, quality-string: Exported functions
Function, query-forward-p: Exported functions
Function, query-mapped-p: Exported functions
Function, query-reverse-p: Exported functions
Function, query-unmapped-p: Exported functions
Function, read-alignment: Exported functions
Function, read-bam-header: Exported functions
Function, read-bam-index: Exported functions
Function, read-bam-magic: Exported functions
Function, read-bam-meta: Exported functions
Function, read-bam-terminator: Exported functions
Function, read-bgz-member: Internal functions
Function, read-bin: Internal functions
Function, read-binning-index: Internal functions
Function, read-bytes: Internal functions
Function, read-index-magic: Internal functions
Function, read-length: Exported functions
Function, read-linear-index: Internal functions
Function, read-name: Exported functions
Function, read-name-length: Exported functions
Function, read-num-references: Exported functions
Function, read-ref-index: Internal functions
Function, read-reference-meta: Exported functions
Function, read-string: Internal functions
Function, ref-index: Exported functions
Function, ref-index-bin: Exported functions
Function, ref-index-bins: Exported functions
Function, ref-index-id: Internal functions
Function, ref-index-intervals: Exported functions
Function, ref-index-p: Internal functions
Function, reference-id: Exported functions
Function, region: Internal functions
Function, region-end: Internal functions
Function, region-p: Internal functions
Function, region-ref: Internal functions
Function, region-start: Internal functions
Function, region-to-bin: Internal functions
Function, region-to-bins: Internal functions
Function, region-to-interval: Internal functions
Function, repair-mapping-flags: Exported functions
Function, rg-record: Exported functions
Function, run-length-encode: Internal functions
Function, samtools-bam-index-p: Internal functions
Function, samtools-bam-index-refs: Internal functions
Function, samtools-bam-index-unassigned: Internal functions
Function, samtools-ref-index-bins: Internal functions
Function, samtools-ref-index-end: Internal functions
Function, samtools-ref-index-id: Internal functions
Function, samtools-ref-index-intervals: Internal functions
Function, samtools-ref-index-mapped: Internal functions
Function, samtools-ref-index-p: Internal functions
Function, samtools-ref-index-start: Internal functions
Function, samtools-ref-index-unmapped: Internal functions
Function, second-in-pair-p: Exported functions
Function, seq-string: Exported functions
Function, sequenced-pair-p: Exported functions
Function, simplify-records: Internal functions
Function, sort-bam-alignments: Internal functions
Function, sort-bam-file: Exported functions
Function, sq-record: Exported functions
Function, stream-view-sam: Internal functions
Function, subst-group-order: Exported functions
Function, subst-sam-version: Exported functions
Function, subst-sort-order: Exported functions
Function, unknown-frag-p: Exported functions
Function, update-pg-records: Internal functions
Function, user-header-tag-p: Internal functions
Function, valid-flag-p: Exported functions
Function, valid-header-tags: Internal functions
Function, valid-mapped-pair-p: Exported functions
Function, valid-mapped-proper-pair-p: Exported functions
Function, valid-read-name-p: Internal functions
Function, valid-reference-name-p: Exported functions
Function, valid-sam-version-p: Exported functions
Function, view-sam: Exported functions
Function, voffset-merge-p: Internal functions
Function, write-alignment: Exported functions
Function, write-bam-header: Exported functions
Function, write-bam-magic: Exported functions
Function, write-bam-meta: Exported functions
Function, write-bgz-member: Internal functions
Function, write-bin: Internal functions
Function, write-binning-index: Internal functions
Function, write-bytes: Internal functions
Function, write-chunked-bytes: Internal functions
Function, write-cigar: Internal functions
Function, write-header-record: Exported functions
Function, write-index-magic: Internal functions
Function, write-linear-index: Internal functions
Function, write-num-references: Exported functions
Function, write-quality-string: Internal functions
Function, write-reference-meta: Exported functions
Function, write-sam-alignment: Exported functions
Function, write-sam-header: Exported functions
Function, write-seq-string: Internal functions
Function, write-tag-values: Internal functions

G
generate-bam-file: Exported functions
generate-reference-file: Exported functions
Generic Function, alignment-tag-documentation: Exported generic functions
Generic Function, bgzf-of: Internal generic functions
Generic Function, buffer-of: Internal generic functions
Generic Function, encode-alignment-tag: Internal generic functions
Generic Function, errno-of: Internal generic functions
Generic Function, position-of: Internal generic functions
Generic Function, prev-position-of: Internal generic functions
Generic Function, prev-reference-of: Internal generic functions
Generic Function, reference-of: Internal generic functions
Generic Function, write-bam-index: Exported generic functions
Generic Function, write-ref-index: Internal generic functions
group-by-tag: Internal functions

H
hd-record: Exported functions
header-record: Internal functions
header-records: Exported functions
header-tags: Exported functions
header-type: Exported functions
header-value: Exported functions

I
index-bam-file: Exported functions
inflate-bgz-member: Internal functions
insert-length: Exported functions

L
last-frag-p: Exported functions
last-programs: Exported functions

M
Macro, define-alignment-tag: Exported macros
Macro, define-header-tag-parser: Internal macros
Macro, with-bam: Exported macros
Macro, with-bam-index: Exported macros
Macro, with-bgzf: Exported macros
Macro, with-open-bgzip: Exported macros
make-alignment: Internal functions
make-alignment-record: Exported functions
make-aln: Internal functions
make-bam-chunks: Internal functions
make-bam-full-scan-input: Internal functions
make-bam-index: Internal functions
make-bam-index-input: Internal functions
make-bam-output: Exported functions
make-bam-scan-input: Internal functions
make-bgz-member: Internal functions
make-bgzf: Internal functions
make-bin: Internal functions
make-chunk: Internal functions
make-header-record: Exported functions
make-header-string: Internal functions
make-ref-index: Internal functions
make-reference-table: Exported functions
make-region: Internal functions
make-region<: Internal functions
make-sam-header: Exported functions
make-samtools-bam-index: Internal functions
make-samtools-ref-index: Internal functions
mandatory-header-tags: Internal functions
mapped-proper-pair-p: Exported functions
mapping-quality: Exported functions
mate-alignment-position: Exported functions
mate-forward-p: Exported functions
mate-mapped-p: Exported functions
mate-reference-id: Exported functions
mate-reverse-p: Exported functions
mate-unmapped-p: Exported functions
max-bin-num: Internal functions
medial-frag-p: Exported functions
merge-chunks: Internal functions
merge-header-records: Exported functions
merge-sam-headers: Exported functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, alignment-tag-documentation: Exported generic functions
Method, bgzf-of: Internal generic functions
Method, buffer-of: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, encode-alignment-tag: Internal generic functions
Method, errno-of: Internal generic functions
Method, position-of: Internal generic functions
Method, prev-position-of: Internal generic functions
Method, prev-reference-of: Internal generic functions
Method, reference-of: Internal generic functions
Method, write-bam-index: Exported generic functions
Method, write-bam-index: Exported generic functions
Method, write-ref-index: Internal generic functions
Method, write-ref-index: Internal generic functions
multiple-frags-p: Exported functions

N
name-sorted-p: Exported functions
next-forward-p: Internal functions
next-mapped-p: Internal functions
next-reverse-p: Exported functions
next-unmapped-p: Exported functions
normalise-regions: Internal functions

P
parse-digits: Internal functions
parse-hd-tag: Internal functions
parse-pg-tag: Internal functions
parse-region-string: Exported functions
parse-rg-tag: Internal functions
parse-sq-tag: Internal functions
partition-by-type: Internal functions
partition-regions: Internal functions
pcr/optical-duplicate-p: Exported functions
pg-record: Exported functions
position-of: Internal generic functions
position-of: Internal generic functions
prev-position-of: Internal generic functions
prev-position-of: Internal generic functions
prev-reference-of: Internal generic functions
prev-reference-of: Internal generic functions
previous-programs: Exported functions
print-aln: Internal functions
print-bin: Internal functions
print-chunk: Internal functions
print-ref-index: Internal functions
print-region: Internal functions
print-samtools-ref-index: Internal functions
proper-aligned-frags-p: Exported functions

Q
quality-string: Exported functions
query-forward-p: Exported functions
query-mapped-p: Exported functions
query-reverse-p: Exported functions
query-unmapped-p: Exported functions

R
read-alignment: Exported functions
read-bam-header: Exported functions
read-bam-index: Exported functions
read-bam-magic: Exported functions
read-bam-meta: Exported functions
read-bam-terminator: Exported functions
read-bgz-member: Internal functions
read-bin: Internal functions
read-binning-index: Internal functions
read-bytes: Internal functions
read-index-magic: Internal functions
read-length: Exported functions
read-linear-index: Internal functions
read-name: Exported functions
read-name-length: Exported functions
read-num-references: Exported functions
read-ref-index: Internal functions
read-reference-meta: Exported functions
read-string: Internal functions
ref-index: Exported functions
ref-index-bin: Exported functions
ref-index-bins: Exported functions
ref-index-id: Internal functions
ref-index-intervals: Exported functions
ref-index-p: Internal functions
reference-id: Exported functions
reference-of: Internal generic functions
reference-of: Internal generic functions
region: Internal functions
region-end: Internal functions
region-p: Internal functions
region-ref: Internal functions
region-start: Internal functions
region-to-bin: Internal functions
region-to-bins: Internal functions
region-to-interval: Internal functions
repair-mapping-flags: Exported functions
rg-record: Exported functions
run-length-encode: Internal functions

S
samtools-bam-index-p: Internal functions
samtools-bam-index-refs: Internal functions
samtools-bam-index-unassigned: Internal functions
samtools-ref-index-bins: Internal functions
samtools-ref-index-end: Internal functions
samtools-ref-index-id: Internal functions
samtools-ref-index-intervals: Internal functions
samtools-ref-index-mapped: Internal functions
samtools-ref-index-p: Internal functions
samtools-ref-index-start: Internal functions
samtools-ref-index-unmapped: Internal functions
second-in-pair-p: Exported functions
seq-string: Exported functions
sequenced-pair-p: Exported functions
simplify-records: Internal functions
sort-bam-alignments: Internal functions
sort-bam-file: Exported functions
sq-record: Exported functions
stream-view-sam: Internal functions
subst-group-order: Exported functions
subst-sam-version: Exported functions
subst-sort-order: Exported functions

U
unknown-frag-p: Exported functions
update-pg-records: Internal functions
user-header-tag-p: Internal functions

V
valid-flag-p: Exported functions
valid-header-tags: Internal functions
valid-mapped-pair-p: Exported functions
valid-mapped-proper-pair-p: Exported functions
valid-read-name-p: Internal functions
valid-reference-name-p: Exported functions
valid-sam-version-p: Exported functions
view-sam: Exported functions
voffset-merge-p: Internal functions

W
with-bam: Exported macros
with-bam-index: Exported macros
with-bgzf: Exported macros
with-open-bgzip: Exported macros
write-alignment: Exported functions
write-bam-header: Exported functions
write-bam-index: Exported generic functions
write-bam-index: Exported generic functions
write-bam-index: Exported generic functions
write-bam-magic: Exported functions
write-bam-meta: Exported functions
write-bgz-member: Internal functions
write-bin: Internal functions
write-binning-index: Internal functions
write-bytes: Internal functions
write-chunked-bytes: Internal functions
write-cigar: Internal functions
write-header-record: Exported functions
write-index-magic: Internal functions
write-linear-index: Internal functions
write-num-references: Exported functions
write-quality-string: Internal functions
write-ref-index: Internal generic functions
write-ref-index: Internal generic functions
write-ref-index: Internal generic functions
write-reference-meta: Exported functions
write-sam-alignment: Exported functions
write-sam-header: Exported functions
write-seq-string: Internal functions
write-tag-values: Internal functions

Jump to:   %   (  
A   B   C   D   E   F   G   H   I   L   M   N   P   Q   R   S   U   V   W  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.3 Variables

Jump to:   *   +  
B   C   E   F   I   L   M   N   O   P   Q   R   S   U  
Index Entry  Section

*
*bam-index-file-type*: Internal special variables
*bam-index-magic*: Internal special variables
*bam-magic*: Internal special variables
*default-compression*: Internal special variables
*empty-bgz-record*: Internal special variables
*invalid-read-name-chars*: Internal special variables
*mandatory-header-tags*: Internal special variables
*sam-version*: Exported special variables
*tree-deepening-boundaries*: Internal special variables
*valid-group-orders*: Internal special variables
*valid-header-tags*: Internal special variables
*valid-header-types*: Internal special variables
*valid-sort-orders*: Internal special variables
*voffset-merge-distance*: Internal special variables

+
+alignment-size-tag+: Internal constants
+bgz-max-payload-length+: Internal constants
+bgzip-buffer-size+: Internal constants
+linear-bin-size+: Internal constants
+max-num-bins+: Internal constants
+member-footer-length+: Internal constants
+member-header-length+: Internal constants
+null-byte+: Internal constants
+samtools-kludge-bin+: Internal constants
+sf1+: Internal constants
+sf2+: Internal constants
+slen+: Internal constants
+tag-size+: Internal constants
+unknown-position+: Internal constants
+unknown-quality+: Internal constants
+unknown-reference+: Internal constants
+xlen+: Internal constants

B
bgzf: Exported conditions
bgzf: Internal classes
bin: Internal structures
bins: Exported structures
bsize: Internal structures
buffer: Exported structures
buffer: Exported classes
buffer: Internal classes

C
chunks: Exported structures
cigar: Internal structures
compression: Exported structures
Constant, +alignment-size-tag+: Internal constants
Constant, +bgz-max-payload-length+: Internal constants
Constant, +bgzip-buffer-size+: Internal constants
Constant, +linear-bin-size+: Internal constants
Constant, +max-num-bins+: Internal constants
Constant, +member-footer-length+: Internal constants
Constant, +member-header-length+: Internal constants
Constant, +null-byte+: Internal constants
Constant, +samtools-kludge-bin+: Internal constants
Constant, +sf1+: Internal constants
Constant, +sf2+: Internal constants
Constant, +slen+: Internal constants
Constant, +tag-size+: Internal constants
Constant, +unknown-position+: Internal constants
Constant, +unknown-quality+: Internal constants
Constant, +unknown-reference+: Internal constants
Constant, +xlen+: Internal constants

E
end: Exported structures
end: Internal structures
end: Internal structures
eof: Exported structures
errno: Exported conditions

F
flag: Internal structures

I
id: Exported structures
insert-length: Internal structures
intervals: Exported structures

L
load-seek: Exported structures
loaded-p: Exported structures

M
map-qual: Internal structures
mapped: Internal structures
mate-pos: Internal structures
mate-ref-id: Internal structures

N
num: Exported structures
num-bytes: Exported classes

O
offset: Exported structures
offset: Exported classes

P
pathname: Exported structures
pointer: Exported structures
pos: Internal structures
position: Exported conditions
position: Exported structures
prev-position: Exported conditions
prev-reference: Exported conditions

Q
qual-str: Internal structures

R
read-name: Internal structures
record: Internal structures
ref: Internal structures
ref-id: Internal structures
ref-len: Internal structures
reference: Exported conditions
refs: Exported structures

S
seq-str: Internal structures
sf1: Internal structures
sf2: Internal structures
slen: Internal structures
Slot, bgzf: Exported conditions
Slot, bgzf: Internal classes
Slot, bin: Internal structures
Slot, bins: Exported structures
Slot, bsize: Internal structures
Slot, buffer: Exported structures
Slot, buffer: Exported classes
Slot, buffer: Internal classes
Slot, chunks: Exported structures
Slot, cigar: Internal structures
Slot, compression: Exported structures
Slot, end: Exported structures
Slot, end: Internal structures
Slot, end: Internal structures
Slot, eof: Exported structures
Slot, errno: Exported conditions
Slot, flag: Internal structures
Slot, id: Exported structures
Slot, insert-length: Internal structures
Slot, intervals: Exported structures
Slot, load-seek: Exported structures
Slot, loaded-p: Exported structures
Slot, map-qual: Internal structures
Slot, mapped: Internal structures
Slot, mate-pos: Internal structures
Slot, mate-ref-id: Internal structures
Slot, num: Exported structures
Slot, num-bytes: Exported classes
Slot, offset: Exported structures
Slot, offset: Exported classes
Slot, pathname: Exported structures
Slot, pointer: Exported structures
Slot, pos: Internal structures
Slot, position: Exported conditions
Slot, position: Exported structures
Slot, prev-position: Exported conditions
Slot, prev-reference: Exported conditions
Slot, qual-str: Internal structures
Slot, read-name: Internal structures
Slot, record: Internal structures
Slot, ref: Internal structures
Slot, ref-id: Internal structures
Slot, ref-len: Internal structures
Slot, reference: Exported conditions
Slot, refs: Exported structures
Slot, seq-str: Internal structures
Slot, sf1: Internal structures
Slot, sf2: Internal structures
Slot, slen: Internal structures
Slot, start: Exported structures
Slot, start: Internal structures
Slot, start: Internal structures
Slot, stream: Exported structures
Slot, udata: Internal structures
Slot, unassigned: Internal structures
Slot, unmapped: Internal structures
Slot, util-buffer: Exported structures
Special Variable, *bam-index-file-type*: Internal special variables
Special Variable, *bam-index-magic*: Internal special variables
Special Variable, *bam-magic*: Internal special variables
Special Variable, *default-compression*: Internal special variables
Special Variable, *empty-bgz-record*: Internal special variables
Special Variable, *invalid-read-name-chars*: Internal special variables
Special Variable, *mandatory-header-tags*: Internal special variables
Special Variable, *sam-version*: Exported special variables
Special Variable, *tree-deepening-boundaries*: Internal special variables
Special Variable, *valid-group-orders*: Internal special variables
Special Variable, *valid-header-tags*: Internal special variables
Special Variable, *valid-header-types*: Internal special variables
Special Variable, *valid-sort-orders*: Internal special variables
Special Variable, *voffset-merge-distance*: Internal special variables
start: Exported structures
start: Internal structures
start: Internal structures
stream: Exported structures

U
udata: Internal structures
unassigned: Internal structures
unmapped: Internal structures
util-buffer: Exported structures

Jump to:   *   +  
B   C   E   F   I   L   M   N   O   P   Q   R   S   U  

Previous: , Up: Indexes   [Contents][Index]

A.4 Data types

Jump to:   A   B   C   P   R   S   T  
Index Entry  Section

A
alignment: Internal structures

B
bam-error: Exported conditions
bam-index: Exported structures
bam-merge-stream: Internal classes
bam-sort-error: Exported conditions
bam-sort-input-stream: Internal classes
bam-sort-output-stream: Internal classes
bgz-member: Internal structures
bgzf: Exported structures
bgzf-ffi: The bgzf-ffi package
bgzf-handle-mixin: Internal classes
bgzf-io-error: Exported conditions
bgzip-buffer: Internal types
bgzip-buffer-index: Internal types
bgzip-input-stream: Exported classes
bgzip-stream: Exported classes
bin: Exported structures

C
chunk: Exported structures
cl-sam: The cl-sam system
Class, bam-merge-stream: Internal classes
Class, bam-sort-input-stream: Internal classes
Class, bam-sort-output-stream: Internal classes
Class, bgzf-handle-mixin: Internal classes
Class, bgzip-input-stream: Exported classes
Class, bgzip-stream: Exported classes
Condition, bam-error: Exported conditions
Condition, bam-sort-error: Exported conditions
Condition, bgzf-io-error: Exported conditions

P
Package, bgzf-ffi: The bgzf-ffi package
Package, sam: The sam package

R
ref-index: Exported structures
region: Internal structures

S
sam: The sam package
samtools-bam-index: Internal structures
samtools-ref-index: Internal structures
Structure, alignment: Internal structures
Structure, bam-index: Exported structures
Structure, bgz-member: Internal structures
Structure, bgzf: Exported structures
Structure, bin: Exported structures
Structure, chunk: Exported structures
Structure, ref-index: Exported structures
Structure, region: Internal structures
Structure, samtools-bam-index: Internal structures
Structure, samtools-ref-index: Internal structures
System, cl-sam: The cl-sam system

T
Type, bgzip-buffer: Internal types
Type, bgzip-buffer-index: Internal types

Jump to:   A   B   C   P   R   S   T