rust_list_types/src/implementation.rs

0001 #![allow(unused_imports)]
0002 #![allow(unused_variables)]
0003 #![allow(dead_code)]
0004 use interface::*;
0005
0006 #[derive(Default, Clone)]
0007 struct ListItem {
0008     boolean: bool,
0009     optional_boolean: Option<bool>,
0010     i8: i8,
0011     u8: u8,
0012     i16: i16,
0013     u16: u16,
0014     i32: i32,
0015     u32: u32,
0016     i64: i64,
0017     u64: u64,
0018     f32: f32,
0019     f64: f64,
0020     bytearray: Vec<u8>,
0021     optional_bytearray: Option<Vec<u8>>,
0022     string: String,
0023     optional_string: Option<String>,
0024 }
0025
0026 pub struct List {
0027     emit: ListEmitter,
0028     model: ListList,
0029     list: Vec<ListItem>,
0030 }
0031
0032 impl ListTrait for List {
0033     fn new(emit: ListEmitter, model: ListList) -> List {
0034         List {
0035             emit: emit,
0036             model: model,
0037             list: vec![ListItem::default(); 10],
0038         }
0039     }
0040     fn emit(&mut self) -> &mut ListEmitter {
0041         &mut self.emit
0042     }
0043     fn row_count(&self) -> usize {
0044         self.list.len()
0045     }
0046     fn boolean(&self, index: usize) -> bool {
0047         self.list[index].boolean
0048     }
0049     fn set_boolean(&mut self, index: usize, v: bool) -> bool {
0050         self.list[index].boolean = v;
0051         true
0052     }
0053     fn optional_boolean(&self, index: usize) -> Option<bool> {
0054         self.list[index].optional_boolean
0055     }
0056     fn set_optional_boolean(&mut self, index: usize, v: Option<bool>) -> bool {
0057         self.list[index].optional_boolean = v;
0058         true
0059     }
0060     fn i8(&self, index: usize) -> i8 {
0061         self.list[index].i8
0062     }
0063     fn set_i8(&mut self, index: usize, v: i8) -> bool {
0064         self.list[index].i8 = v;
0065         true
0066     }
0067     fn u8(&self, index: usize) -> u8 {
0068         self.list[index].u8
0069     }
0070     fn set_u8(&mut self, index: usize, v: u8) -> bool {
0071         self.list[index].u8 = v;
0072         true
0073     }
0074     fn i16(&self, index: usize) -> i16 {
0075         self.list[index].i16
0076     }
0077     fn set_i16(&mut self, index: usize, v: i16) -> bool {
0078         self.list[index].i16 = v;
0079         true
0080     }
0081     fn u16(&self, index: usize) -> u16 {
0082         self.list[index].u16
0083     }
0084     fn set_u16(&mut self, index: usize, v: u16) -> bool {
0085         self.list[index].u16 = v;
0086         true
0087     }
0088     fn i32(&self, index: usize) -> i32 {
0089         self.list[index].i32
0090     }
0091     fn set_i32(&mut self, index: usize, v: i32) -> bool {
0092         self.list[index].i32 = v;
0093         true
0094     }
0095     fn u32(&self, index: usize) -> u32 {
0096         self.list[index].u32
0097     }
0098     fn set_u32(&mut self, index: usize, v: u32) -> bool {
0099         self.list[index].u32 = v;
0100         true
0101     }
0102     fn i64(&self, index: usize) -> i64 {
0103         self.list[index].i64
0104     }
0105     fn set_i64(&mut self, index: usize, v: i64) -> bool {
0106         self.list[index].i64 = v;
0107         true
0108     }
0109     fn u64(&self, index: usize) -> u64 {
0110         self.list[index].u64
0111     }
0112     fn set_u64(&mut self, index: usize, v: u64) -> bool {
0113         self.list[index].u64 = v;
0114         true
0115     }
0116     fn f32(&self, index: usize) -> f32 {
0117         self.list[index].f32
0118     }
0119     fn set_f32(&mut self, index: usize, v: f32) -> bool {
0120         self.list[index].f32 = v;
0121         true
0122     }
0123     fn f64(&self, index: usize) -> f64 {
0124         self.list[index].f64
0125     }
0126     fn set_f64(&mut self, index: usize, v: f64) -> bool {
0127         self.list[index].f64 = v;
0128         true
0129     }
0130     fn string(&self, index: usize) -> &str {
0131         &self.list[index].string
0132     }
0133     fn set_string(&mut self, index: usize, v: String) -> bool {
0134         self.list[index].string = v;
0135         true
0136     }
0137     fn optional_string(&self, index: usize) -> Option<&str> {
0138         self.list[index].optional_string.as_ref().map(|p|&p[..])
0139     }
0140     fn set_optional_string(&mut self, index: usize, v: Option<String>) -> bool {
0141         self.list[index].optional_string = v;
0142         true
0143     }
0144     fn bytearray(&self, index: usize) -> &[u8] {
0145         &self.list[index].bytearray
0146     }
0147     fn set_bytearray(&mut self, index: usize, v: &[u8]) -> bool {
0148         self.list[index].bytearray.truncate(0);
0149         self.list[index].bytearray.extend_from_slice(v);
0150         true
0151     }
0152     fn optional_bytearray(&self, index: usize) -> Option<&[u8]> {
0153         self.list[index].optional_bytearray.as_ref().map(|p|&p[..])
0154     }
0155     fn set_optional_bytearray(&mut self, index: usize, v: Option<&[u8]>) -> bool {
0156         match (v, &mut self.list[index].optional_bytearray) {
0157             (Some(value), &mut Some(ref mut b)) => {
0158                 b.truncate(0);
0159                 b.extend_from_slice(value);
0160             },
0161             (Some(value), b) => {
0162                 *b = Some(value.into())
0163             },
0164             (None, b) => {*b = None;}
0165         };
0166         true
0167     }
0168 }
0169