obj_alloc/
lib.rs

1pub mod pair;
2pub mod id_map;
3pub mod deser;
4
5pub use id_map::*;
6pub use pair::*;
7
8use std::ops::{Deref, DerefMut};
9use field_collex::{Collexetable, FieldCollex, FieldValue};
10use field_collex::collex::*;
11use span_core::Span;
12
13pub(crate) fn insert<K,E,V>(id_map: &mut IdMap<K,V>, elem: E) -> Pair<K,E>
14where
15    K: Id,
16    E: Collexetable<V>,
17    V: FieldValue,
18{
19    Pair(
20        id_map.insert(elem.collexate()),
21        elem
22    )
23}
24
25pub(crate) fn extend_from_vec<K,E,V>(id_map: &mut IdMap<K,V>, vec: Vec<E>) -> Vec<Pair<K,E>>
26where
27    K: Id,
28    E: Collexetable<V>,
29    V: FieldValue,
30{
31    let mut other: Vec<Pair<K,E>> = Vec::new();
32    vec.into_iter().for_each(|e|
33        {
34            other.push(insert(id_map, e))
35        }
36    );
37    
38    other
39}
40
41#[derive(Debug)]
42#[derive(serde::Serialize)]
43#[serde(transparent)]
44pub struct OrdAllocator<K,T,O>
45where
46    K: Id,
47    O: Collexetable<T>,
48    T: FieldValue,
49{
50    #[serde(skip)]
51    pub id_map: IdMap<K,T>,
52    pub collex: FieldCollex<Pair<K,O>,T>
53}
54
55impl<K,V,E> Deref for OrdAllocator<K,V,E>
56where
57    K: Id,
58    E: Collexetable<V>,
59    V: FieldValue,
60{
61    type Target =  FieldCollex<Pair<K,E>,V>;
62    fn deref(&self) -> &Self::Target {
63        &self.collex
64    }
65}
66
67impl<K,V,E> DerefMut for OrdAllocator<K,V,E>
68where
69    K: Id,
70    E: Collexetable<V>,
71    V: FieldValue,
72{
73    fn deref_mut(&mut self) -> &mut Self::Target {
74        &mut self.collex
75    }
76}
77
78
79impl<K, V, E> OrdAllocator<K, V, E>
80where
81    K: Id,
82    E: Collexetable<V>,
83    V: FieldValue,
84{
85    pub fn new(span: Span<V>, unit: V) -> Result<Self, NewFieldCollexError<V>> {
86        Ok(Self{
87            id_map: IdMap::with_id(),
88            collex: FieldCollex::new(span, unit)?,
89        })
90    }
91    
92    pub fn with_capacity(
93        span: Span<V>,
94        unit: V,
95        capacity: usize,
96    ) -> Result<Self, WithCapacityFieldCollexError<V>>
97    {
98        Ok(Self{
99            id_map: IdMap::with_id_capacity(capacity),
100            collex: FieldCollex::with_capacity(span, unit, capacity)?,
101        })
102    }
103    
104    pub fn with_elements(
105        span: Span<V>,
106        unit: V,
107        vec: Vec<E>,
108    ) -> Result<Self, WithElementsFieldCollexError<V>>
109    {
110        let mut id_map = IdMap::with_id();
111        let other = extend_from_vec(&mut id_map, vec);
112        
113        Ok(Self{
114            id_map,
115            collex: FieldCollex::with_elements(span, unit, other)?,
116        })
117    }
118    
119    pub fn extend(&mut self, vec: Vec<E>) {
120        let other = extend_from_vec(&mut self.id_map, vec);
121        self.collex.extend(other)
122    }
123    
124    pub fn try_extend(&mut self, vec: Vec<E>) -> TryExtendResult<Pair<K, E>> {
125        let other = extend_from_vec(&mut self.id_map, vec);
126        self.collex.try_extend(other)
127    }
128    
129    pub fn insert(&mut self, elem: E) -> Result<K, InsertFieldCollexError<E>> {
130        use InsertFieldCollexError::*;
131        let obj = insert(&mut self.id_map, elem);
132        let id = obj.0;
133        self.collex.insert(obj)
134            .map(|_| id)
135            .map_err(|err|
136                {
137                    self.id_map.remove(id);
138                    match err {
139                        OutOfSpan(o) => { OutOfSpan(o.1) }
140                        AlreadyExist(o) => { AlreadyExist(o.1) }
141                    }
142                }
143            )
144    }
145    
146    pub fn remove(&mut self, id: K) -> Option<E> {
147        let v = self.id_map.remove(id)?;
148        
149        Some(self.collex
150            .remove(v)
151            .unwrap()
152            .1)
153    }
154    
155    pub fn modify<F,R>(&mut self, id: K, f: F) -> Result<R, ModifyFieldCollexError<(R,E)>>
156    where
157        F: Fn(&mut E) -> R,
158    {
159        use ModifyFieldCollexError::*;
160        let v = self.id_map.get(id).ok_or(CannotFind)?;
161        let (r,new_v) =
162            self.collex
163                .modify(*v,|e| (f(e),e.collexate()) )
164                .map_err(|err|
165                    err.map(|e| (e.0.0, e.1.1))
166                )?;
167        *self.id_map.get_mut(id).unwrap() = new_v;
168        Ok(r)
169    }
170    
171    pub fn try_modify<F,R>(&mut self, id: K, f: F) -> Result<R, ModifyFieldCollexError<R>>
172    where
173        F: Fn(&mut E) -> R,
174    {
175        use ModifyFieldCollexError::*;
176        let v = self.id_map.get(id).ok_or(CannotFind)?;
177        let (r,new_v) =
178            self.collex
179                .try_modify(*v, |e| (f(e),e.collexate()) )
180                .map_err(|err|
181                     err.map(|e| e.0)
182                )?;
183        *self.id_map.get_mut(id).unwrap() = new_v;
184        Ok(r)
185    }
186    
187    pub fn get_with_id(&self, id: K) -> Option<&E> {
188        let v = self.id_map.get(id)?;
189        self.collex.get(*v).map(|v| &v.1)
190    }
191    
192    pub fn into_raw_parts(self) -> (IdMap<K,V>, FieldCollex<Pair<K,E>,V>) {
193        (self.id_map,self.collex)
194    }
195    
196    pub fn from_raw_parts(id_map: IdMap<K,V>, collex: FieldCollex<Pair<K,E>,V>) -> Self {
197        Self {
198            id_map, collex
199        }
200    }
201}
202
203
obj_alloc/lib.rs

obj_alloc/
lib.rs
