obj_alloc/
lib.rs

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

obj_alloc/
lib.rs
