facet_core/impls_core/
slice.rs

1use crate::*;
2
3unsafe impl<'a, T> Facet<'a> for [T]
4where
5    T: Facet<'a>,
6{
7    const VTABLE: &'static ValueVTable = &const {
8        ValueVTable::builder_unsized::<Self>()
9            .type_name(|f, opts| {
10                if let Some(opts) = opts.for_children() {
11                    write!(f, "[")?;
12                    (T::SHAPE.vtable.type_name())(f, opts)?;
13                    write!(f, "]")
14                } else {
15                    write!(f, "[⋯]")
16                }
17            })
18            .marker_traits(|| {
19                T::SHAPE
20                    .vtable
21                    .marker_traits()
22                    .difference(MarkerTraits::COPY)
23            })
24            .debug(|| {
25                if T::SHAPE.vtable.has_debug() {
26                    Some(|value, f| {
27                        write!(f, "[")?;
28                        for (i, item) in value.iter().enumerate() {
29                            if i > 0 {
30                                write!(f, ", ")?;
31                            }
32                            (<VTableView<T>>::of().debug().unwrap())(item, f)?;
33                        }
34                        write!(f, "]")
35                    })
36                } else {
37                    None
38                }
39            })
40            .partial_eq(|| {
41                if T::SHAPE.vtable.has_partial_eq() {
42                    Some(|a, b| {
43                        if a.len() != b.len() {
44                            return false;
45                        }
46                        for (x, y) in a.iter().zip(b.iter()) {
47                            if !(<VTableView<T>>::of().partial_eq().unwrap())(x, y) {
48                                return false;
49                            }
50                        }
51                        true
52                    })
53                } else {
54                    None
55                }
56            })
57            .partial_ord(|| {
58                if T::SHAPE.vtable.has_partial_ord() {
59                    Some(|a, b| {
60                        for (x, y) in a.iter().zip(b.iter()) {
61                            let ord = (<VTableView<T>>::of().partial_ord().unwrap())(x, y);
62                            match ord {
63                                Some(core::cmp::Ordering::Equal) => continue,
64                                Some(order) => return Some(order),
65                                None => return None,
66                            }
67                        }
68                        a.len().partial_cmp(&b.len())
69                    })
70                } else {
71                    None
72                }
73            })
74            .ord(|| {
75                if T::SHAPE.vtable.has_ord() {
76                    Some(|a, b| {
77                        for (x, y) in a.iter().zip(b.iter()) {
78                            let ord = (<VTableView<T>>::of().ord().unwrap())(x, y);
79                            if ord != core::cmp::Ordering::Equal {
80                                return ord;
81                            }
82                        }
83                        a.len().cmp(&b.len())
84                    })
85                } else {
86                    None
87                }
88            })
89            .hash(|| {
90                if T::SHAPE.vtable.has_hash() {
91                    Some(|value, state, hasher| {
92                        for item in value.iter() {
93                            (<VTableView<T>>::of().hash().unwrap())(item, state, hasher);
94                        }
95                    })
96                } else {
97                    None
98                }
99            })
100            .build()
101    };
102
103    const SHAPE: &'static Shape = &const {
104        Shape::builder_for_unsized::<Self>()
105            .type_identifier("[_]")
106            .type_params(&[TypeParam {
107                name: "T",
108                shape: || T::SHAPE,
109            }])
110            .ty(Type::Sequence(SequenceType::Slice(SliceType {
111                t: T::SHAPE,
112            })))
113            .def(Def::Slice(
114                SliceDef::builder()
115                    .vtable(
116                        &const {
117                            SliceVTable::builder()
118                                .len(|ptr| unsafe {
119                                    let slice = ptr.get::<&[T]>();
120                                    slice.len()
121                                })
122                                .as_ptr(|ptr| unsafe {
123                                    let slice = ptr.get::<&[T]>();
124                                    PtrConst::new(slice.as_ptr())
125                                })
126                                .as_mut_ptr(|ptr| unsafe {
127                                    let slice = ptr.as_mut::<&mut [T]>();
128                                    PtrMut::new(slice.as_mut_ptr())
129                                })
130                                .build()
131                        },
132                    )
133                    .t(T::SHAPE)
134                    .build(),
135            ))
136            .build()
137    };
138}
facet_core/impls_core/slice.rs

facet_core/impls_core/
slice.rs
