insertions

src/lib.rs

@@ -37,6 +37,7 @@ pub struct Contig {
 pub enum ContigRef {
     Unique(Mapping),
     Chimeric((Mapping, Mapping)),
+    ChimericTriple((Mapping, Mapping, Mapping)),
     ChimericMultiple((Mapping, Vec<Mapping>, Mapping)),
     LeftAmbiguity((Vec<Mapping>, Mapping)),
     RightAmbiguity((Mapping, Vec<Mapping>)),
@@ -72,19 +73,20 @@ impl fmt::Display for ContigRef {
 
 impl ContigRef {
     pub fn hgvs(&self) -> Option<String> {
+        let uk = "UNKNOWN".to_string();
         match self {
             ContigRef::Unique(_) => None,
             ContigRef::Chimeric((a, b)) => {
                 if a.target_name == b.target_name {
-                    let chr = a.target_name.clone().unwrap_or("UNKNOWN".to_string());
+                    let chr = a.target_name.clone().unwrap_or(uk);
                     let del_start = a.target_end;
                     let del_end = b.target_start;
                     let hgvs = format!("{chr}:{del_start}_{del_end}");
                     Some(hgvs)
                 } else {
-                    let a_chr = a.target_name.clone().unwrap_or("UNKNOWN".to_string());
+                    let a_chr = a.target_name.clone().unwrap_or(uk);
                     let a_bp = a.target_end;
-                    let b_chr = b.target_name.clone().unwrap_or("UNKNOWN".to_string());
+                    let b_chr = b.target_name.clone().unwrap_or(uk);
                     let b_bp = b.target_end;
                     let hgvs = format!("{a_chr}:{a_bp}delins[{b_chr}:{b_bp}]");
                     Some(hgvs)
@@ -94,6 +96,45 @@ impl ContigRef {
             ContigRef::LeftAmbiguity(_) => None,
             ContigRef::RightAmbiguity(_) => None,
             ContigRef::Ambigous(_) => None,
+            ContigRef::ChimericTriple((a, b, c)) => {
+                // Insertions
+                // prioritize first len
+                let (bp_a_1, bp_a_2) = if a.query_end <= b.query_end {
+                    // TODO add inserted nt
+                    (
+                        (a.target_name.clone().unwrap_or(uk), a.target_end),
+                        (b.target_name.clone().unwrap_or(uk), b.target_start),
+                    )
+                } else {
+                    let diff = a.query_end - b.query_start;
+                    (
+                        (a.target_name.clone().unwrap_or(uk), a.target_end),
+                        (b.target_name.clone().unwrap_or(uk), b.target_start + diff),
+                    )
+                };
+                let (bp_b_1, bp_b_2) = if b.query_end <= c.query_end {
+                    // TODO add inserted nt
+                    (
+                        (b.target_name.clone().unwrap_or(uk), b.target_end),
+                        (c.target_name.clone().unwrap_or(uk), c.target_start),
+                    )
+                } else {
+                    let diff = b.query_end - c.query_start;
+                    (
+                        (b.target_name.clone().unwrap_or(uk), b.target_end),
+                        (c.target_name.clone().unwrap_or(uk), c.target_start + diff),
+                    )
+                };
+                if bp_a_1.0 == bp_b_2.0 {
+                    let hgvs = format!(
+                        "{}:{}_{}ins[{}:{}_{}]",
+                        bp_a_1.0, bp_a_1.1, bp_b_2.1, bp_a_2.0, bp_a_2.1, bp_b_1.1
+                    );
+                    Some(hgvs)
+                } else {
+                    None
+                }
+            }
         }
     }
 }
@@ -153,14 +194,16 @@ pub fn get_ref_pos(mappings: Vec<Mapping>) -> Result<ContigRef> {
                     let all: Vec<Mapping> = vec![first, last].into_iter().flat_map(|e| e).collect();
                     return Ok(ContigRef::Ambigous(all));
                 }
-            } else {
             }
             if first.len() == 1 && last.len() == 1 {
-                return Ok(ContigRef::ChimericMultiple((
-                    first.get(0).unwrap().clone(),
-                    grouped.into_iter().flat_map(|e| e).collect(),
-                    last.get(0).unwrap().clone(),
-                )));
+                if grouped.len() == 1 {
+                } else {
+                    return Ok(ContigRef::ChimericMultiple((
+                        first.get(0).unwrap().clone(),
+                        grouped.into_iter().flat_map(|e| e).collect(),
+                        last.get(0).unwrap().clone(),
+                    )));
+                }
             } else if first.len() == 1 {
                 let right: Vec<Mapping> = vec![grouped.into_iter().flat_map(|e| e).collect(), last]
                     .into_iter()