genet_abi/
layer.rs

1use attr::Attr;
2use fixed::{Fixed, MutFixed};
3use slice::ByteSlice;
4use std::{
5    fmt,
6    marker::PhantomData,
7    ops::{Deref, DerefMut},
8    slice,
9};
10use token::Token;
11
12/// A layer stack object.
13pub struct LayerStack<'a> {
14    buffer: &'a [*const Layer],
15}
16
17impl<'a> LayerStack<'a> {
18    pub(crate) unsafe fn new(ptr: *const *const Layer, len: usize) -> LayerStack<'a> {
19        Self {
20            buffer: slice::from_raw_parts(ptr, len),
21        }
22    }
23
24    /// Returns the top of the LayerStack.
25    pub fn top(&self) -> Option<&Layer> {
26        self.layers().last()
27    }
28
29    /// Returns the bottom of the LayerStack.
30    pub fn bottom(&self) -> Option<&Layer> {
31        self.layers().next()
32    }
33
34    /// Find the attribute in the LayerStack.
35    pub fn attr(&self, id: Token) -> Option<&Attr> {
36        for layer in self.layers().rev() {
37            if let Some(attr) = layer.attr(id) {
38                return Some(attr);
39            }
40        }
41        None
42    }
43
44    /// Find the layer in the LayerStack.
45    pub fn layer(&self, id: Token) -> Option<&Layer> {
46        self.layers().find(|layer| layer.id() == id)
47    }
48
49    fn layers(&self) -> impl DoubleEndedIterator<Item = &'a Layer> {
50        self.buffer.iter().map(|layer| unsafe { &**layer })
51    }
52}
53
54/// A mutable proxy for a layer object.
55#[repr(C)]
56pub struct Parent<'a> {
57    layer: *mut Layer,
58    add_child: extern "C" fn(*mut Parent, *mut Layer),
59    children_len: extern "C" fn(*const Parent) -> u64,
60    children_data: extern "C" fn(*const Parent) -> *const *mut Layer,
61    phantom: PhantomData<&'a ()>,
62    children: Vec<*mut Layer>,
63}
64
65impl<'a> Parent<'a> {
66    pub fn from_mut_ref(layer: &'a mut Layer) -> Parent {
67        Parent {
68            layer,
69            add_child: abi_add_child,
70            children_len: abi_children_len,
71            children_data: abi_children_data,
72            phantom: PhantomData,
73            children: Vec::new(),
74        }
75    }
76
77    /// Returns the ID of self.
78    pub fn id(&self) -> Token {
79        self.deref().id()
80    }
81
82    /// Returns the type of self.
83    pub fn data(&self) -> ByteSlice {
84        self.deref().data()
85    }
86
87    /// Returns the slice of headers.
88    pub fn headers(&self) -> &[Fixed<Attr>] {
89        self.deref().headers()
90    }
91
92    /// Returns the slice of attributes.
93    pub fn attrs(&self) -> &[Fixed<Attr>] {
94        self.deref().attrs()
95    }
96
97    /// Find the attribute in the Layer.
98    pub fn attr<T: Into<Token>>(&self, id: T) -> Option<&Attr> {
99        self.deref().attr(id)
100    }
101
102    /// Adds an attribute to the Layer.
103    pub fn add_attr<T: Into<Fixed<Attr>>>(&mut self, attr: T) {
104        self.deref_mut().add_attr(attr);
105    }
106
107    /// Returns the slice of payloads.
108    pub fn payloads(&self) -> &[Payload] {
109        self.deref().payloads()
110    }
111
112    /// Adds a payload to the Layer.
113    pub fn add_payload(&mut self, payload: Payload) {
114        self.deref_mut().add_payload(payload);
115    }
116
117    pub fn add_child<T: Into<MutFixed<Layer>>>(&mut self, layer: T) {
118        (self.add_child)(self, layer.into().as_mut_ptr());
119    }
120
121    pub fn children(&self) -> &[*mut Layer] {
122        let data = (self.children_data)(self);
123        let len = (self.children_len)(self) as usize;
124        unsafe { slice::from_raw_parts(data, len) }
125    }
126}
127
128impl<'a> Deref for Parent<'a> {
129    type Target = Layer;
130
131    fn deref(&self) -> &Layer {
132        unsafe { &*self.layer }
133    }
134}
135
136impl<'a> DerefMut for Parent<'a> {
137    fn deref_mut(&mut self) -> &mut Layer {
138        unsafe { &mut *self.layer }
139    }
140}
141
142extern "C" fn abi_add_child(layer: *mut Parent, child: *mut Layer) {
143    unsafe { (*layer).children.push(child) }
144}
145
146extern "C" fn abi_children_len(layer: *const Parent) -> u64 {
147    unsafe { (*layer).children.len() as u64 }
148}
149
150extern "C" fn abi_children_data(layer: *const Parent) -> *const *mut Layer {
151    unsafe { (*layer).children.as_ptr() }
152}
153
154/// A layer object.
155#[repr(C)]
156pub struct Layer {
157    class: Fixed<LayerClass>,
158    data: ByteSlice,
159    attrs: Vec<Fixed<Attr>>,
160    payloads: Vec<Payload>,
161}
162
163unsafe impl Send for Layer {}
164
165impl Layer {
166    /// Creates a new Layer.
167    pub fn new<C: Into<Fixed<LayerClass>>, B: Into<ByteSlice>>(class: C, data: B) -> Layer {
168        Layer {
169            class: class.into(),
170            data: data.into(),
171            attrs: Vec::new(),
172            payloads: Vec::new(),
173        }
174    }
175
176    /// Returns the ID of self.
177    pub fn id(&self) -> Token {
178        self.class.id()
179    }
180
181    /// Returns the type of self.
182    pub fn data(&self) -> ByteSlice {
183        self.class.data(self)
184    }
185
186    /// Returns the slice of headers.
187    pub fn headers(&self) -> &[Fixed<Attr>] {
188        self.class.headers()
189    }
190
191    /// Returns the slice of attributes.
192    pub fn attrs(&self) -> &[Fixed<Attr>] {
193        self.class.attrs(self)
194    }
195
196    /// Find the attribute in the Layer.
197    pub fn attr<T: Into<Token>>(&self, id: T) -> Option<&Attr> {
198        let id = id.into();
199        let id = self
200            .class
201            .aliases()
202            .find(|alias| alias.id == id)
203            .map(|alias| alias.target)
204            .unwrap_or(id);
205        self.attrs()
206            .iter()
207            .chain(self.class.headers().iter())
208            .find(|attr| attr.id() == id)
209            .map(|attr| attr.as_ref())
210    }
211
212    /// Adds an attribute to the Layer.
213    pub fn add_attr<T: Into<Fixed<Attr>>>(&mut self, attr: T) {
214        let func = self.class.add_attr;
215        (func)(self, attr.into());
216    }
217
218    /// Returns the slice of payloads.
219    pub fn payloads(&self) -> &[Payload] {
220        self.class.payloads(self)
221    }
222
223    /// Adds a payload to the Layer.
224    pub fn add_payload(&mut self, payload: Payload) {
225        let func = self.class.add_payload;
226        (func)(self, payload);
227    }
228}
229
230impl fmt::Debug for Layer {
231    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
232        write!(f, "Layer {:?}", self.id())
233    }
234}
235
236impl Into<MutFixed<Layer>> for Layer {
237    fn into(self) -> MutFixed<Layer> {
238        MutFixed::new(self)
239    }
240}
241
242/// A payload object.
243#[repr(C)]
244pub struct Payload {
245    data: *const u8,
246    len: u64,
247    id: Token,
248    typ: Token,
249}
250
251impl Payload {
252    /// Creates a new payload.
253    pub fn new<B: Into<ByteSlice>, T: Into<Token>>(data: B, id: T) -> Payload {
254        Self::with_typ(data, id, "")
255    }
256
257    /// Creates a new payload with the given type.
258    pub fn with_typ<B: Into<ByteSlice>, T: Into<Token>, U: Into<Token>>(
259        data: B,
260        id: T,
261        typ: U,
262    ) -> Payload {
263        let data: ByteSlice = data.into();
264        Self {
265            data: data.as_ptr(),
266            len: data.len() as u64,
267            id: id.into(),
268            typ: typ.into(),
269        }
270    }
271
272    /// Returns the ID of self.
273    pub fn id(&self) -> Token {
274        self.id
275    }
276
277    /// Returns the type of self.
278    pub fn typ(&self) -> Token {
279        self.typ
280    }
281
282    /// Returns the data of self.
283    pub fn data(&self) -> ByteSlice {
284        unsafe { ByteSlice::from_raw_parts(self.data, self.len as usize) }
285    }
286}
287
288/// A builder object for LayerClass.
289pub struct LayerClassBuilder {
290    id: Token,
291    aliases: Vec<Alias>,
292    headers: Vec<Fixed<Attr>>,
293}
294
295impl LayerClassBuilder {
296    /// Adds an attribute alias for LayerClass.
297    pub fn alias<T: Into<Token>, U: Into<Token>>(mut self, id: T, target: U) -> LayerClassBuilder {
298        self.aliases.push(Alias {
299            id: id.into(),
300            target: target.into(),
301        });
302        self
303    }
304
305    /// Adds a header attribute for LayerClass.
306    pub fn header<T: Into<Fixed<Attr>>>(mut self, attr: T) -> LayerClassBuilder {
307        self.headers.push(attr.into());
308        self
309    }
310
311    /// Builds a new LayerClass.
312    pub fn build(self) -> LayerClass {
313        LayerClass {
314            get_id: abi_id,
315            data: abi_data,
316            attrs_len: abi_attrs_len,
317            attrs_data: abi_attrs_data,
318            aliases_len: abi_aliases_len,
319            aliases_data: abi_aliases_data,
320            headers_len: abi_headers_len,
321            headers_data: abi_headers_data,
322            add_attr: abi_add_attr,
323            payloads_len: abi_payloads_len,
324            payloads_data: abi_payloads_data,
325            add_payload: abi_add_payload,
326            id: self.id,
327            aliases: self.aliases,
328            headers: self.headers,
329        }
330    }
331}
332
333#[repr(C)]
334struct Alias {
335    id: Token,
336    target: Token,
337}
338
339/// A layer class object.
340#[repr(C)]
341pub struct LayerClass {
342    get_id: extern "C" fn(*const LayerClass) -> Token,
343    aliases_len: extern "C" fn(*const LayerClass) -> u64,
344    aliases_data: extern "C" fn(*const LayerClass) -> *const Alias,
345    headers_len: extern "C" fn(*const LayerClass) -> u64,
346    headers_data: extern "C" fn(*const LayerClass) -> *const Fixed<Attr>,
347    data: extern "C" fn(*const Layer, *mut u64) -> *const u8,
348    attrs_len: extern "C" fn(*const Layer) -> u64,
349    attrs_data: extern "C" fn(*const Layer) -> *const Fixed<Attr>,
350    add_attr: extern "C" fn(*mut Layer, Fixed<Attr>),
351    payloads_len: extern "C" fn(*const Layer) -> u64,
352    payloads_data: extern "C" fn(*const Layer) -> *const Payload,
353    add_payload: extern "C" fn(*mut Layer, Payload),
354    id: Token,
355    aliases: Vec<Alias>,
356    headers: Vec<Fixed<Attr>>,
357}
358
359impl LayerClass {
360    /// Creates a new builder object for LayerClass.
361    pub fn builder<T: Into<Token>>(id: T) -> LayerClassBuilder {
362        LayerClassBuilder {
363            id: id.into(),
364            aliases: Vec::new(),
365            headers: Vec::new(),
366        }
367    }
368
369    fn id(&self) -> Token {
370        (self.get_id)(self)
371    }
372
373    fn aliases(&self) -> impl Iterator<Item = &Alias> {
374        let data = (self.aliases_data)(self);
375        let len = (self.aliases_len)(self) as usize;
376        let iter = unsafe { slice::from_raw_parts(data, len).iter() };
377        iter.map(|v| &*v)
378    }
379
380    fn headers(&self) -> &[Fixed<Attr>] {
381        let data = (self.headers_data)(self);
382        let len = (self.headers_len)(self) as usize;
383        unsafe { slice::from_raw_parts(data, len) }
384    }
385
386    fn data(&self, layer: &Layer) -> ByteSlice {
387        let mut len = 0;
388        let data = (self.data)(layer, &mut len);
389        unsafe { ByteSlice::from_raw_parts(data, len as usize) }
390    }
391
392    fn attrs(&self, layer: &Layer) -> &[Fixed<Attr>] {
393        let data = (self.attrs_data)(layer);
394        let len = (self.attrs_len)(layer) as usize;
395        unsafe { slice::from_raw_parts(data, len) }
396    }
397
398    fn payloads(&self, layer: &Layer) -> &[Payload] {
399        let data = (self.payloads_data)(layer);
400        let len = (self.payloads_len)(layer) as usize;
401        unsafe { slice::from_raw_parts(data, len) }
402    }
403}
404
405impl Into<Fixed<LayerClass>> for &'static LayerClass {
406    fn into(self) -> Fixed<LayerClass> {
407        Fixed::from_static(self)
408    }
409}
410
411extern "C" fn abi_id(class: *const LayerClass) -> Token {
412    unsafe { (*class).id }
413}
414
415extern "C" fn abi_aliases_len(class: *const LayerClass) -> u64 {
416    unsafe { (*class).aliases.len() as u64 }
417}
418
419extern "C" fn abi_aliases_data(class: *const LayerClass) -> *const Alias {
420    unsafe { (*class).aliases.as_ptr() }
421}
422
423extern "C" fn abi_headers_len(class: *const LayerClass) -> u64 {
424    unsafe { (*class).headers.len() as u64 }
425}
426
427extern "C" fn abi_headers_data(class: *const LayerClass) -> *const Fixed<Attr> {
428    unsafe { (*class).headers.as_ptr() }
429}
430
431extern "C" fn abi_data(layer: *const Layer, len: *mut u64) -> *const u8 {
432    unsafe {
433        let data = &(*layer).data;
434        *len = data.len() as u64;
435        data.as_ptr()
436    }
437}
438
439extern "C" fn abi_attrs_len(layer: *const Layer) -> u64 {
440    unsafe { (*layer).attrs.len() as u64 }
441}
442
443extern "C" fn abi_attrs_data(layer: *const Layer) -> *const Fixed<Attr> {
444    unsafe { (*layer).attrs.as_ptr() }
445}
446
447extern "C" fn abi_add_attr(layer: *mut Layer, attr: Fixed<Attr>) {
448    let attrs = unsafe { &mut (*layer).attrs };
449    attrs.push(attr);
450}
451
452extern "C" fn abi_payloads_len(layer: *const Layer) -> u64 {
453    unsafe { (*layer).payloads.len() as u64 }
454}
455
456extern "C" fn abi_payloads_data(layer: *const Layer) -> *const Payload {
457    unsafe { (*layer).payloads.as_ptr() }
458}
459
460extern "C" fn abi_add_payload(layer: *mut Layer, payload: Payload) {
461    let payloads = unsafe { &mut (*layer).payloads };
462    payloads.push(payload);
463}
464
465#[cfg(test)]
466mod tests {
467    use attr::{Attr, AttrClass};
468    use cast::Cast;
469    use fixed::Fixed;
470    use layer::{Layer, LayerClass, Payload};
471    use slice::ByteSlice;
472    use std::io::Result;
473    use token::Token;
474    use variant::Variant;
475
476    #[test]
477    fn id() {
478        let id = Token::from(123);
479        let class = Fixed::new(LayerClass::builder(id).build());
480        let layer = Layer::new(class, ByteSlice::new());
481        assert_eq!(layer.id(), id);
482    }
483
484    #[test]
485    fn data() {
486        let data = b"hello";
487        let class = Fixed::new(LayerClass::builder(Token::null()).build());
488        let layer = Layer::new(class, ByteSlice::from(&data[..]));
489        assert_eq!(layer.data(), ByteSlice::from(&data[..]));
490    }
491
492    #[test]
493    fn payloads() {
494        let class = Fixed::new(LayerClass::builder(Token::null()).build());
495        let mut layer = Layer::new(class, ByteSlice::new());
496        assert!(layer.payloads().iter().next().is_none());
497
498        let count = 100;
499        let data = b"hello";
500
501        for i in 0..count {
502            layer.add_payload(Payload::new(ByteSlice::from(&data[..]), Token::from(i)));
503        }
504
505        let mut iter = layer.payloads().iter();
506        for i in 0..count {
507            let payload = iter.next().unwrap();
508            assert_eq!(payload.data(), ByteSlice::from(&data[..]));
509            assert_eq!(payload.id(), Token::from(i));
510        }
511        assert!(iter.next().is_none());
512    }
513
514    #[test]
515    fn attrs() {
516        let class = Fixed::new(LayerClass::builder(Token::null()).build());
517        let mut layer = Layer::new(class, ByteSlice::new());
518        assert!(layer.attrs().is_empty());
519
520        #[derive(Clone)]
521        struct TestCast {}
522
523        impl Cast for TestCast {
524            fn cast(&self, _: &ByteSlice) -> Result<Variant> {
525                Ok(Variant::Nil)
526            }
527        }
528        let class = Fixed::new(
529            AttrClass::builder("nil")
530                .typ("@nil")
531                .cast(TestCast {})
532                .build(),
533        );
534
535        let count = 100;
536        for i in 0..count {
537            let attr = Attr::builder(class.clone()).range(0..i).build();
538            layer.add_attr(attr);
539        }
540        let mut iter = layer.attrs().iter();
541        for i in 0..count {
542            let attr = iter.next().unwrap();
543            assert_eq!(attr.id(), Token::from("nil"));
544            assert_eq!(attr.typ(), Token::from("@nil"));
545            assert_eq!(attr.range(), 0..i);
546        }
547        assert!(iter.next().is_none());
548    }
549}
genet_abi/layer.rs

genet_abi/
layer.rs
