rsomics-annotation 0.1.0

Typed GFF3 and GTF validation, selection, conversion, and sequence extraction
Documentation
use crate::transcript::Span;

pub(crate) struct Spliced {
    pub(crate) sequence: Vec<u8>,
    pub(crate) coding_range: Option<(u64, u64)>,
}

pub(crate) fn splice(
    genome: &[u8],
    exons: &[Span],
    reverse: bool,
    range: Span,
    coding: Option<Span>,
) -> Spliced {
    let mut sequence = Vec::with_capacity((range.end - range.start + 1) as usize);
    let mut coding_start = None;
    let mut coding_end = None;

    for index in 0..exons.len() {
        let exon = exons[if reverse {
            exons.len() - index - 1
        } else {
            index
        }];
        if !range.overlaps(exon) {
            continue;
        }

        let segment = Span {
            start: exon.start.max(range.start),
            end: exon.end.min(range.end),
        };
        let bases = &genome[(segment.start - 1) as usize..segment.end as usize];
        if reverse {
            push_reverse_complement(&mut sequence, bases);
        } else {
            sequence.extend_from_slice(bases);
        }

        let written = sequence.len() as u64;
        if let Some(coding) = coding {
            if reverse {
                if segment.contains(coding.end) {
                    coding_start = Some(written - (coding.end - segment.start));
                }
                if segment.contains(coding.start) {
                    coding_end = Some(written - (coding.start - segment.start));
                }
            } else {
                if segment.contains(coding.start) {
                    coding_start = Some(written - (segment.end - coding.start));
                }
                if segment.contains(coding.end) {
                    coding_end = Some(written - (segment.end - coding.end));
                }
            }
        }
    }

    Spliced {
        sequence,
        coding_range: coding_start.zip(coding_end),
    }
}

fn push_reverse_complement(output: &mut Vec<u8>, sequence: &[u8]) {
    output.extend(sequence.iter().rev().map(|base| complement(*base)));
}

fn complement(base: u8) -> u8 {
    match base {
        b'A' => b'T',
        b'a' => b't',
        b'C' => b'G',
        b'c' => b'g',
        b'G' => b'C',
        b'g' => b'c',
        b'T' | b'U' => b'A',
        b't' | b'u' => b'a',
        b'M' => b'K',
        b'm' => b'k',
        b'R' => b'Y',
        b'r' => b'y',
        b'W' => b'W',
        b'w' => b'w',
        b'S' => b'S',
        b's' => b's',
        b'Y' => b'R',
        b'y' => b'r',
        b'K' => b'M',
        b'k' => b'm',
        b'V' => b'B',
        b'v' => b'b',
        b'H' => b'D',
        b'h' => b'd',
        b'D' => b'H',
        b'd' => b'h',
        b'B' => b'V',
        b'b' => b'v',
        b'N' => b'N',
        b'n' => b'n',
        b'X' => b'X',
        b'x' => b'x',
        b'-' => b'-',
        b'*' => b'*',
        _ => b'N',
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn reverse_strand_reorders_exons_and_complements_bases() {
        let genome = b"AACCGGTT";
        let exons = [Span { start: 1, end: 2 }, Span { start: 7, end: 8 }];
        let result = splice(genome, &exons, true, Span { start: 1, end: 8 }, None);
        assert_eq!(result.sequence, b"AATT");
    }
}