use std::alloc::{Layout, alloc_zeroed, handle_alloc_error};
use std::os::raw::c_int;
use crate::bitmap::set;
use crate::node::RBS_MASKS_PER_NODE;
use crate::sequence::rcom_seq;
use crate::types::{Gene, MASK_SIZE, MAX_GENES, MAX_MASKS, MAX_SEQ, Mask, Node, STT_NOD};
pub(crate) struct SequenceBuffer {
pub seq: Vec<u8>,
pub rseq: Vec<u8>,
pub useq: Vec<u8>,
pub nodes: Vec<Node>,
pub genes: Vec<Gene>,
pub masks: Vec<Mask>,
pub rbs_masks: Vec<u32>,
pub forward_mers: Vec<u16>,
pub reverse_mers: Vec<u16>,
pub nmask: c_int,
prev_len: usize,
prev_nn: usize,
}
impl SequenceBuffer {
#[allow(dead_code)]
pub fn new() -> Self {
Self::with_base_capacity(MAX_SEQ)
}
pub fn with_base_capacity(max_bases: usize) -> Self {
let max_bases = max_bases.min(MAX_SEQ);
let seq_bytes = (max_bases / 4 + 2).max(1);
let useq_bytes = (max_bases / 8 + 2).max(1);
SequenceBuffer {
seq: vec![0u8; seq_bytes],
rseq: vec![0u8; seq_bytes],
useq: vec![0u8; useq_bytes],
nodes: zeroed_vec(STT_NOD),
genes: zeroed_vec(MAX_GENES),
masks: zeroed_vec(MAX_MASKS),
rbs_masks: Vec::new(),
forward_mers: Vec::new(),
reverse_mers: Vec::new(),
nmask: 0,
prev_len: 0,
prev_nn: 0,
}
}
pub fn reusable() -> Self {
Self::with_base_capacity(0)
}
pub fn mark_nodes(&mut self, nn: c_int) {
self.prev_nn = (nn.max(0) as usize).min(self.nodes.len());
}
fn prepare(&mut self, dna_len: usize) {
let max_bases = dna_len.min(MAX_SEQ);
let seq_bytes = (max_bases / 4 + 2).max(1);
let useq_bytes = (max_bases / 8 + 2).max(1);
if self.seq.len() < seq_bytes {
self.seq.resize(seq_bytes, 0);
self.rseq.resize(seq_bytes, 0);
}
if self.useq.len() < useq_bytes {
self.useq.resize(useq_bytes, 0);
}
self.clear_seq(self.prev_len);
for i in 0..self.prev_nn {
self.nodes[i] = unsafe { std::mem::zeroed() };
}
self.prev_nn = 0;
}
fn clear_seq(&mut self, prev_len: usize) {
let seq_bytes = (prev_len / 4 + 1).min(self.seq.len());
let useq_bytes = (prev_len / 8 + 1).min(self.useq.len());
self.seq[..seq_bytes].fill(0);
self.rseq[..seq_bytes].fill(0);
self.useq[..useq_bytes].fill(0);
self.nmask = 0;
}
pub unsafe fn encode(&mut self, dna: &[u8], do_mask: bool) -> (c_int, f64) {
self.prepare(dna.len());
let mut bctr: c_int = 0;
let mut len: c_int = 0;
let mut gc_count: c_int = 0;
let mut mask_beg: c_int = -1;
for &base in dna {
if base < b'A' || base > b'z' {
continue;
}
if do_mask && mask_beg != -1 && base != b'N' && base != b'n' {
if len - mask_beg >= MASK_SIZE as c_int {
if (self.nmask as usize) < MAX_MASKS {
self.masks[self.nmask as usize].begin = mask_beg;
self.masks[self.nmask as usize].end = len - 1;
self.nmask += 1;
}
}
mask_beg = -1;
}
if do_mask && mask_beg == -1 && (base == b'N' || base == b'n') {
mask_beg = len;
}
match base {
b'g' | b'G' => {
set(self.seq.as_mut_ptr(), bctr);
gc_count += 1;
}
b't' | b'T' => {
set(self.seq.as_mut_ptr(), bctr);
set(self.seq.as_mut_ptr(), bctr + 1);
}
b'c' | b'C' => {
set(self.seq.as_mut_ptr(), bctr + 1);
gc_count += 1;
}
b'a' | b'A' => { }
_ => {
set(self.seq.as_mut_ptr(), bctr + 1);
set(self.useq.as_mut_ptr(), len);
}
}
bctr += 2;
len += 1;
}
if len > 0 {
rcom_seq(
self.seq.as_mut_ptr(),
self.rseq.as_mut_ptr(),
self.useq.as_mut_ptr(),
len,
);
}
let gc = if len > 0 {
gc_count as f64 / len as f64
} else {
0.0
};
self.prev_len = len as usize;
(len, gc)
}
pub unsafe fn encode_training(&mut self, sequences: &[&[u8]], do_mask: bool) -> (c_int, f64) {
self.clear_seq(self.seq.len() * 4);
let mut bctr: c_int = 0;
let mut len: c_int = 0;
let mut gc_count: c_int = 0;
let mut mask_beg: c_int = -1;
let mut seq_count = 0;
for &seq_data in sequences {
if seq_count > 0 {
for i in 0..12 {
if i % 4 == 0 || i % 4 == 1 {
set(self.seq.as_mut_ptr(), bctr);
set(self.seq.as_mut_ptr(), bctr + 1);
}
bctr += 2;
len += 1;
}
}
seq_count += 1;
for &base in seq_data {
if base < b'A' || base > b'z' {
continue;
}
if do_mask && mask_beg != -1 && base != b'N' && base != b'n' {
if len - mask_beg >= MASK_SIZE as c_int {
if (self.nmask as usize) < MAX_MASKS {
self.masks[self.nmask as usize].begin = mask_beg;
self.masks[self.nmask as usize].end = len - 1;
self.nmask += 1;
}
}
mask_beg = -1;
}
if do_mask && mask_beg == -1 && (base == b'N' || base == b'n') {
mask_beg = len;
}
match base {
b'g' | b'G' => {
set(self.seq.as_mut_ptr(), bctr);
gc_count += 1;
}
b't' | b'T' => {
set(self.seq.as_mut_ptr(), bctr);
set(self.seq.as_mut_ptr(), bctr + 1);
}
b'c' | b'C' => {
set(self.seq.as_mut_ptr(), bctr + 1);
gc_count += 1;
}
b'a' | b'A' => {}
_ => {
set(self.seq.as_mut_ptr(), bctr + 1);
set(self.useq.as_mut_ptr(), len);
}
}
bctr += 2;
len += 1;
if (len as usize) + 10000 >= MAX_SEQ {
break;
}
}
}
if seq_count > 1 {
for i in 0..12 {
if i % 4 == 0 || i % 4 == 1 {
set(self.seq.as_mut_ptr(), bctr);
set(self.seq.as_mut_ptr(), bctr + 1);
}
bctr += 2;
len += 1;
}
}
if len > 0 {
rcom_seq(
self.seq.as_mut_ptr(),
self.rseq.as_mut_ptr(),
self.useq.as_mut_ptr(),
len,
);
}
let gc = if len > 0 {
gc_count as f64 / len as f64
} else {
0.0
};
self.prev_len = len as usize;
(len, gc)
}
pub fn ensure_node_capacity(&mut self, slen: c_int) {
let needed = (slen as usize) / 8;
if needed > self.nodes.len() {
let mut grown: Vec<Node> = zeroed_vec(needed);
grown[..self.nodes.len()].copy_from_slice(&self.nodes);
self.nodes = grown;
}
}
pub fn ensure_rbs_capacity(&mut self, nn: c_int) {
let needed = (nn.max(0) as usize) * RBS_MASKS_PER_NODE;
if self.rbs_masks.len() < needed {
self.rbs_masks.resize(needed, 0);
}
}
pub fn clear_nodes(&mut self, nn: c_int) {
let dirty = (nn.max(0) as usize).max(self.prev_nn).min(self.nodes.len());
unsafe { std::ptr::write_bytes(self.nodes.as_mut_ptr(), 0, dirty) };
self.prev_nn = 0;
}
}
fn zeroed_vec<T>(count: usize) -> Vec<T> {
if count == 0 {
return Vec::new();
}
let layout = Layout::array::<T>(count).expect("scratch buffer fits in memory");
unsafe {
let ptr = alloc_zeroed(layout) as *mut T;
if ptr.is_null() {
handle_alloc_error(layout);
}
Vec::from_raw_parts(ptr, count, count)
}
}