commit f1bfe6734db80c7482e9ec331e9f7399f5acc016 · drubery.com/icfp2007

+2 -3

dna2rna/src/main.rs

···

       1
       1
        
       mod dna;

     

       2
       2
        
       mod parser;

     

       3
       3
        
       mod pattern;

     

       4
       4
       -
       

     

       5
       5
       -
       use crate::dna::*;

     

       4
       4
       +
       mod template;

     

       6
       5
        
       

     

       7
       6
        
       fn main() {

     

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

     

       7
       7
       +
           let dna = dna::DnaRef::from_string("ICFP");

     

       9
       8
        
           println!("Back to string: {}", dna.to_string());

     

       10
       9
        
       }

+62 -2

dna2rna/src/parser.rs

···

       1
       1
       -
       use crate::Base;

     

       2
       2
       -
       use crate::DnaRef;

     

       1
       1
       +
       use crate::dna::Base;

     

       2
       2
       +
       use crate::dna::DnaRef;

     

       3
       3
        
       use crate::pattern::Pattern;

     

       4
       4
        
       use crate::pattern::PatternItem;

     

       5
       5
       +
       use crate::template::Template;

     

       6
       6
       +
       use crate::template::TemplateItem;

     

       5
       7
        
       

     

       6
       8
        
       struct Parser<'a> {

     

       7
       9
        
           buf: &'a DnaRef,

     
···

       113
       115
        
                   }

     

       114
       116
        
               }

     

       115
       117
        
           }

     

       118
       118
       +
       

     

       119
       119
       +
           pub fn template(&mut self) -> Option<Template> {

     

       120
       120
       +
               let mut ret = Vec::new();

     

       121
       121
       +
               loop {

     

       122
       122
       +
                   if self.next_is(&[Base::C]) {

     

       123
       123
       +
                       self.index += 1;

     

       124
       124
       +
                       ret.push(TemplateItem::Base(Base::I));

     

       125
       125
       +
                   } else if self.next_is(&[Base::F]) {

     

       126
       126
       +
                       self.index += 1;

     

       127
       127
       +
                       ret.push(TemplateItem::Base(Base::C));

     

       128
       128
       +
                   } else if self.next_is(&[Base::P]) {

     

       129
       129
       +
                       self.index += 1;

     

       130
       130
       +
                       ret.push(TemplateItem::Base(Base::F));

     

       131
       131
       +
                   } else if self.next_is(&[Base::I, Base::C]) {

     

       132
       132
       +
                       self.index += 2;

     

       133
       133
       +
                       ret.push(TemplateItem::Base(Base::P));

     

       134
       134
       +
                   } else if self.next_is(&[Base::I, Base::P]) || self.next_is(&[Base::I, Base::F]) {

     

       135
       135
       +
                       self.index += 2;

     

       136
       136
       +
                       let l = self.nat()?;

     

       137
       137
       +
                       let n = self.nat()?;

     

       138
       138
       +
                       ret.push(TemplateItem::Ref(n, l));

     

       139
       139
       +
                   } else if self.next_is(&[Base::I, Base::I, Base::C])

     

       140
       140
       +
                       || self.next_is(&[Base::I, Base::I, Base::F])

     

       141
       141
       +
                   {

     

       142
       142
       +
                       self.index += 3;

     

       143
       143
       +
                       return Some(ret);

     

       144
       144
       +
                   } else if self.next_is(&[Base::I, Base::I, Base::P]) {

     

       145
       145
       +
                       self.index += 3;

     

       146
       146
       +
                       let n = self.nat()?;

     

       147
       147
       +
                       ret.push(TemplateItem::Len(n));

     

       148
       148
       +
                   } else if self.next_is(&[Base::I, Base::I, Base::I]) {

     

       149
       149
       +
                       self.index += 10;

     

       150
       150
       +
                       // TODO: RNA output

     

       151
       151
       +
                   } else {

     

       152
       152
       +
                       return None;

     

       153
       153
       +
                   }

     

       154
       154
       +
               }

     

       155
       155
       +
           }

     

       116
       156
        
       }

     

       117
       157
        
       

     

       118
       158
        
       #[cfg(test)]

     
···

       160
       200
        
               let dna = DnaRef::from_string("CIIC");

     

       161
       201
        
               let mut parser = Parser::new(&dna);

     

       162
       202
        
               assert_eq!(parser.pattern(), Some(vec![PatternItem::Base(Base::I)]));

     

       203
       203
       +
               assert_eq!(parser.ijndex, 4);

     

       163
       204
        
       

     

       164
       205
        
               let dna = DnaRef::from_string("IIPIPICPIICICIIF");

     

       165
       206
        
               let mut parser = Parser::new(&dna);

     
···

       172
       213
        
                       PatternItem::Base(Base::P)

     

       173
       214
        
                   ])

     

       174
       215
        
               );

     

       216
       216
       +
               assert_eq!(parser.index, 16);

     

       217
       217
       +
           }

     

       218
       218
       +
       

     

       219
       219
       +
           #[test]

     

       220
       220
       +
           fn test_template() {

     

       221
       221
       +
               let dna = DnaRef::from_string("CFPICIFCPICPIIPIICPIIC");

     

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

     

       223
       223
       +
               assert_eq!(

     

       224
       224
       +
                   parser.template(),

     

       225
       225
       +
                   Some(vec![

     

       226
       226
       +
                       TemplateItem::Base(Base::I),

     

       227
       227
       +
                       TemplateItem::Base(Base::C),

     

       228
       228
       +
                       TemplateItem::Base(Base::F),

     

       229
       229
       +
                       TemplateItem::Base(Base::P),

     

       230
       230
       +
                       TemplateItem::Ref(2, 1),

     

       231
       231
       +
                       TemplateItem::Len(4)

     

       232
       232
       +
                   ])

     

       233
       233
       +
               );

     

       234
       234
       +
               assert_eq!(parser.index, 22);

     

       175
       235
        
           }

     

       176
       236
        
       }

+1 -1

dna2rna/src/pattern.rs

···

       1
       1
       -
       use crate::Base;

     

       1
       1
       +
       use crate::dna::Base;

     

       2
       2
        
       

     

       3
       3
        
       #[derive(Debug, PartialEq)]

     

       4
       4
        
       pub enum PatternItem {

+10

dna2rna/src/template.rs

···

       1
       1
       +
       use crate::dna::Base;

     

       2
       2
       +
       

     

       3
       3
       +
       #[derive(Debug, PartialEq)]

     

       4
       4
       +
       pub enum TemplateItem {

     

       5
       5
       +
           Base(Base),

     

       6
       6
       +
           Ref(usize, usize),

     

       7
       7
       +
           Len(usize),

     

       8
       8
       +
       }

     

       9
       9
       +
       

     

       10
       10
       +
       pub type Template = Vec<TemplateItem>;