compact_genome/implementation/
vec_sequence.rs

1//! A simple representation of a genome as `Vec<u8>`.
2
3use std::borrow::Borrow;
4use std::ops::{
5    Index, IndexMut, Range, RangeFrom, RangeFull, RangeInclusive, RangeTo, RangeToInclusive,
6};
7//use std::marker::PhantomData;
8use crate::interface::alphabet::Alphabet;
9use crate::interface::sequence::{
10    EditableGenomeSequence, GenomeSequence, GenomeSequenceMut, OwnedGenomeSequence,
11};
12use ref_cast::RefCast;
13use traitsequence::interface::{EditableSequence, OwnedSequence, Sequence, SequenceMut};
14
15/// A genome sequence stored as vector of plain characters.
16#[derive(Debug, Clone, Eq, PartialEq, Hash, Ord, PartialOrd)]
17pub struct VectorGenome<AlphabetType: Alphabet> {
18    vector: Vec<AlphabetType::CharacterType>,
19}
20
21/// The subsequence of a genome sequence stored as slice of plain characters.
22#[derive(RefCast, Debug, Eq, PartialEq, Hash)]
23#[repr(transparent)]
24pub struct SliceSubGenome<AlphabetType: Alphabet> {
25    //phantom_data: PhantomData<AlphabetType>,
26    pub(crate) slice: [AlphabetType::CharacterType],
27}
28
29impl<AlphabetType: Alphabet> GenomeSequence<AlphabetType, SliceSubGenome<AlphabetType>>
30    for VectorGenome<AlphabetType>
31{
32    fn as_genome_subsequence(&self) -> &SliceSubGenome<AlphabetType> {
33        SliceSubGenome::ref_cast(&self.vector[..])
34    }
35}
36
37impl<AlphabetType: Alphabet> GenomeSequenceMut<AlphabetType, SliceSubGenome<AlphabetType>>
38    for VectorGenome<AlphabetType>
39{
40}
41
42impl<AlphabetType: Alphabet> OwnedGenomeSequence<AlphabetType, SliceSubGenome<AlphabetType>>
43    for VectorGenome<AlphabetType>
44{
45}
46
47impl<AlphabetType: Alphabet> EditableGenomeSequence<AlphabetType, SliceSubGenome<AlphabetType>>
48    for VectorGenome<AlphabetType>
49{
50}
51
52impl<AlphabetType: Alphabet> GenomeSequence<AlphabetType, SliceSubGenome<AlphabetType>>
53    for SliceSubGenome<AlphabetType>
54{
55}
56
57impl<AlphabetType: Alphabet> GenomeSequenceMut<AlphabetType, SliceSubGenome<AlphabetType>>
58    for SliceSubGenome<AlphabetType>
59{
60}
61
62impl<AlphabetType: Alphabet> Sequence<AlphabetType::CharacterType, SliceSubGenome<AlphabetType>>
63    for VectorGenome<AlphabetType>
64{
65    type Iterator<'a>
66        = std::slice::Iter<'a, AlphabetType::CharacterType>
67    where
68        AlphabetType: 'a;
69
70    fn iter(&self) -> Self::Iterator<'_> {
71        self.as_genome_subsequence().iter()
72    }
73
74    fn len(&self) -> usize {
75        self.as_genome_subsequence().len()
76    }
77}
78
79impl<AlphabetType: Alphabet> Sequence<AlphabetType::CharacterType, SliceSubGenome<AlphabetType>>
80    for SliceSubGenome<AlphabetType>
81{
82    type Iterator<'a>
83        = std::slice::Iter<'a, AlphabetType::CharacterType>
84    where
85        AlphabetType: 'a;
86
87    fn iter(&self) -> Self::Iterator<'_> {
88        self.slice.iter()
89    }
90
91    fn len(&self) -> usize {
92        self.slice.len()
93    }
94}
95
96impl<AlphabetType: Alphabet>
97    EditableSequence<AlphabetType::CharacterType, SliceSubGenome<AlphabetType>>
98    for VectorGenome<AlphabetType>
99{
100    fn split_off(&mut self, at: usize) -> Self {
101        Self {
102            vector: self.vector.split_off(at),
103        }
104    }
105
106    fn set(&mut self, index: usize, item: AlphabetType::CharacterType) {
107        self.vector.set(index, item)
108    }
109
110    fn reserve(&mut self, additional: usize) {
111        self.vector.reserve(additional)
112    }
113
114    fn resize(&mut self, new_len: usize, value: AlphabetType::CharacterType)
115    where
116        AlphabetType::CharacterType: Clone,
117    {
118        self.vector.resize(new_len, value)
119    }
120
121    fn resize_with(
122        &mut self,
123        new_len: usize,
124        generator: impl FnMut() -> AlphabetType::CharacterType,
125    ) {
126        self.vector.resize_with(new_len, generator);
127    }
128
129    fn push(&mut self, item: AlphabetType::CharacterType) {
130        self.vector.push(item)
131    }
132
133    fn splice(
134        &mut self,
135        range: Range<usize>,
136        replace_with: impl IntoIterator<Item = AlphabetType::CharacterType>,
137    ) {
138        self.vector.splice(range, replace_with);
139    }
140}
141
142impl<AlphabetType: Alphabet> Index<Range<usize>> for VectorGenome<AlphabetType> {
143    type Output = SliceSubGenome<AlphabetType>;
144
145    fn index(&self, index: Range<usize>) -> &Self::Output {
146        self.as_genome_subsequence().index(index)
147    }
148}
149
150impl<AlphabetType: Alphabet> Index<RangeFrom<usize>> for VectorGenome<AlphabetType> {
151    type Output = SliceSubGenome<AlphabetType>;
152
153    fn index(&self, index: RangeFrom<usize>) -> &Self::Output {
154        self.as_genome_subsequence().index(index)
155    }
156}
157
158impl<AlphabetType: Alphabet> Index<RangeTo<usize>> for VectorGenome<AlphabetType> {
159    type Output = SliceSubGenome<AlphabetType>;
160
161    fn index(&self, index: RangeTo<usize>) -> &Self::Output {
162        self.as_genome_subsequence().index(index)
163    }
164}
165
166impl<AlphabetType: Alphabet> Index<RangeFull> for VectorGenome<AlphabetType> {
167    type Output = SliceSubGenome<AlphabetType>;
168
169    fn index(&self, index: RangeFull) -> &Self::Output {
170        self.as_genome_subsequence().index(index)
171    }
172}
173
174impl<AlphabetType: Alphabet> Index<RangeInclusive<usize>> for VectorGenome<AlphabetType> {
175    type Output = SliceSubGenome<AlphabetType>;
176
177    fn index(&self, index: RangeInclusive<usize>) -> &Self::Output {
178        self.as_genome_subsequence().index(index)
179    }
180}
181
182impl<AlphabetType: Alphabet> Index<RangeToInclusive<usize>> for VectorGenome<AlphabetType> {
183    type Output = SliceSubGenome<AlphabetType>;
184
185    fn index(&self, index: RangeToInclusive<usize>) -> &Self::Output {
186        self.as_genome_subsequence().index(index)
187    }
188}
189
190impl<AlphabetType: Alphabet> Index<usize> for VectorGenome<AlphabetType> {
191    type Output = AlphabetType::CharacterType;
192
193    fn index(&self, index: usize) -> &Self::Output {
194        self.as_genome_subsequence().index(index)
195    }
196}
197
198impl<AlphabetType: Alphabet> Index<Range<usize>> for SliceSubGenome<AlphabetType> {
199    type Output = SliceSubGenome<AlphabetType>;
200
201    fn index(&self, index: Range<usize>) -> &Self::Output {
202        SliceSubGenome::ref_cast(&self.slice[index.start..index.end])
203    }
204}
205
206impl<AlphabetType: Alphabet> Index<RangeFrom<usize>> for SliceSubGenome<AlphabetType> {
207    type Output = SliceSubGenome<AlphabetType>;
208
209    fn index(&self, index: RangeFrom<usize>) -> &Self::Output {
210        self.index(index.start..self.len())
211    }
212}
213
214impl<AlphabetType: Alphabet> Index<RangeTo<usize>> for SliceSubGenome<AlphabetType> {
215    type Output = SliceSubGenome<AlphabetType>;
216
217    fn index(&self, index: RangeTo<usize>) -> &Self::Output {
218        self.index(0..index.end)
219    }
220}
221
222impl<AlphabetType: Alphabet> Index<RangeFull> for SliceSubGenome<AlphabetType> {
223    type Output = SliceSubGenome<AlphabetType>;
224
225    fn index(&self, _index: RangeFull) -> &Self::Output {
226        self.index(0..self.len())
227    }
228}
229
230impl<AlphabetType: Alphabet> Index<RangeInclusive<usize>> for SliceSubGenome<AlphabetType> {
231    type Output = SliceSubGenome<AlphabetType>;
232
233    fn index(&self, index: RangeInclusive<usize>) -> &Self::Output {
234        SliceSubGenome::ref_cast(&self.slice[*index.start()..=*index.end()])
235    }
236}
237
238impl<AlphabetType: Alphabet> Index<RangeToInclusive<usize>> for SliceSubGenome<AlphabetType> {
239    type Output = SliceSubGenome<AlphabetType>;
240
241    fn index(&self, index: RangeToInclusive<usize>) -> &Self::Output {
242        self.index(0..=index.end)
243    }
244}
245
246impl<AlphabetType: Alphabet> Index<usize> for SliceSubGenome<AlphabetType> {
247    type Output = AlphabetType::CharacterType;
248
249    fn index(&self, index: usize) -> &Self::Output {
250        self.slice.index(index)
251    }
252}
253
254impl<AlphabetType: Alphabet> FromIterator<AlphabetType::CharacterType>
255    for VectorGenome<AlphabetType>
256{
257    fn from_iter<T: IntoIterator<Item = AlphabetType::CharacterType>>(iter: T) -> Self {
258        let mut result = Self::default();
259        result.extend(iter);
260        result
261    }
262}
263
264impl<AlphabetType: Alphabet> Extend<AlphabetType::CharacterType> for VectorGenome<AlphabetType> {
265    fn extend<T: IntoIterator<Item = AlphabetType::CharacterType>>(&mut self, iter: T) {
266        self.vector.extend(iter)
267    }
268}
269
270impl<AlphabetType: Alphabet> IntoIterator for VectorGenome<AlphabetType> {
271    type Item = AlphabetType::CharacterType;
272    type IntoIter = std::vec::IntoIter<Self::Item>;
273
274    fn into_iter(self) -> Self::IntoIter {
275        self.vector.into_iter()
276    }
277}
278
279impl<AlphabetType: Alphabet> Borrow<SliceSubGenome<AlphabetType>> for VectorGenome<AlphabetType> {
280    fn borrow(&self) -> &SliceSubGenome<AlphabetType> {
281        self.as_genome_subsequence()
282    }
283}
284
285impl<AlphabetType: Alphabet> ToOwned for SliceSubGenome<AlphabetType> {
286    type Owned = VectorGenome<AlphabetType>;
287
288    fn to_owned(&self) -> Self::Owned {
289        self.iter().cloned().collect()
290    }
291}
292
293impl<AlphabetType: Alphabet> SequenceMut<AlphabetType::CharacterType, SliceSubGenome<AlphabetType>>
294    for VectorGenome<AlphabetType>
295{
296    type IteratorMut<'a>
297        = std::slice::IterMut<'a, AlphabetType::CharacterType>
298    where
299        AlphabetType: 'a;
300
301    fn iter_mut(&mut self) -> Self::IteratorMut<'_> {
302        self.vector.iter_mut()
303    }
304}
305
306impl<AlphabetType: Alphabet> IndexMut<usize> for VectorGenome<AlphabetType> {
307    fn index_mut(&mut self, index: usize) -> &mut Self::Output {
308        self.vector.index_mut(index)
309    }
310}
311
312impl<AlphabetType: Alphabet> IndexMut<Range<usize>> for VectorGenome<AlphabetType> {
313    fn index_mut(&mut self, index: Range<usize>) -> &mut Self::Output {
314        SliceSubGenome::ref_cast_mut(&mut self.vector[index])
315    }
316}
317
318impl<AlphabetType: Alphabet> SequenceMut<AlphabetType::CharacterType, SliceSubGenome<AlphabetType>>
319    for SliceSubGenome<AlphabetType>
320{
321    type IteratorMut<'a>
322        = std::slice::IterMut<'a, AlphabetType::CharacterType>
323    where
324        AlphabetType: 'a;
325
326    fn iter_mut(&mut self) -> Self::IteratorMut<'_> {
327        self.slice.iter_mut()
328    }
329}
330
331impl<AlphabetType: Alphabet> IndexMut<usize> for SliceSubGenome<AlphabetType> {
332    fn index_mut(&mut self, index: usize) -> &mut Self::Output {
333        self.slice.index_mut(index)
334    }
335}
336
337impl<AlphabetType: Alphabet> IndexMut<Range<usize>> for SliceSubGenome<AlphabetType> {
338    fn index_mut(&mut self, index: Range<usize>) -> &mut Self::Output {
339        SliceSubGenome::ref_cast_mut(&mut self.slice[index])
340    }
341}
342
343impl<AlphabetType: Alphabet> Default for VectorGenome<AlphabetType> {
344    fn default() -> Self {
345        Self {
346            vector: Default::default(),
347        }
348    }
349}
350
351impl<AlphabetType: Alphabet>
352    OwnedSequence<AlphabetType::CharacterType, SliceSubGenome<AlphabetType>>
353    for VectorGenome<AlphabetType>
354{
355}
356
357impl<AlphabetType: Alphabet> VectorGenome<AlphabetType> {
358    /// Converts the `VectorGenome` to its inner data vector.
359    pub fn into_inner(self) -> Vec<AlphabetType::CharacterType> {
360        self.vector
361    }
362}
363
364impl<AlphabetType: Alphabet> From<VectorGenome<AlphabetType>> for Vec<AlphabetType::CharacterType> {
365    fn from(genome: VectorGenome<AlphabetType>) -> Self {
366        genome.into_inner()
367    }
368}
369
370#[cfg(test)]
371mod tests {
372    use crate::implementation::alphabets::dna_alphabet::DnaAlphabet;
373    use crate::implementation::vec_sequence::VectorGenome;
374    use crate::interface::sequence::{GenomeSequence, OwnedGenomeSequence};
375
376    #[test]
377    fn test_reverse_complement() {
378        let genome = VectorGenome::<DnaAlphabet>::from_slice_u8(b"ATTCGGT").unwrap();
379        let reverse_complement = VectorGenome::<DnaAlphabet>::from_slice_u8(b"ACCGAAT").unwrap();
380        debug_assert_eq!(genome.clone_as_reverse_complement(), reverse_complement);
381        debug_assert_eq!(genome, reverse_complement.clone_as_reverse_complement());
382    }
383
384    #[test]
385    fn test_display() {
386        let genome = VectorGenome::<DnaAlphabet>::from_slice_u8(b"ATTCGGT").unwrap();
387        let display_string = genome.as_string();
388        let expected_string = "ATTCGGT";
389        debug_assert_eq!(display_string, expected_string);
390    }
391}
compact_genome/implementation/vec_sequence.rs

compact_genome/implementation/
vec_sequence.rs
