roussillon_type_system/value/
sequence.rs

1use std::cell::RefCell;
2use std::fmt::Debug;
3use std::rc::Rc;
4use crate::parse::{parse_slice, Parsed};
5
6use crate::types::concept::{DataType, Type};
7use crate::types::sequence::Tuple;
8use crate::value::concept::{DataValue, ValueCell};
9use crate::value::error::{SequenceError, TypeResult};
10
11#[derive(Clone, Debug)]
12pub struct Sequence {
13    definition: Tuple,
14    values: Vec<ValueCell>,
15}
16
17impl Sequence {
18    
19    pub fn empty() -> Self {
20        Self {
21            definition: vec![],
22            values: vec![],
23        }
24    }
25    
26    pub fn new(definition: Tuple, values: &[ValueCell]) -> TypeResult<Self> {
27        if definition.len() != values.len() {
28            return Err(SequenceError::SequenceLengthMismatch { expected: 0, provided: 0 }.promote());
29        }
30        for (index, expected) in definition.iter().enumerate() {
31            values[index].borrow().validate_type(expected)?;
32        }
33        Ok(Self { definition, values: values.to_vec() })
34    }
35
36    pub fn values(&self) -> &[ValueCell] {
37        &self.values
38    }
39
40    pub fn get(&self) -> Vec<ValueCell> {
41        self.values().to_vec()
42    }
43    pub fn to_cell(self) -> ValueCell { Rc::new(RefCell::new(self)) }
44
45    pub fn from(definition: Tuple, raw: &[u8]) -> TypeResult<Self> {
46        let mut values = Vec::new();
47        let mut start = 0;
48        let mut end = 0;
49        for t in definition.iter() {
50            end += t.size();
51            values.push(t.construct_from_raw(&raw[start..end])?);
52            start = end;
53        }
54        Self::new(definition.clone(), &values)
55    }
56    
57    /// Returns a new [Sequence] from a [Tuple] scheme and raw data.
58    /// 
59    /// ## Panics
60    /// 
61    /// This methods could panic if the call to Self::from() return a [crate::value::error::TypeError].
62    pub fn parse(input: &[u8], definition: Tuple) -> Parsed<Self> {
63        let (Some(raw), rest) = parse_slice(input, definition.size()) else { return (None, input); };
64        (Some(Self::from(definition, raw).unwrap()), rest)
65    }
66}
67
68pub fn values_to_raw(values: &[ValueCell]) -> Vec<u8> {
69    let mut raw = Vec::new();
70    for element in values {
71        raw.extend(element.borrow().raw());
72    }
73    raw
74}
75
76impl DataValue for Sequence {
77    fn data_type(&self) -> Type {
78        Rc::new(self.definition.clone())
79    }
80
81    fn raw(&self) -> Vec<u8> { values_to_raw(&self.values) }
82
83    fn set(&mut self, raw: &[u8]) {
84        let mut pointer: usize = 0;
85        for i in self.values.iter_mut() {
86            let pointer_end = pointer + i.borrow().data_type().size();
87            i.borrow_mut().set(&raw[pointer..pointer_end]);
88            pointer = pointer_end;
89        }
90    }
91}
roussillon_type_system/value/sequence.rs

roussillon_type_system/value/
sequence.rs
