use super::*;
pub(super) const MOD_TAGS: [Tag; 3] = [
Tag::BASE_MODIFICATIONS,
Tag::BASE_MODIFICATION_PROBABILITIES,
Tag::BASE_MODIFICATION_SEQUENCE_LENGTH,
];
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum ModBlock {
Absent,
Consistent,
MissingMn,
Malformed,
}
pub(super) fn classify_mod_block(
mm: &[u8],
ml: Option<Option<usize>>,
mn: Option<Option<i64>>,
seq_len: usize,
) -> ModBlock {
let Some(expected) = mods::expected_ml_len(mm) else {
return ModBlock::Malformed;
};
match ml {
Some(None) => return ModBlock::Malformed,
Some(Some(len)) if len != expected => return ModBlock::Malformed,
_ => {},
}
match mn {
None => ModBlock::MissingMn,
Some(Some(n)) if i64::try_from(seq_len).ok() == Some(n) => ModBlock::Consistent,
Some(_) => ModBlock::Malformed,
}
}
pub(super) fn mod_tags(src: &RecordBuf) -> Option<(&[u8], Option<&[u8]>)> {
let mm: &[u8] = match src.data().get(&Tag::BASE_MODIFICATIONS) {
Some(Value::String(s)) => AsRef::<[u8]>::as_ref(s),
_ => return None,
};
let ml = match src.data().get(&Tag::BASE_MODIFICATION_PROBABILITIES) {
Some(Value::Array(Array::UInt8(v))) => Some(v.as_slice()),
_ => None,
};
Some((mm, ml))
}
pub(crate) fn inspect_mod_block(src: &RecordBuf, seq_len: usize) -> ModBlock {
let Some((mm, _)) = mod_tags(src) else {
return ModBlock::Absent;
};
let ml = src
.data()
.get(&Tag::BASE_MODIFICATION_PROBABILITIES)
.map(|v| match v {
Value::Array(Array::UInt8(a)) => Some(a.len()),
_ => None,
});
let mn = src
.data()
.get(&Tag::BASE_MODIFICATION_SEQUENCE_LENGTH)
.map(aux_integer);
let block = classify_mod_block(mm, ml, mn, seq_len);
if block != ModBlock::Malformed
&& !mods::parse::positions_valid(mm, src.sequence().as_ref().iter().copied())
{
ModBlock::Malformed
} else {
block
}
}
pub(super) fn rebuild_mods(
mm: &[u8],
ml: Option<&[u8]>,
seq: &[u8],
start: usize,
end: usize,
indexed: Option<&IndexedMods>,
) -> (Vec<u8>, Option<Vec<u8>>) {
if start == 0 && end == seq.len() {
return (mm.to_vec(), ml.map(<[u8]>::to_vec));
}
let sliced = match indexed {
Some(indexed) => indexed.window(start, end),
None => mods::reconstruct(&mods::parse(mm, ml.unwrap_or(&[])), seq, start, end),
};
let (mm, probabilities) = mods::serialize(&sliced);
(mm, ml.map(|_| probabilities))
}