rust_object_types/src/implementation.rs

0001 #![allow(unused_imports)]
0002 #![allow(unused_variables)]
0003 #![allow(dead_code)]
0004 use interface::*;
0005
0006 pub struct Object {
0007     emit: ObjectEmitter,
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     optional_u64: Option<u64>,
0019     f32: f32,
0020     f64: f64,
0021     bytearray: Vec<u8>,
0022     optional_bytearray: Option<Vec<u8>>,
0023     string: String,
0024     optional_string: Option<String>,
0025     string_by_function: String,
0026 }
0027
0028 impl ObjectTrait for Object {
0029     fn new(emit: ObjectEmitter) -> Object {
0030         Object {
0031             emit,
0032             boolean: false,
0033             optional_boolean: None,
0034             i8: 0,
0035             u8: 0,
0036             i16: 0,
0037             u16: 0,
0038             i32: 0,
0039             u32: 0,
0040             i64: 0,
0041             u64: 0,
0042             optional_u64: None,
0043             f32: 0.,
0044             f64: 0.,
0045             bytearray: Vec::new(),
0046             optional_bytearray: None,
0047             string: String::new(),
0048             optional_string: None,
0049             string_by_function: String::new()
0050         }
0051     }
0052     fn emit(&mut self) -> &mut ObjectEmitter {
0053         &mut self.emit
0054     }
0055     fn boolean(&self) -> bool {
0056         self.boolean
0057     }
0058     fn set_boolean(&mut self, value: bool) {
0059         self.boolean = value;
0060         self.emit.boolean_changed();
0061     }
0062     fn optional_boolean(&self) -> Option<bool> {
0063         self.optional_boolean
0064     }
0065     fn set_optional_boolean(&mut self, b: Option<bool>) {
0066         self.optional_boolean = b;
0067         self.emit.optional_boolean_changed();
0068     }
0069     fn i8(&self) -> i8 {
0070         self.i8
0071     }
0072     fn set_i8(&mut self, value: i8) {
0073         self.i8 = value;
0074         self.emit.i8_changed();
0075     }
0076     fn u8(&self) -> u8 {
0077         self.u8
0078     }
0079     fn set_u8(&mut self, value: u8) {
0080         self.u8 = value;
0081         self.emit.u8_changed();
0082     }
0083     fn i16(&self) -> i16 {
0084         self.i16
0085     }
0086     fn set_i16(&mut self, value: i16) {
0087         self.i16 = value;
0088         self.emit.i16_changed();
0089     }
0090     fn u16(&self) -> u16 {
0091         self.u16
0092     }
0093     fn set_u16(&mut self, value: u16) {
0094         self.u16 = value;
0095         self.emit.u16_changed();
0096     }
0097     fn i32(&self) -> i32 {
0098         self.i32
0099     }
0100     fn set_i32(&mut self, value: i32) {
0101         self.i32 = value;
0102         self.emit.i32_changed();
0103     }
0104     fn u32(&self) -> u32 {
0105         self.u32
0106     }
0107     fn set_u32(&mut self, value: u32) {
0108         self.u32 = value;
0109         self.emit.u32_changed();
0110     }
0111     fn i64(&self) -> i64 {
0112         self.i64
0113     }
0114     fn set_i64(&mut self, value: i64) {
0115         self.i64 = value;
0116         self.emit.i64_changed();
0117     }
0118     fn u64(&self) -> u64 {
0119         self.u64
0120     }
0121     fn set_u64(&mut self, value: u64) {
0122         self.u64 = value;
0123         self.emit.u64_changed();
0124     }
0125     fn optional_u64(&self) -> Option<u64> {
0126         self.optional_u64
0127     }
0128     fn set_optional_u64(&mut self, v: Option<u64>) {
0129         self.optional_u64 = v;
0130         self.emit.optional_u64_changed();
0131     }
0132     fn f32(&self) -> f32 {
0133         self.f32
0134     }
0135     fn set_f32(&mut self, value: f32) {
0136         self.f32 = value;
0137         self.emit.f32_changed();
0138     }
0139     fn f64(&self) -> f64 {
0140         self.f64
0141     }
0142     fn set_f64(&mut self, value: f64) {
0143         self.f64 = value;
0144         self.emit.f64_changed();
0145     }
0146     fn bytearray(&self) -> &[u8] {
0147         &self.bytearray
0148     }
0149     fn set_bytearray(&mut self, value: &[u8]) {
0150         self.bytearray.truncate(0);
0151         self.bytearray.extend_from_slice(value);
0152         self.emit.bytearray_changed();
0153     }
0154     fn optional_bytearray(&self) -> Option<&[u8]> {
0155         self.optional_bytearray.as_ref().map(|p|&p[..])
0156     }
0157     fn set_optional_bytearray(&mut self, value: Option<&[u8]>) {
0158         match (value, &mut self.optional_bytearray) {
0159             (Some(value), &mut Some(ref mut b)) => {
0160                 b.truncate(0);
0161                 b.extend_from_slice(value);
0162             },
0163             (Some(value), b) => {
0164                 *b = Some(value.into())
0165             },
0166             (None, b) => {*b = None;}
0167         };
0168         self.emit.optional_bytearray_changed();
0169     }
0170     fn optional_string(&self) -> Option<&str> {
0171         self.optional_string.as_ref().map(|p|&p[..])
0172     }
0173     fn set_optional_string(&mut self, value: Option<String>) {
0174         self.optional_string = value;
0175         self.emit.optional_string_changed();
0176     }
0177     fn string(&self) -> &str {
0178         &self.string
0179     }
0180     fn set_string(&mut self, value: String) {
0181         self.string = value;
0182         self.emit.string_changed();
0183     }
0184     fn string_by_function<F>(&self, getter: F) where F: FnOnce(&str) {
0185         getter(&self.string_by_function)
0186     }
0187     fn set_string_by_function(&mut self, value: String) {
0188         self.string_by_function = value;
0189         self.emit.string_by_function_changed();
0190     }
0191 }
0192