* Return number of elements. */

* Append a single alignment result, which might be paired or * unpaired, to the given output stream in Bowtie's verbose-mode * format. If the ali

Return length of the read in the buffer

* Return true iff there are no elements. */

* Return the score of the given read character with the given quality * aligning to the given reference mask. Take Ns into account. */

* Add an element to the back and immediately initialize it via * operator=. */

* Clear set without deallocating (or setting) anything. */

* Reset Edit to uninitialized state. */

* If size is less than requested size, resize up to at least sz * and set cur_ to requested sz. */

* Write a c++ string to the write buffer and, if necessary, flush. */

* Return a pointer to the beginning of the buffer. */

* Check that the edit is internally consistent. */

* Populate the given SwResult with information about the "next best" * alignment if there is one. If there isn't one, false is returned. Note * th

* Return true iff this slice is initialized. */

* Get the nucleotide and quality value at the given offset from 5' end. * If 'fw' is false, get the reverse complement. */

* The penalty associated with opening a new read gap. */

* The penalty associated with opening a new ref gap. */

* Add an element to the back. No intialization is done. */

* Return true iff all elements have been reported. */

* The penalty associated with extending a read gap by one character. */

* The penalty associated with extending a ref gap by one character. */

Check that Ebwt is internally consistent with respect to given EbwtParams; assert if not

* Put a terminator in the 'len_'th element and then return a * pointer to the buffer. Useful for printing. */

* Return number of active elements in the range being tracked by * this GWState. */

* Return true iff this AlnRes and the given AlnRes overlap. Two AlnRess * overlap if they share a cell in the overall dynamic programming table: *

* Initialize new AlnRes. */

* Tally a memory allocation of size amt bytes. */

* Return the number of reference nucleotides involved in the alignment * (i.e. the number of characters in the inclusive range from the first * ma

* Return the 0-based offset of the alignment into the reference * sequence it aligned to. */

* Another interface for running a case. */

* Return the number of Ns in the read. */

* Return the marginal penalty incurred by a mismatch at a read * position with quality 30. */

* Return true iff this Edit is an initialized insertion. */

* Return true iff the Edit is initialized. */

* Caller uses this member function to indicate that one additional unpaired * mate alignment has been found for the specified mate. */

* Close the input stream (if that's possible) */

* Get orientation of the Coord. */

* Return true iff this Edit is an initialized deletion. */

* Reverse list elements. */

* Return an integer representing the alignment state we're in. */

* Return true iff this locus is present in one of the intervals in the * list. */

* Return DNA character corresponding to element 'idx'. */

* Initialize a new descent branching from the given descent via the given * edit. Return false if the Descent has no outgoing edges (and can * ther

* Copy 'sz' bytes from buffer 'b' into this string. memcpy is used, not * operator=. */

Make this look like an invalid SideLocus

* Initialize with a new read. */

* Insert a new element into the set in sorted order. */

* Allocate a T array of length sz_ and store in list_. Also, * tally into the global memory tally. */

* Return the total capacity of the Descent driver and all its constituent * parts. */

* Clear all the outgoing edges stored here. */

* Return true iff all input is exhausted. */

* Given row i, return the row that the LF mapping maps i to. */

* Given the score floor for valid alignments and the length of the read, * calculate the maximum possible number of read gaps that could occur in a

* Given the score floor for valid alignments and the length of the read, * calculate the maximum possible number of reference gaps that could occur

* Return the number of elements being held. */

* Return the total size occupued by the Descent driver and all its * constituent parts. */

* Return memory category. */

* Add an element to the back. No intialization is done. */

* Return the size of the alignments SA range.s */

* Return the number of elements in this range. */

* If false, no further consideration of the given mate is necessary. It's * not needed for *any* class of alignment: concordant, discordant or *

* Return the number of SA elements involved in hits. */

* Return true iff this set contains 'el'. */

* Set the given cell's E mask. This is the mask of remaining legal ways to * backtrack from the E cell at this coordinate. It's 2 bits long and has

* Set the given cell's F mask. This is the mask of remaining legal ways to * backtrack from the F cell at this coordinate. It's 2 bits long and has

* Write already-finished lines starting from cur_. */

* Parse an int out of optarg and enforce that it be at least 'lower'; * if it is less than 'lower', than output the given error message and * exit w

* Return the best score achievable by a read of length 'rdlen'. */

* Set a bit. */

* Return the number of intervals added since the last call to reset() or * clear(). */

* Add a new search root, which might (a) prefer to move in a left-to-right * direction, and might (b) be with respect to the read or its reverse *

* Drive the process of descending from all search roots. */

* Return the element in the H matrix at element row, col. */

* Return a pointer to the H vector at the given row and column. Note: * here row refers to rows of vectors, not rows of elements. */

* Return the length of the string. */

* Return the number of SA ranges involved in hits. */

* Return the number of records that have been started so far. */

* Clear seed-hit state and end-to-end alignment state. */