170 lines
4.5 KiB
Rust
170 lines
4.5 KiB
Rust
#![allow(unused_imports)]
|
|
#![allow(unused_variables)]
|
|
#![allow(dead_code)]
|
|
use interface::*;
|
|
|
|
#[derive(Default, Clone)]
|
|
struct ListItem {
|
|
boolean: bool,
|
|
optional_boolean: Option<bool>,
|
|
i8: i8,
|
|
u8: u8,
|
|
i16: i16,
|
|
u16: u16,
|
|
i32: i32,
|
|
u32: u32,
|
|
i64: i64,
|
|
u64: u64,
|
|
f32: f32,
|
|
f64: f64,
|
|
bytearray: Vec<u8>,
|
|
optional_bytearray: Option<Vec<u8>>,
|
|
string: String,
|
|
optional_string: Option<String>,
|
|
}
|
|
|
|
pub struct List {
|
|
emit: ListEmitter,
|
|
model: ListList,
|
|
list: Vec<ListItem>,
|
|
}
|
|
|
|
impl ListTrait for List {
|
|
fn new(emit: ListEmitter, model: ListList) -> List {
|
|
List {
|
|
emit: emit,
|
|
model: model,
|
|
list: vec![ListItem::default(); 10],
|
|
}
|
|
}
|
|
fn emit(&mut self) -> &mut ListEmitter {
|
|
&mut self.emit
|
|
}
|
|
fn row_count(&self) -> usize {
|
|
self.list.len()
|
|
}
|
|
fn boolean(&self, index: usize) -> bool {
|
|
self.list[index].boolean
|
|
}
|
|
fn set_boolean(&mut self, index: usize, v: bool) -> bool {
|
|
self.list[index].boolean = v;
|
|
true
|
|
}
|
|
fn optional_boolean(&self, index: usize) -> Option<bool> {
|
|
self.list[index].optional_boolean
|
|
}
|
|
fn set_optional_boolean(&mut self, index: usize, v: Option<bool>) -> bool {
|
|
self.list[index].optional_boolean = v;
|
|
true
|
|
}
|
|
fn i8(&self, index: usize) -> i8 {
|
|
self.list[index].i8
|
|
}
|
|
fn set_i8(&mut self, index: usize, v: i8) -> bool {
|
|
self.list[index].i8 = v;
|
|
true
|
|
}
|
|
fn u8(&self, index: usize) -> u8 {
|
|
self.list[index].u8
|
|
}
|
|
fn set_u8(&mut self, index: usize, v: u8) -> bool {
|
|
self.list[index].u8 = v;
|
|
true
|
|
}
|
|
fn i16(&self, index: usize) -> i16 {
|
|
self.list[index].i16
|
|
}
|
|
fn set_i16(&mut self, index: usize, v: i16) -> bool {
|
|
self.list[index].i16 = v;
|
|
true
|
|
}
|
|
fn u16(&self, index: usize) -> u16 {
|
|
self.list[index].u16
|
|
}
|
|
fn set_u16(&mut self, index: usize, v: u16) -> bool {
|
|
self.list[index].u16 = v;
|
|
true
|
|
}
|
|
fn i32(&self, index: usize) -> i32 {
|
|
self.list[index].i32
|
|
}
|
|
fn set_i32(&mut self, index: usize, v: i32) -> bool {
|
|
self.list[index].i32 = v;
|
|
true
|
|
}
|
|
fn u32(&self, index: usize) -> u32 {
|
|
self.list[index].u32
|
|
}
|
|
fn set_u32(&mut self, index: usize, v: u32) -> bool {
|
|
self.list[index].u32 = v;
|
|
true
|
|
}
|
|
fn i64(&self, index: usize) -> i64 {
|
|
self.list[index].i64
|
|
}
|
|
fn set_i64(&mut self, index: usize, v: i64) -> bool {
|
|
self.list[index].i64 = v;
|
|
true
|
|
}
|
|
fn u64(&self, index: usize) -> u64 {
|
|
self.list[index].u64
|
|
}
|
|
fn set_u64(&mut self, index: usize, v: u64) -> bool {
|
|
self.list[index].u64 = v;
|
|
true
|
|
}
|
|
fn f32(&self, index: usize) -> f32 {
|
|
self.list[index].f32
|
|
}
|
|
fn set_f32(&mut self, index: usize, v: f32) -> bool {
|
|
self.list[index].f32 = v;
|
|
true
|
|
}
|
|
fn f64(&self, index: usize) -> f64 {
|
|
self.list[index].f64
|
|
}
|
|
fn set_f64(&mut self, index: usize, v: f64) -> bool {
|
|
self.list[index].f64 = v;
|
|
true
|
|
}
|
|
fn string(&self, index: usize) -> &str {
|
|
&self.list[index].string
|
|
}
|
|
fn set_string(&mut self, index: usize, v: String) -> bool {
|
|
self.list[index].string = v;
|
|
true
|
|
}
|
|
fn optional_string(&self, index: usize) -> Option<&str> {
|
|
self.list[index].optional_string.as_ref().map(|p|&p[..])
|
|
}
|
|
fn set_optional_string(&mut self, index: usize, v: Option<String>) -> bool {
|
|
self.list[index].optional_string = v;
|
|
true
|
|
}
|
|
fn bytearray(&self, index: usize) -> &[u8] {
|
|
&self.list[index].bytearray
|
|
}
|
|
fn set_bytearray(&mut self, index: usize, v: &[u8]) -> bool {
|
|
self.list[index].bytearray.truncate(0);
|
|
self.list[index].bytearray.extend_from_slice(v);
|
|
true
|
|
}
|
|
fn optional_bytearray(&self, index: usize) -> Option<&[u8]> {
|
|
self.list[index].optional_bytearray.as_ref().map(|p|&p[..])
|
|
}
|
|
fn set_optional_bytearray(&mut self, index: usize, v: Option<&[u8]>) -> bool {
|
|
match (v, &mut self.list[index].optional_bytearray) {
|
|
(Some(value), &mut Some(ref mut b)) => {
|
|
b.truncate(0);
|
|
b.extend_from_slice(value);
|
|
},
|
|
(Some(value), b) => {
|
|
*b = Some(value.into())
|
|
},
|
|
(None, b) => {*b = None;}
|
|
};
|
|
true
|
|
}
|
|
}
|
|
|