···

       
19
       
19
       
 
       


     

       
20
       
20
       
 
       
    let Ok(prefix) = fs::read_to_string(&args[1]) else {

     

       
21
       
21
       
 
       
        println!("Failed to read prefix file at {}", &args[1]);

     

       
22
       
22
       
-
       
	return;

     

       
22
       
22
       
+
       
        return;

     

       
23
       
23
       
 
       
    };

     

       
24
       
24
       
 
       
    let Ok(dna) = fs::read_to_string(&args[2]) else {

     

       
25
       
25
       
-
       
    	println!("Failed to read dna file at {}", &args[2]);

     

       
26
       
26
       
-
       
	return;

     

       
25
       
25
       
+
       
        println!("Failed to read dna file at {}", &args[2]);

     

       
26
       
26
       
+
       
        return;

     

       
27
       
27
       
 
       
    };

     

       
28
       
28
       
 
       


     

       
29
       
29
       
 
       
    let mut dna = dna::DnaRef::from_string(&prefix) + dna::DnaRef::from_string(&dna);

     

       
30
       
30
       
 
       
    let Ok(mut rna_file) = File::create(&args[3]) else {

     

       
31
       
31
       
 
       
        println!("Failed to create rna output file at {}", &args[3]);

     

       
32
       
32
       
-
       
	return;

     

       
32
       
32
       
+
       
        return;

     

       
33
       
33
       
 
       
    };

     

       
34
       
34
       
 
       
    let mut rna = Vec::new();

     

       
35
       
35
       
 
       
    loop {

     
···

       
41
       
41
       
 
       


     

       
42
       
42
       
 
       
        for r in rna.iter() {

     

       
43
       
43
       
 
       
            let rna_str: String = r.iter().map(|b| b.to_char()).collect();

     

       
44
       
44
       
-
       
	    // Just tolerate a write error.

     

       
44
       
44
       
+
       
            // Just tolerate a write error.

     

       
45
       
45
       
 
       
            let _ = rna_file.write(rna_str.as_bytes());

     

       
46
       
46
       
-
       
	    let _ = rna_file.write(b"\n");

     

       
46
       
46
       
+
       
            let _ = rna_file.write(b"\n");

     

       
47
       
47
       
 
       
        }

     

       
48
       
48
       
 
       


     

       
49
       
49
       
 
       
        rna.clear();

     

···

       
118
       
118
       
 
       
}

     

       
119
       
119
       
 
       


     

       
120
       
120
       
 
       
pub fn match_replace(dna: DnaRef, rna: &mut Vec<Rna>) -> Option<DnaRef> {

     

       
121
       
121
       
-
       
    let mut parser = Parser::new(&dna);

     

       
121
       
121
       
+
       
    let mut parser = Parser::new(dna.iter());

     

       
122
       
122
       
 
       
    let pattern = parser.pattern(rna)?;

     

       
123
       
123
       
 
       
    let template = parser.template(rna)?;

     

       
124
       
124
       
 
       
    let index = parser.index();

     

···

       
1
       
1
       
 
       
use crate::dna::Base;

     

       
2
       
2
       
-
       
use crate::dna::DnaIterator;

     

       
3
       
3
       
-
       
use crate::dna::DnaRef;

     

       
4
       
2
       
 
       
use crate::pattern::Pattern;

     

       
5
       
3
       
 
       
use crate::pattern::PatternItem;

     

       
6
       
4
       
 
       
use crate::rna::Rna;

     
···

       
8
       
6
       
 
       
use crate::template::TemplateItem;

     

       
9
       
7
       
 
       
use std::mem;

     

       
10
       
8
       
 
       


     

       
11
       
11
       
-
       
pub struct Parser<'a> {

     

       
12
       
12
       
-
       
    iter: DnaIterator<'a>,

     

       
9
       
9
       
+
       
pub struct Parser<I>

     

       
10
       
10
       
+
       
where

     

       
11
       
11
       
+
       
    I: Iterator<Item = Base>,

     

       
12
       
12
       
+
       
{

     

       
13
       
13
       
+
       
    iter: I,

     

       
13
       
14
       
 
       
    peeked: Vec<Base>,

     

       
14
       
15
       
 
       
    index: usize,

     

       
15
       
16
       
 
       
}

     

       
16
       
17
       
 
       


     

       
17
       
17
       
-
       
impl<'a> Parser<'a> {

     

       
18
       
18
       
-
       
    pub fn new(buf: &'a DnaRef) -> Parser<'a> {

     

       
18
       
18
       
+
       
impl<I> Parser<I>

     

       
19
       
19
       
+
       
where

     

       
20
       
20
       
+
       
    I: Iterator<Item = Base>,

     

       
21
       
21
       
+
       
{

     

       
22
       
22
       
+
       
    pub fn new(iter: I) -> Parser<I> {

     

       
19
       
23
       
 
       
        Parser {

     

       
20
       
20
       
-
       
            iter: buf.iter(),

     

       
24
       
24
       
+
       
            iter: iter,

     

       
21
       
25
       
 
       
            peeked: Vec::new(),

     

       
22
       
26
       
 
       
            index: 0,

     

       
23
       
27
       
 
       
        }

     
···

       
189
       
193
       
 
       
mod tests {

     

       
190
       
194
       
 
       
    use super::*;

     

       
191
       
195
       
 
       


     

       
196
       
196
       
+
       
    fn dna_from_str(s: &str) -> Vec<Base> {

     

       
197
       
197
       
+
       
        s.chars().filter_map(|c| Base::from_char(c)).collect()

     

       
198
       
198
       
+
       
    }

     

       
199
       
199
       
+
       


     

       
192
       
200
       
 
       
    #[test]

     

       
193
       
201
       
 
       
    fn test_base() {

     

       
194
       
194
       
-
       
        let dna = DnaRef::from_string("ICFP");

     

       
195
       
195
       
-
       
        let mut parser = Parser::new(&dna);

     

       
202
       
202
       
+
       
        let dna = dna_from_str("ICFP").into_iter();

     

       
203
       
203
       
+
       
        let mut parser = Parser::new(dna);

     

       
196
       
204
       
 
       
        assert!(parser.next_is(&[Base::I]));

     

       
197
       
205
       
 
       
        assert!(parser.next_is(&[Base::I, Base::C]));

     

       
198
       
206
       
 
       
        assert!(parser.next_is(&[Base::I, Base::C, Base::F]));

     
···

       
201
       
209
       
 
       


     

       
202
       
210
       
 
       
    #[test]

     

       
203
       
211
       
 
       
    fn test_nat() {

     

       
204
       
204
       
-
       
        let dna = DnaRef::from_string("CP");

     

       
205
       
205
       
-
       
        let mut parser = Parser::new(&dna);

     

       
212
       
212
       
+
       
        let dna = dna_from_str("CP").into_iter();

     

       
213
       
213
       
+
       
        let mut parser = Parser::new(dna);

     

       
206
       
214
       
 
       
        assert_eq!(parser.nat(), Some(1));

     

       
207
       
215
       
 
       
        assert_eq!(parser.index, 2);

     

       
208
       
216
       
 
       


     

       
209
       
209
       
-
       
        let dna = DnaRef::from_string("ICICP");

     

       
210
       
210
       
-
       
        let mut parser = Parser::new(&dna);

     

       
217
       
217
       
+
       
        let dna = dna_from_str("ICICP").into_iter();

     

       
218
       
218
       
+
       
        let mut parser = Parser::new(dna);

     

       
211
       
219
       
 
       
        assert_eq!(parser.nat(), Some(10));

     

       
212
       
220
       
 
       
        assert_eq!(parser.index, 5);

     

       
213
       
221
       
 
       


     

       
214
       
214
       
-
       
        let dna = DnaRef::from_string("III");

     

       
215
       
215
       
-
       
        let mut parser = Parser::new(&dna);

     

       
222
       
222
       
+
       
        let dna = dna_from_str("III").into_iter();

     

       
223
       
223
       
+
       
        let mut parser = Parser::new(dna);

     

       
216
       
224
       
 
       
        assert_eq!(parser.nat(), None);

     

       
217
       
225
       
 
       
        assert_eq!(parser.index, 3);

     

       
218
       
226
       
 
       
    }

     

       
219
       
227
       
 
       


     

       
220
       
228
       
 
       
    #[test]

     

       
221
       
229
       
 
       
    fn test_consts() {

     

       
222
       
222
       
-
       
        let dna = DnaRef::from_string("CFPICIIC");

     

       
223
       
223
       
-
       
        let mut parser = Parser::new(&dna);

     

       
230
       
230
       
+
       
        let dna = dna_from_str("CFPICIIC").into_iter();

     

       
231
       
231
       
+
       
        let mut parser = Parser::new(dna);

     

       
224
       
232
       
 
       
        assert_eq!(parser.consts(), &[Base::I, Base::C, Base::F, Base::P]);

     

       
225
       
233
       
 
       
        assert_eq!(parser.index, 5);

     

       
226
       
234
       
 
       
    }

     
···

       
229
       
237
       
 
       
    fn test_pattern() {

     

       
230
       
238
       
 
       
        let mut rna = Vec::new();

     

       
231
       
239
       
 
       


     

       
232
       
232
       
-
       
        let dna = DnaRef::from_string("CIIC");

     

       
233
       
233
       
-
       
        let mut parser = Parser::new(&dna);

     

       
240
       
240
       
+
       
        let dna = dna_from_str("CIIC").into_iter();

     

       
241
       
241
       
+
       
        let mut parser = Parser::new(dna);

     

       
234
       
242
       
 
       
        assert_eq!(

     

       
235
       
243
       
 
       
            parser.pattern(&mut rna),

     

       
236
       
244
       
 
       
            Some(vec![PatternItem::Base(Base::I)])

     

       
237
       
245
       
 
       
        );

     

       
238
       
246
       
 
       
        assert_eq!(parser.index, 4);

     

       
239
       
247
       
 
       


     

       
240
       
240
       
-
       
        let dna = DnaRef::from_string("IIPIPICPIICICIIF");

     

       
241
       
241
       
-
       
        let mut parser = Parser::new(&dna);

     

       
248
       
248
       
+
       
        let dna = dna_from_str("IIPIPICPIICICIIF").into_iter();

     

       
249
       
249
       
+
       
        let mut parser = Parser::new(dna);

     

       
242
       
250
       
 
       
        assert_eq!(

     

       
243
       
251
       
 
       
            parser.pattern(&mut rna),

     

       
244
       
252
       
 
       
            Some(vec![

     
···

       
250
       
258
       
 
       
        );

     

       
251
       
259
       
 
       
        assert_eq!(parser.index, 16);

     

       
252
       
260
       
 
       


     

       
253
       
253
       
-
       
        let dna = DnaRef::from_string("IIIPFCICFPIIC");

     

       
254
       
254
       
-
       
        let mut parser = Parser::new(&dna);

     

       
261
       
261
       
+
       
        let dna = dna_from_str("IIIPFCICFPIIC").into_iter();

     

       
262
       
262
       
+
       
        let mut parser = Parser::new(dna);

     

       
255
       
263
       
 
       
        assert_eq!(parser.pattern(&mut rna), Some(vec![]));

     

       
256
       
264
       
 
       
        assert_eq!(parser.index, 13);

     

       
257
       
265
       
 
       
        assert_eq!(

     
···

       
272
       
280
       
 
       
    fn test_template() {

     

       
273
       
281
       
 
       
        let mut rna = Vec::new();

     

       
274
       
282
       
 
       


     

       
275
       
275
       
-
       
        let dna = DnaRef::from_string("CFPICIFCPICPIIPIICPIIC");

     

       
276
       
276
       
-
       
        let mut parser = Parser::new(&dna);

     

       
283
       
283
       
+
       
        let dna = dna_from_str("CFPICIFCPICPIIPIICPIIC").into_iter();

     

       
284
       
284
       
+
       
        let mut parser = Parser::new(dna);

     

       
277
       
285
       
 
       
        assert_eq!(

     

       
278
       
286
       
 
       
            parser.template(&mut rna),

     

       
279
       
287
       
 
       
            Some(vec![

     
···

       
287
       
295
       
 
       
        );

     

       
288
       
296
       
 
       
        assert_eq!(parser.index, 22);

     

       
289
       
297
       
 
       


     

       
290
       
290
       
-
       
        let dna = DnaRef::from_string("IIIPFCICFPIIC");

     

       
291
       
291
       
-
       
        let mut parser = Parser::new(&dna);

     

       
298
       
298
       
+
       
        let dna = dna_from_str("IIIPFCICFPIIC").into_iter();

     

       
299
       
299
       
+
       
        let mut parser = Parser::new(dna);

     

       
292
       
300
       
 
       
        assert_eq!(parser.template(&mut rna), Some(vec![]));

     

       
293
       
301
       
 
       
        assert_eq!(parser.index, 13);

     

       
294
       
302
       
 
       
        assert_eq!(