xxlib/
manager.rs

1use crate::types::{TypeClass, ISerde, ISerdeCaseToType, ITypeCaseToISerde};
2use std::cell::{RefCell, Cell, UnsafeCell};
3use impl_trait_for_tuples::*;
4use std::collections::{HashMap, BTreeMap, HashSet, BTreeSet};
5use data_rw::Data;
6use data_rw::DataReader;
7use anyhow::*;
8use crate::StringAssign;
9use std::hash::Hash;
10use std::mem::size_of;
11
12
13#[cfg(not(feature ="Arc"))]
14pub use sharedptr::Rc::SharedPtr;
15#[cfg(not(feature ="Arc"))]
16use std::rc::{Rc, Weak};
17#[cfg(feature ="Arc")]
18pub use sharedptr::Arc::SharedPtr;
19#[cfg(feature ="Arc")]
20use std::sync::{Arc, Weak};
21use sharedptr::unsafe_def::IGetMutUnchecked;
22
23
24static TYPES:TypeClass<65535>=TypeClass::<65535>::new();
25
26pub fn filter_ids(like:&str)->Vec<i32>{
27    let mut table=Vec::new();
28    unsafe {
29        for (typeid,name) in (*TYPES.register_name.get()).iter() {
30            if let Some(0) = name.find(like) {
31                table.push(*typeid as i32)
32            }
33        }
34    }
35    table
36}
37
38/// 用于筛选 struct 内部写入 的类型判断
39pub trait IWriteInner{
40    fn write_(&self,om:&ObjectManager,data:&mut Data)->Result<()>;
41}
42
43#[impl_for_tuples(0, 50)]
44impl IWriteInner for WriteTupleIdntifier{
45    fn write_(&self, om: &ObjectManager, data: &mut Data) -> Result<()> {
46        for_tuples!( #( WriteTupleIdntifier.write_(om,data)?; )* );
47        Ok(())
48    }
49}
50
51
52/// 用于筛选写入struct 字段
53pub trait IReadInner{
54    fn read_(&mut self,om:&ObjectManager,data:&mut DataReader)->Result<()>;
55}
56
57///实现 最大50个类型元素的元组 读取
58#[impl_for_tuples(0,50)]
59impl IReadInner for TupleIdentifier{
60    #[inline]
61    fn read_(&mut self, om: &ObjectManager, data: &mut DataReader) -> Result<()> {
62        for_tuples!( #( TupleIdentifier.read_(om,data)?; )* );
63        Ok(())
64    }
65}
66
67
68/// PKG 序列化 反序列化 的实现
69pub struct ObjectManager{
70    write_ptr_vec:UnsafeCell<ordnung::Map<u64,u32>>,
71    read_ptr_vec:UnsafeCell<Vec<SharedPtr<dyn ISerde>>>
72}
73
74impl Default for ObjectManager{
75    #[inline]
76    fn default() -> Self {
77        ObjectManager::new()
78    }
79}
80
81impl ObjectManager{
82    #[inline]
83    pub fn new()->Self{
84        ObjectManager{
85            write_ptr_vec:UnsafeCell::new(ordnung::Map::with_capacity(10)),
86            read_ptr_vec:UnsafeCell::new(Vec::with_capacity(10))
87        }
88    }
89
90    /// 注册 struct 和 Typeid 映射
91    #[cfg(not(feature ="Arc"))]
92    #[inline]
93    pub fn register<T:Default+ ISerde+'static>(name:&'static str){
94        TYPES.register(T::type_id(),name,||{
95            SharedPtr::from(Rc::new(T::default()) as Rc<dyn ISerde>)
96        });
97    }
98
99    /// 注册 struct 和 Typeid 映射
100    #[cfg(feature ="Arc")]
101    #[inline]
102    pub fn register<T:Default+ ISerde+'static>(name:&'static str){
103        TYPES.register(T::type_id(),name,||{
104            SharedPtr::from(Arc::new(T::default()) as Arc<dyn ISerde>)
105        });
106    }
107
108    /// 根据 Typeid 返回 SharedPtr<dyn ISerde>
109    /// 如果没有注册 返回 None
110    #[inline]
111    pub fn create(typeid:u16)->Option<SharedPtr<dyn ISerde>>{
112        TYPES.create(typeid)
113    }
114
115    /// 写入入口函数
116    #[inline]
117    pub fn write_to<T:ISerde>(&self,data:&mut Data,value:&SharedPtr<T>)->Result<()> {
118        if value.is_null() {
119            panic!("write_to shared ptr not null")
120        } else {
121            self.write_sharedptr_entry(data, value)?;
122        }
123        unsafe {
124            (*self.write_ptr_vec.get()).clear();
125        }
126        Ok(())
127    }
128
129    /// 生成物结构内部写入
130    #[inline]
131    pub fn write_<T:IWriteInner>(&self,data:&mut Data,value:&T)->Result<()>{
132        value.write_(self,data)
133    }
134
135    /// 写入共享指针入口
136    #[inline]
137    pub(crate) fn write_sharedptr_entry<T:ISerde>(&self,data:&mut Data,value:&SharedPtr<T>)->Result<()>{
138        let offset_addr =value.as_ref() as *const T as u64;
139        unsafe {
140            (*self.write_ptr_vec.get()).insert(offset_addr,1);
141        }
142        data.write_var_integer(&value.get_type_id());
143        self.write_ptr(data, value)
144    }
145
146    /// 写入共享指针
147    #[inline]
148    pub(crate) fn write_sharedptr<T:ISerde>(&self,data:&mut Data,value:&SharedPtr<T>)->Result<()>{
149        if value.is_null(){
150            data.write_fixed(&0u8);
151        }else{
152
153            unsafe {
154                let value_addr=value.as_ref() as *const T as u64;
155                let offset = (*self.write_ptr_vec.get()).get(&value_addr).unwrap_or(&0);
156                if *offset == 0 {
157                    let offset = (*self.write_ptr_vec.get()).len() as u32 + 1;
158                    (*self.write_ptr_vec.get()).insert(value_addr,offset);
159                    data.write_var_integer(&offset);
160                    data.write_var_integer(&value.get_type_id());
161                    self.write_ptr(data, value)?;
162                } else {
163                    data.write_var_integer(offset);
164                }
165            }
166        }
167        Ok(())
168    }
169
170    /// 写指针
171    #[inline(always)]
172    fn write_ptr<T:ISerde>(&self,data:&mut Data,value:&SharedPtr<T>)->Result<()>{
173        value.write_to(self,data)
174    }
175
176
177    /// 读SharedPtr<ISerde>
178    #[inline]
179    pub fn read_ptr(&self, dr:&mut DataReader) ->Result<SharedPtr<dyn ISerde>>{
180        unsafe {
181            let r = self.read_ptr_first(dr);
182            (*self.read_ptr_vec.get()).clear();
183            r
184        }
185    }
186
187    #[inline]
188    fn read_ptr_first(&self,data:&mut DataReader)->Result<SharedPtr<dyn ISerde>> {
189        let typeid: u16 = data.read_var_integer()?;
190        let ptr = ObjectManager::create(typeid)
191            .ok_or_else(move ||anyhow!("typeid not found:{}",typeid))?;
192        unsafe {
193            (*self.read_ptr_vec.get()).push(ptr.clone());
194            ptr.get_mut_unchecked().read_from(self, data)?;
195        }
196        Ok(ptr)
197    }
198
199    #[inline]
200    pub fn read_from<T:ISerde+'static>(&self,dr:&mut DataReader,ptr:&SharedPtr<T>)->Result<()>{
201        unsafe {
202            let r = self.read_from_first(dr,ptr);
203            (*self.read_ptr_vec.get()).clear();
204            r
205        }
206    }
207
208    #[inline]
209    fn read_from_first<T:ISerde+'static>(&self, data:&mut DataReader, ptr: &SharedPtr<T>) ->Result<()> {
210        let typeid: u16 = data.read_var_integer()?;
211        ensure!(typeid==ptr.get_type_id(),"typeid error,{}!={}",typeid,ptr.get_type_id());
212        unsafe {
213            (*self.read_ptr_vec.get()).push(ptr.clone().un_cast());
214            ptr.get_mut_unchecked().read_from(self, data)?;
215        }
216        Ok(())
217    }
218
219    #[inline(always)]
220    pub fn read_<T:IReadInner>(&self, data:&mut DataReader, v: &mut T) ->Result<()>{
221        v.read_(self,data)
222    }
223}
224
225
226///
227///                             write
228///
229impl<T:ISerde> IWriteInner for SharedPtr<T>{
230    #[inline]
231    fn write_(&self, om: &ObjectManager, data: &mut Data)->Result<()> {
232        om.write_sharedptr(data, self)
233    }
234}
235
236impl<T:ISerde> IWriteInner for Weak<T>{
237    #[inline]
238    fn write_(&self, om: &ObjectManager, data: &mut Data)->Result<()> {
239        if let Some(ptr) = self.upgrade() {
240            let ptr = SharedPtr::from(ptr);
241            om.write_sharedptr(data, &ptr)?;
242        }else{
243            data.write_fixed(&0u8);
244        }
245        Ok(())
246    }
247}
248impl <T:IWriteInner> IWriteInner for Option<T>{
249    #[inline]
250    fn write_(&self, om: &ObjectManager, data: &mut Data)->Result<()> {
251        if let Some(v)=self{
252            data.write_fixed(&1u8);
253            v.write_(om,data)?;
254        }else{
255            data.write_fixed(&0u8);
256        }
257        Ok(())
258    }
259}
260impl<T:ISerde+Default> IWriteInner for T{
261    #[inline]
262    fn write_(&self, om: &ObjectManager, data: &mut Data)->Result<()> {
263        self.write_to(om,data)
264    }
265}
266macro_rules! impl_iwrite_inner_number_var {
267    ($type:ty) => (
268    impl IWriteInner for $type{
269        #[inline]
270        fn write_(&self, _: &ObjectManager, data: &mut Data)->Result<()> {
271            data.write_var_integer(self);
272            Ok(())
273        }
274    });
275}
276impl_iwrite_inner_number_var!(u16);
277impl_iwrite_inner_number_var!(i16);
278impl_iwrite_inner_number_var!(u32);
279impl_iwrite_inner_number_var!(i32);
280impl_iwrite_inner_number_var!(u64);
281impl_iwrite_inner_number_var!(i64);
282impl_iwrite_inner_number_var!(String);
283impl IWriteInner for &str{
284    #[inline]
285    fn write_(&self, _: &ObjectManager, data: &mut Data)->Result<()> {
286        data.write_var_integer(self);
287        Ok(())
288    }
289}
290macro_rules! impl_iwrite_inner_number_fixed {
291    ($type:ty) => (
292        impl IWriteInner for $type{
293            #[inline]
294            fn write_(&self, _: &ObjectManager, data: &mut Data)->Result<()> {
295                data.write_fixed(self);
296                Ok(())
297            }
298        }
299    );
300}
301impl_iwrite_inner_number_fixed!(i8);
302impl_iwrite_inner_number_fixed!(u8);
303impl_iwrite_inner_number_fixed!(bool);
304impl_iwrite_inner_number_fixed!(f32);
305impl_iwrite_inner_number_fixed!(f64);
306
307impl <T:IWriteInner> IWriteInner for Vec<T>{
308    #[inline]
309    fn write_(&self, om: &ObjectManager, data: &mut Data) ->Result<()>{
310        data.write_var_integer(&(self.len() as u64));
311
312        if size_of::<T>()==1{
313            let buff=self.as_slice() as *const [T] as * const[u8];
314            unsafe {
315                data.write_buf(&*buff);
316            }
317        }else {
318            for x in self.iter() {
319                x.write_(om, data)?;
320            }
321        }
322        Ok(())
323    }
324}
325impl<T:IWriteInner> IWriteInner for &[T]{
326    #[inline]
327    fn write_(&self, om: &ObjectManager, data: &mut Data)->Result<()> {
328        data.write_var_integer(&(self.len() as u64));
329        if size_of::<T>()==1{
330            let buff=*self as *const [T] as * const[u8];
331            unsafe {
332                data.write_buf(&*buff);
333            }
334        }else {
335            for x in self.iter() {
336                x.write_(om, data)?;
337            }
338        }
339        Ok(())
340    }
341}
342macro_rules! impl_iwrite_inner_for_mapset {
343    ($type:tt) =>(
344    impl <K:IWriteInner> IWriteInner for $type::<K>{
345        #[inline]
346        fn write_(&self, om: &ObjectManager, data: &mut Data)->Result<()> {
347            data.write_var_integer(&(self.len() as u64));
348            for k in self.iter() {
349                k.write_(om, data)?;
350            }
351            Ok(())
352        }
353    });
354}
355impl_iwrite_inner_for_mapset!(HashSet);
356impl_iwrite_inner_for_mapset!(BTreeSet);
357macro_rules! impl_iwrite_inner_for_map {
358    ($type:tt) => (
359    impl <K:IWriteInner,V:IWriteInner> IWriteInner for $type<K,V>{
360        #[inline]
361        fn write_(&self, om: &ObjectManager, data: &mut Data)->Result<()> {
362            data.write_var_integer(&(self.len() as u64));
363            for (k,v) in self.iter() {
364                k.write_(om, data)?;
365                v.write_(om, data)?;
366            }
367            Ok(())
368        }
369    }
370    );
371}
372impl_iwrite_inner_for_map!(HashMap);
373impl_iwrite_inner_for_map!(BTreeMap);
374impl <T:IWriteInner> IWriteInner for RefCell<T>{
375    fn write_(&self, om: &ObjectManager, data: &mut Data)->Result<()> {
376        self.borrow().write_(om,data)?;
377        Ok(())
378    }
379}
380impl <T:IWriteInner+Copy> IWriteInner for Cell<T>{
381    fn write_(&self, om: &ObjectManager, data: &mut Data)->Result<()> {
382        self.get().write_(om,data)?;
383        Ok(())
384    }
385}
386
387///
388///                         reader
389///
390macro_rules! impl_iread_object_for_var {
391    ($type:ty) => (
392    impl IReadInner for $type{
393        #[inline]
394        fn read_(&mut self, _om: &ObjectManager, data: &mut DataReader) -> Result<()> {
395            *self = data.read_var_integer()?;
396            Ok(())
397        }
398    });
399}
400impl_iread_object_for_var!(i16);
401impl_iread_object_for_var!(u16);
402impl_iread_object_for_var!(i32);
403impl_iread_object_for_var!(u32);
404impl_iread_object_for_var!(i64);
405impl_iread_object_for_var!(u64);
406
407macro_rules! impl_iread_inner_for_fixed {
408    ($type:ty) => (
409    impl IReadInner for $type{
410        #[inline]
411        fn read_(&mut self, _om: &ObjectManager, data: &mut DataReader) -> Result<()> {
412            *self=data.read_fixed()?;
413            Ok(())
414        }
415    });
416}
417impl_iread_inner_for_fixed!(i8);
418impl_iread_inner_for_fixed!(u8);
419
420impl IReadInner for f32{
421    #[inline]
422    fn read_(&mut self, _om: &ObjectManager, data: &mut DataReader) -> Result<()> {
423        *self=data.read_fixed()?;
424
425        if self.is_nan(){
426            bail!("NaN");
427        }
428        if self.is_infinite(){
429            bail!("INFINITY");
430        }
431        Ok(())
432    }
433}
434
435impl IReadInner for f64{
436    #[inline]
437    fn read_(&mut self, _om: &ObjectManager, data: &mut DataReader) -> Result<()> {
438        *self=data.read_fixed()?;
439        if self.is_nan(){
440            bail!("NaN");
441        }
442        if self.is_infinite(){
443            bail!("INFINITY");
444        }
445        Ok(())
446    }
447}
448
449
450impl IReadInner for bool{
451    #[inline]
452    fn read_(&mut self, _om: &ObjectManager, data: &mut DataReader) -> Result<()> {
453        *self=data.read_fixed::<u8>()?==1;
454        Ok(())
455    }
456}
457impl<T:ISerde> IReadInner for T{
458    #[inline]
459    fn read_(&mut self, om: &ObjectManager, data: &mut DataReader) -> Result<()> {
460        self.read_from(om,data)
461    }
462}
463
464#[inline]
465fn read_shared_ptr<T:ISerde+'static>(om: &ObjectManager, data: &mut DataReader, offset: usize)->Result<SharedPtr<T>> {
466    unsafe {
467        let len = (*om.read_ptr_vec.get()).len();
468        if offset == len + 1 {
469            let typeid = data.read_var_integer::<u16>()?;
470            ensure!(typeid==T::type_id(),"read typeid:{} error,not type:{}",typeid,T::type_id());
471            let ptr = ObjectManager::create(typeid)
472                .ok_or_else(move || anyhow!("not found typeid:{}",typeid))?;
473            (*om.read_ptr_vec.get()).push(ptr.clone());
474            ptr.get_mut_unchecked().read_from(om, data)?;
475            Ok(ptr.cast::<T>()?)
476        } else {
477            ensure!(offset<= len,"read type:{} offset error,offset:{} > vec len:{}",T::type_id(),offset,len);
478            let ptr = (*om.read_ptr_vec.get()).get(offset - 1).cloned()
479                .ok_or_else(move || anyhow!("read type:{} offset error,not found offset:{}",T::type_id(),offset))?;
480            ensure!(T::type_id()==ptr.get_type_id(),"read type:{} error offset type:{}",T::type_id(),ptr.get_type_id());
481            Ok(ptr.cast::<T>()?)
482        }
483    }
484}
485impl <T:ISerde+'static> IReadInner for SharedPtr<T>{
486    #[inline]
487    fn read_(&mut self, om: &ObjectManager, data: &mut DataReader) -> Result<()> {
488        let offset=data.read_var_integer::<u32>()? as usize;
489        if offset==0{
490            self.set_null();
491            return  Ok(())
492        }
493        *self= read_shared_ptr::<T>(om, data, offset)?;
494        Ok(())
495    }
496}
497
498
499impl <T:ISerde+'static> IReadInner for Weak<T>{
500    #[inline]
501    fn read_(&mut self, om: &ObjectManager, data: &mut DataReader) -> Result<()> {
502        let offset = data.read_var_integer::<u32>()? as usize;
503        if offset == 0 {
504            *self = Default::default();
505            return Ok(())
506        }
507        if let Some(ptr) = read_shared_ptr::<T>(om, data, offset)?.weak() {
508            *self = ptr;
509            Ok(())
510        } else {
511            bail!("shared ptr is null,type:{}",T::type_id())
512        }
513    }
514}
515impl IReadInner for String{
516    #[inline(always)]
517    fn read_(&mut self, _om: &ObjectManager, data: &mut DataReader) -> Result<()> {
518        self.assign(data.read_var_str()?);
519        Ok(())
520    }
521}
522
523
524impl<T:IReadInner+ Default> IReadInner for Option<T>{
525    #[inline]
526    fn read_(&mut self, om: &ObjectManager, data: &mut DataReader) -> Result<()> {
527        if data.read_fixed::<u8>()? == 0 {
528            *self = None
529        } else {
530            let mut x = T::default();
531            x.read_(om, data)?;
532            *self = Some(x)
533        }
534        Ok(())
535    }
536}
537
538
539impl <T:IReadInner+Default+Clone> IReadInner for Vec<T>{
540    #[inline]
541    fn read_(&mut self, om: &ObjectManager, data: &mut DataReader) -> Result<()> {
542        self.clear();
543        if size_of::<T>()==1{
544            let b=data.read_var_buf()? as *const [u8] as *const[T];
545            unsafe{
546                self.extend_from_slice(&*b);
547            }
548        }else {
549            let len = data.read_var_integer::<u32>()?;
550            for _ in 0..len {
551                let mut v = T::default();
552                v.read_(om, data)?;
553                self.push(v);
554            }
555        }
556        Ok(())
557    }
558}
559
560impl <K:IReadInner+Default+Eq+Hash,V:IReadInner+Default> IReadInner for HashMap<K,V>{
561    #[inline]
562    fn read_(&mut self, om: &ObjectManager, data: &mut DataReader) -> Result<()> {
563        let len=data.read_var_integer::<u32>()?;
564        self.clear();
565        for _ in 0..len {
566            let mut k=K::default();
567            k.read_(om,data)?;
568            let mut v=V::default();
569            v.read_(om,data)?;
570            self.insert(k,v);
571        }
572        Ok(())
573    }
574}
575impl <K:IReadInner+Default+Ord,V:IReadInner+Default> IReadInner for BTreeMap<K,V>{
576    #[inline]
577    fn read_(&mut self, om: &ObjectManager, data: &mut DataReader) -> Result<()> {
578        let len=data.read_var_integer::<u32>()?;
579        self.clear();
580        for _ in 0..len {
581            let mut k=K::default();
582            k.read_(om,data)?;
583            let mut v=V::default();
584            v.read_(om,data)?;
585            self.insert(k,v);
586        }
587        Ok(())
588    }
589}
590impl <K:IReadInner+Default+Eq+Hash> IReadInner for HashSet<K>{
591    #[inline]
592    fn read_(&mut self, om: &ObjectManager, data: &mut DataReader) -> Result<()> {
593        let len=data.read_var_integer::<u32>()?;
594        self.clear();
595        for _ in 0..len {
596            let mut k=K::default();
597            k.read_(om,data)?;
598            self.insert(k);
599        }
600        Ok(())
601    }
602}
603impl <K:IReadInner+Default+Ord> IReadInner for BTreeSet<K>{
604    #[inline]
605    fn read_(&mut self, om: &ObjectManager, data: &mut DataReader) -> Result<()> {
606        let len=data.read_var_integer::<u32>()?;
607        self.clear();
608        for _ in 0..len {
609            let mut k=K::default();
610            k.read_(om,data)?;
611            self.insert(k);
612        }
613        Ok(())
614    }
615}
616
xxlib/manager.rs

xxlib/
manager.rs
