pbni/
object.rs

1use crate::{
2    bindings::*, invoker::{ObjectEvent, ObjectMethod}, session::AsMethodName, value::FromValueOwned, *
3};
4use std::{
5    cell::{Cell, RefCell}, ops::{Deref, DerefMut}, rc::Rc
6};
7
8/// 对象实例的引用
9pub struct Object<'obj> {
10    ptr: pbobject,
11    group: Cell<Option<pbgroup>>,
12    cls: pbclass,
13    session: Session,
14    _marker: PhantomData<&'obj pbobject>
15}
16
17impl<'obj> Object<'obj> {
18    pub(crate) unsafe fn from_ptr(ptr: pbobject, session: Session) -> Object<'obj> {
19        let group = Cell::new(None);
20        let cls = ffi::pbsession_GetClass(session.as_ptr(), ptr).unwrap();
21        Object {
22            ptr,
23            group,
24            cls,
25            session,
26            _marker: PhantomData
27        }
28    }
29    pub(crate) fn as_ptr(&self) -> pbobject { self.ptr }
30    pub(crate) fn get_group(&self) -> pbgroup {
31        match self.group.get() {
32            Some(group) => group,
33            None => {
34                let group = self.session.get_group(self.cls);
35                self.group.set(group);
36                group.unwrap()
37            }
38        }
39    }
40    pub(crate) fn get_class(&self) -> pbclass { self.cls }
41
42    /// 是否为原生对象 (由pbni-rs导出的对象)
43    /// FIXME: 始终返回false?
44    pub fn is_native(&self) -> bool {
45        unsafe { ffi::pbsession_IsNativeObject(self.session.as_ptr(), self.ptr).into() }
46    }
47
48    /// 获取原生对象的引用
49    ///
50    /// # Safety
51    ///
52    /// 引用类型不能保证始终有效,详情请阅读[内存安全]说明
53    ///
54    /// [内存安全]: ./index.html#内存安全
55    ///
56    /// # Examples
57    ///
58    /// ```
59    /// let obj = obj.get_native_ref::<RustObject>().uwnrap();
60    /// ```
61    #[cfg(any(feature = "nonvisualobject", feature = "visualobject"))]
62    pub unsafe fn get_native_ref<T: UserObject>(&self) -> Result<&'obj T> {
63        /*if !self.is_native() {
64            return Err(PBXRESULT::E_MISMATCHED_DATA_TYPE);
65        }*/
66        let obj = ffi::pbsession_GetNativeInterface(self.session.as_ptr(), self.ptr);
67        if obj.is_none() {
68            return Err(PBXRESULT::E_MISMATCHED_DATA_TYPE);
69        }
70        let ctx = ffi::GetSafeContext(obj.unwrap(), type_id::<T>());
71        if ctx.is_null() {
72            return Err(PBXRESULT::E_MISMATCHED_DATA_TYPE);
73        } else {
74            Ok(&*(ctx as *const T))
75        }
76    }
77
78    /// 获取原生对象的可变引用
79    ///
80    /// # Safety
81    ///
82    /// 引用类型不能保证始终有效,详情请阅读[内存安全]说明
83    ///
84    /// [内存安全]: ./index.html#内存安全
85    ///
86    /// # Examples
87    ///
88    /// ```
89    /// let mut obj = obj.get_native_mut::<RustObject>().uwnrap();
90    /// obj.set_var("is_test","rust").unwrap();
91    /// ```
92    #[cfg(any(feature = "nonvisualobject", feature = "visualobject"))]
93    pub unsafe fn get_native_mut<T: UserObject>(&mut self) -> Result<&'obj mut T> {
94        /*if !self.is_native() {
95            return Err(PBXRESULT::E_MISMATCHED_DATA_TYPE);
96        }*/
97        let obj = ffi::pbsession_GetNativeInterface(self.session.as_ptr(), self.ptr);
98        if obj.is_none() {
99            return Err(PBXRESULT::E_MISMATCHED_DATA_TYPE);
100        }
101        let ctx = ffi::GetSafeContext(obj.unwrap(), type_id::<T>());
102        if ctx.is_null() {
103            return Err(PBXRESULT::E_MISMATCHED_DATA_TYPE);
104        } else {
105            Ok(&mut *(ctx as *mut T))
106        }
107    }
108
109    /// 共享对象
110    pub fn share(&self) -> SharedObject { unsafe { SharedObject::from_ptr(self.ptr, self.session.clone()) } }
111
112    /// 转换为共享对象
113    pub fn into_shared(self) -> SharedObject { self.into() }
114}
115
116/*
117    Instance variable
118*/
119
120/// 实例变量抽象
121pub trait VarId {
122    fn var_id(&self, obj: &Object) -> FieldId;
123}
124
125impl<T: AsPBStr> VarId for T {
126    #[inline]
127    fn var_id(&self, obj: &Object) -> FieldId {
128        let pbstr = self.as_pbstr();
129        obj.get_var_id(pbstr.as_ref())
130            .ok_or_else(|| format!("invalid var {}", pbstr.to_string_lossy()))
131            .unwrap()
132    }
133}
134impl VarId for FieldId {
135    #[inline]
136    fn var_id(&self, _obj: &Object) -> FieldId { *self }
137}
138impl VarId for Option<FieldId> {
139    #[inline]
140    fn var_id(&self, _obj: &Object) -> FieldId { self.unwrap() }
141}
142
143impl<'obj> Object<'obj> {
144    /// 获取实例变量数量
145    ///
146    /// # Examples
147    ///
148    /// ```
149    /// let cnt = obj.get_var_count("is_var");
150    /// //遍历所有变量并输出变量名
151    /// for id in 0..cnt {
152    ///     let fid = unsafe { FieldId::new(id) };
153    ///     println!("field id: {}, name: {}", id, obj.get_var_name(fid));
154    /// }
155    /// ```
156    pub fn get_var_count(&self) -> pbulong {
157        unsafe { ffi::pbsession_GetNumOfFields(self.session.as_ptr(), self.cls) }
158    }
159
160    /// 查找实例变量ID
161    ///
162    /// # Examples
163    ///
164    /// ```
165    /// let fid = obj.get_var_id("is_var").unwrap();
166    /// obj.set_var_str(fid,"rust");
167    /// ```
168    pub fn get_var_id(&self, name: impl AsPBStr) -> Option<FieldId> {
169        unsafe {
170            let fid = ffi::pbsession_GetFieldID(self.session.as_ptr(), self.cls, name.as_pbstr().as_ptr());
171            if fid.is_undefined() {
172                None
173            } else {
174                Some(fid)
175            }
176        }
177    }
178
179    /// 通过实例变量ID获取变量名
180    ///
181    /// # Panics
182    ///
183    /// 访问不存在的变量时会触发Panic
184    ///
185    /// # Examples
186    ///
187    /// ```
188    /// let fid = obj.get_var_id("is_var").unwrap();
189    /// assert_eq!(pbstr!("is_var"),obj.get_var_name(fid));
190    /// ```
191    pub fn get_var_name(&self, fid: impl VarId) -> &PBStr {
192        unsafe {
193            PBStr::from_ptr_str(ffi::pbsession_GetFieldName(
194                self.session.as_ptr(),
195                self.cls,
196                fid.var_id(self)
197            ))
198        }
199    }
200
201    /// 判断是否存在指定实例变量
202    ///
203    /// # Examples
204    ///
205    /// ```
206    /// if object.has_var("is_var") {
207    ///     object.set_var_str("is_var","rust");
208    /// }
209    /// ```
210    pub fn has_var(self, name: impl AsPBStr) -> bool { self.get_var_id(name).is_some() }
211
212    /// 获取变量类型
213    ///
214    /// # Panics
215    ///
216    /// 访问不存在的变量时会触发Panic
217    ///
218    /// # Examples
219    ///
220    /// ```
221    /// if object.get_var_type("is_var") == ValueType::String {
222    ///     object.set_var_str("is_var","rust");
223    /// }
224    /// ```
225    pub fn get_var_type(&self, fid: impl VarId) -> ValueType {
226        unsafe { ffi::pbsession_GetFieldType(self.session.as_ptr(), self.cls, fid.var_id(self)) }
227    }
228
229    /// 判断实例变量是否为NULL
230    ///
231    /// # Panics
232    ///
233    /// 访问不存在的变量时会触发Panic
234    pub fn is_var_null(&self, fid: impl VarId) -> bool {
235        unsafe { ffi::pbsession_IsFieldNull(self.session.as_ptr(), self.ptr, fid.var_id(self)).into() }
236    }
237
238    /// 判断实例变量类型是否为数组
239    ///
240    /// # Panics
241    ///
242    /// 访问不存在的变量时会触发Panic
243    pub fn is_var_array(&self, fid: impl VarId) -> bool {
244        unsafe { ffi::pbsession_IsFieldArray(self.session.as_ptr(), self.cls, fid.var_id(self)).into() }
245    }
246
247    /// 判断实例变量类型是否为对象
248    ///
249    /// # Panics
250    ///
251    /// 访问不存在的变量时会触发Panic
252    pub fn is_var_object(&self, fid: impl VarId) -> bool {
253        unsafe { ffi::pbsession_IsFieldObject(self.session.as_ptr(), self.cls, fid.var_id(self)).into() }
254    }
255
256    /// 刷新实例变量关联的UI状态,如窗口的`title`变量修改后需要调用此函数以刷新UI
257    ///
258    /// # Panics
259    ///
260    /// 访问不存在的变量时会触发Panic
261    ///
262    /// # Examples
263    ///
264    /// ```
265    /// object.set_var_str("title","rust");
266    /// object.update_field("title");
267    /// ```
268    pub fn update_field(&self, fid: impl VarId) -> Result<()> {
269        unsafe { ffi::pbsession_UpdateField(self.session.as_ptr(), self.ptr, fid.var_id(self)).into() }
270    }
271
272    /// 获取`int`类型实例变量值
273    ///
274    /// # Panics
275    ///
276    /// 访问不存在的变量或类型不匹配时会触发Panic
277    pub fn get_var_int(&self, fid: impl VarId) -> Option<pbint> {
278        let fid = fid.var_id(self);
279        assert!(self.get_var_type(fid) == ValueType::Int);
280        unsafe { self.get_var_int_unchecked(fid) }
281    }
282
283    /// 获取`int`类型实例变量值,不检查类型
284    ///
285    /// # Panics
286    ///
287    /// 访问不存在的变量时会触发Panic
288    ///
289    /// # Safety
290    ///
291    /// 类型不兼容时可能会出现未定义行为
292    pub unsafe fn get_var_int_unchecked(&self, fid: impl VarId) -> Option<pbint> {
293        let mut is_null = Default::default();
294        let v = ffi::pbsession_GetIntField(self.session.as_ptr(), self.ptr, fid.var_id(self), &mut is_null);
295        if is_null == true {
296            None
297        } else {
298            Some(v)
299        }
300    }
301
302    /// 获取`uint`类型实例变量值
303    ///
304    /// # Panics
305    ///
306    /// 访问不存在的变量或类型不匹配时会触发Panic
307    pub fn get_var_uint(&self, fid: impl VarId) -> Option<pbuint> {
308        let fid = fid.var_id(self);
309        assert!(self.get_var_type(fid) == ValueType::Uint);
310        unsafe { self.get_var_uint_unchecked(fid) }
311    }
312
313    /// 获取`uint`类型实例变量值,不检查类型
314    ///
315    /// # Panics
316    ///
317    /// 访问不存在的变量时会触发Panic
318    ///
319    /// # Safety
320    ///
321    /// 类型不兼容时可能会出现未定义行为
322    pub unsafe fn get_var_uint_unchecked(&self, fid: impl VarId) -> Option<pbuint> {
323        let mut is_null = Default::default();
324        let v = ffi::pbsession_GetUintField(self.session.as_ptr(), self.ptr, fid.var_id(self), &mut is_null);
325        if is_null == true {
326            None
327        } else {
328            Some(v)
329        }
330    }
331
332    /// 获取`long`类型实例变量值
333    ///
334    /// # Panics
335    ///
336    /// 访问不存在的变量或类型不匹配时会触发Panic
337    pub fn get_var_long(&self, fid: impl VarId) -> Option<pblong> {
338        let fid = fid.var_id(self);
339        assert!(self.get_var_type(fid) == ValueType::Long);
340        unsafe { self.get_var_long_unchecked(fid) }
341    }
342
343    /// 获取`long`类型实例变量值,不检查类型
344    ///
345    /// # Panics
346    ///
347    /// 访问不存在的变量时会触发Panic
348    ///
349    /// # Safety
350    ///
351    /// 类型不兼容时可能会出现未定义行为
352    pub unsafe fn get_var_long_unchecked(&self, fid: impl VarId) -> Option<pblong> {
353        let mut is_null = Default::default();
354        let v = ffi::pbsession_GetLongField(self.session.as_ptr(), self.ptr, fid.var_id(self), &mut is_null);
355        if is_null == true {
356            None
357        } else {
358            Some(v)
359        }
360    }
361
362    /// 获取`ulong`类型实例变量值
363    ///
364    /// # Panics
365    ///
366    /// 访问不存在的变量或类型不匹配时会触发Panic
367    pub fn get_var_ulong(&self, fid: impl VarId) -> Option<pbulong> {
368        let fid = fid.var_id(self);
369        assert!(self.get_var_type(fid) == ValueType::Ulong);
370        unsafe { self.get_var_ulong_unchecked(fid) }
371    }
372
373    /// 获取`ulong`类型实例变量值,不检查类型
374    ///
375    /// # Panics
376    ///
377    /// 访问不存在的变量时会触发Panic
378    ///
379    /// # Safety
380    ///
381    /// 类型不兼容时可能会出现未定义行为
382    pub unsafe fn get_var_ulong_unchecked(&self, fid: impl VarId) -> Option<pbulong> {
383        let mut is_null = Default::default();
384        let v = ffi::pbsession_GetUlongField(self.session.as_ptr(), self.ptr, fid.var_id(self), &mut is_null);
385        if is_null == true {
386            None
387        } else {
388            Some(v)
389        }
390    }
391
392    /// 获取`longlong`类型实例变量值
393    ///
394    /// # Panics
395    ///
396    /// 访问不存在的变量或类型不匹配时会触发Panic
397    pub fn get_var_longlong(&self, fid: impl VarId) -> Option<pblonglong> {
398        let fid = fid.var_id(self);
399        assert!(self.get_var_type(fid) == ValueType::LongLong);
400        unsafe { self.get_var_longlong_unchecked(fid) }
401    }
402
403    /// 获取`longlong`类型实例变量值,不检查类型
404    ///
405    /// # Panics
406    ///
407    /// 访问不存在的变量时会触发Panic
408    ///
409    /// # Safety
410    ///
411    /// 类型不兼容时可能会出现未定义行为
412    pub unsafe fn get_var_longlong_unchecked(&self, fid: impl VarId) -> Option<pblonglong> {
413        let mut is_null = Default::default();
414        let v =
415            ffi::pbsession_GetLongLongField(self.session.as_ptr(), self.ptr, fid.var_id(self), &mut is_null);
416        if is_null == true {
417            None
418        } else {
419            Some(v)
420        }
421    }
422
423    /// 获取`real`类型实例变量值
424    ///
425    /// # Panics
426    ///
427    /// 访问不存在的变量或类型不匹配时会触发Panic
428    pub fn get_var_real(&self, fid: impl VarId) -> Option<pbreal> {
429        let fid = fid.var_id(self);
430        assert!(self.get_var_type(fid) == ValueType::Real);
431        unsafe { self.get_var_real_unchecked(fid) }
432    }
433
434    /// 获取`real`类型实例变量值,不检查类型
435    ///
436    /// # Panics
437    ///
438    /// 访问不存在的变量时会触发Panic
439    ///
440    /// # Safety
441    ///
442    /// 类型不兼容时可能会出现未定义行为
443    pub unsafe fn get_var_real_unchecked(&self, fid: impl VarId) -> Option<pbreal> {
444        let mut is_null = Default::default();
445        let v = ffi::pbsession_GetRealField(self.session.as_ptr(), self.ptr, fid.var_id(self), &mut is_null);
446        if is_null == true {
447            None
448        } else {
449            Some(v)
450        }
451    }
452
453    /// 获取`double`类型实例变量值
454    ///
455    /// # Panics
456    ///
457    /// 访问不存在的变量或类型不匹配时会触发Panic
458    pub fn get_var_double(&self, fid: impl VarId) -> Option<pbdouble> {
459        let fid = fid.var_id(self);
460        assert!(self.get_var_type(fid) == ValueType::Double);
461        unsafe { self.get_var_double_unchecked(fid) }
462    }
463
464    /// 获取`double`类型实例变量值,不检查类型
465    ///
466    /// # Panics
467    ///
468    /// 访问不存在的变量时会触发Panic
469    ///
470    /// # Safety
471    ///
472    /// 类型不兼容时可能会出现未定义行为
473    pub unsafe fn get_var_double_unchecked(&self, fid: impl VarId) -> Option<pbdouble> {
474        let mut is_null = Default::default();
475        let v =
476            ffi::pbsession_GetDoubleField(self.session.as_ptr(), self.ptr, fid.var_id(self), &mut is_null);
477        if is_null == true {
478            None
479        } else {
480            Some(v)
481        }
482    }
483
484    /// 获取`decimal`类型实例变量值
485    ///
486    /// # Panics
487    ///
488    /// 访问不存在的变量或类型不匹配时会触发Panic
489    #[cfg(feature = "decimal")]
490    pub fn get_var_dec(&self, fid: impl VarId) -> Option<Decimal> {
491        let fid = fid.var_id(self);
492        assert!(self.get_var_type(fid) == ValueType::Decimal);
493        unsafe { self.get_var_dec_unchecked(fid) }
494    }
495
496    /// 获取`decimal`类型实例变量值,不检查类型
497    ///
498    /// # Panics
499    ///
500    /// 访问不存在的变量时会触发Panic
501    ///
502    /// # Safety
503    ///
504    /// 类型不兼容时可能会出现未定义行为
505    #[cfg(feature = "decimal")]
506    pub unsafe fn get_var_dec_unchecked(&self, fid: impl VarId) -> Option<Decimal> {
507        let mut is_null = Default::default();
508        let v = ffi::pbsession_GetDecField(self.session.as_ptr(), self.ptr, fid.var_id(self), &mut is_null);
509        if is_null == true {
510            None
511        } else {
512            Some(self.session.get_dec_unchecked(v))
513        }
514    }
515
516    /// 获取`string`类型实例变量的引用
517    ///
518    /// # Panics
519    ///
520    /// 访问不存在的变量或类型不匹配时会触发Panic
521    ///
522    /// # Safety
523    ///
524    /// 引用类型不能保证始终有效,详情请阅读[内存安全]说明
525    ///
526    /// [内存安全]: ./index.html#内存安全
527    pub unsafe fn get_var_str(&self, fid: impl VarId) -> Option<&'obj PBStr> {
528        let fid = fid.var_id(self);
529        assert!(self.get_var_type(fid) == ValueType::String);
530        self.get_var_str_unchecked(fid)
531    }
532
533    /// 获取`string`类型实例变量的引用,不检查类型
534    ///
535    /// # Panics
536    ///
537    /// 访问不存在的变量时会触发Panic
538    ///
539    /// # Safety
540    ///
541    /// - 类型不兼容时可能会出现未定义行为
542    /// - 引用类型不能保证始终有效,详情请阅读[内存安全]说明
543    ///
544    /// [内存安全]: ./index.html#内存安全
545    pub unsafe fn get_var_str_unchecked(&self, fid: impl VarId) -> Option<&'obj PBStr> {
546        let mut is_null = Default::default();
547        let v =
548            ffi::pbsession_GetStringField(self.session.as_ptr(), self.ptr, fid.var_id(self), &mut is_null);
549        if is_null == true {
550            None
551        } else {
552            self.session.get_string_unchecked(v)
553        }
554    }
555
556    /// 获取`string`类型实例变量值
557    ///
558    /// # Panics
559    ///
560    /// 访问不存在的变量或类型不匹配时会触发Panic
561    pub fn get_var_string(&self, fid: impl VarId) -> Option<PBString> {
562        let fid = fid.var_id(self);
563        assert!(self.get_var_type(fid) == ValueType::String);
564        unsafe { self.get_var_string_unchecked(fid) }
565    }
566
567    /// 获取`string`类型实例变量值,不检查类型
568    ///
569    /// # Panics
570    ///
571    /// 访问不存在的变量时会触发Panic
572    ///
573    /// # Safety
574    ///
575    /// 类型不兼容时可能会出现未定义行为
576    pub unsafe fn get_var_string_unchecked(&self, fid: impl VarId) -> Option<PBString> {
577        self.get_var_str_unchecked(fid).map(|v| v.to_ucstring())
578    }
579
580    /// 获取`boolean`类型实例变量值
581    ///
582    /// # Panics
583    ///
584    /// 访问不存在的变量或类型不匹配时会触发Panic
585    pub fn get_var_bool(&self, fid: impl VarId) -> Option<bool> {
586        let fid = fid.var_id(self);
587        assert!(self.get_var_type(fid) == ValueType::Boolean);
588        unsafe { self.get_var_bool_unchecked(fid) }
589    }
590
591    /// 获取`boolean`类型实例变量值,不检查类型
592    ///
593    /// # Panics
594    ///
595    /// 访问不存在的变量时会触发Panic
596    ///
597    /// # Safety
598    ///
599    /// 类型不兼容时可能会出现未定义行为
600    pub unsafe fn get_var_bool_unchecked(&self, fid: impl VarId) -> Option<bool> {
601        let mut is_null = Default::default();
602        let v = ffi::pbsession_GetBoolField(self.session.as_ptr(), self.ptr, fid.var_id(self), &mut is_null);
603        if is_null == true {
604            None
605        } else {
606            Some(v.into())
607        }
608    }
609
610    /// 获取`blob`类型实例变量的引用
611    ///
612    /// # Panics
613    ///
614    /// 访问不存在的变量或类型不匹配时会触发Panic
615    ///
616    /// # Safety
617    ///
618    /// 引用类型不能保证始终有效,详情请阅读[内存安全]说明
619    ///
620    /// [内存安全]: ./index.html#内存安全
621    pub unsafe fn get_var_blob(&self, fid: impl VarId) -> Option<&'obj [u8]> {
622        let fid = fid.var_id(self);
623        assert!(self.get_var_type(fid) == ValueType::Blob);
624        self.get_var_blob_unchecked(fid)
625    }
626
627    /// 获取`blob`类型实例变量的引用,不检查类型
628    ///
629    /// # Panics
630    ///
631    /// 访问不存在的变量时会触发Panic
632    ///
633    /// # Safety
634    ///
635    /// - 类型不兼容时可能会出现未定义行为
636    /// - 引用类型不能保证始终有效,详情请阅读[内存安全]说明
637    ///
638    /// [内存安全]: ./index.html#内存安全
639    pub unsafe fn get_var_blob_unchecked(&self, fid: impl VarId) -> Option<&'obj [u8]> {
640        let mut is_null = Default::default();
641        let v = ffi::pbsession_GetBlobField(self.session.as_ptr(), self.ptr, fid.var_id(self), &mut is_null);
642        if is_null == true {
643            None
644        } else {
645            Some(self.session.get_blob_unchecked(v))
646        }
647    }
648
649    /// 获取`date`类型实例变量值
650    ///
651    /// # Panics
652    ///
653    /// 访问不存在的变量或类型不匹配时会触发Panic
654    #[cfg(feature = "datetime")]
655    pub fn get_var_date(&self, fid: impl VarId) -> Option<NaiveDate> {
656        let fid = fid.var_id(self);
657        assert!(self.get_var_type(fid) == ValueType::Date);
658        unsafe { self.get_var_date_unchecked(fid) }
659    }
660
661    /// 获取`date`类型实例变量值,不检查类型
662    ///
663    /// # Panics
664    ///
665    /// 访问不存在的变量时会触发Panic
666    ///
667    /// # Safety
668    ///
669    /// 类型不兼容时可能会出现未定义行为
670    #[cfg(feature = "datetime")]
671    pub unsafe fn get_var_date_unchecked(&self, fid: impl VarId) -> Option<NaiveDate> {
672        let mut is_null = Default::default();
673        let v = ffi::pbsession_GetDateField(self.session.as_ptr(), self.ptr, fid.var_id(self), &mut is_null);
674        if is_null == true {
675            None
676        } else {
677            Some(self.session.get_date_unchecked(v))
678        }
679    }
680
681    /// 获取`time`类型实例变量值
682    ///
683    /// # Panics
684    ///
685    /// 访问不存在的变量或类型不匹配时会触发Panic
686    #[cfg(feature = "datetime")]
687    pub fn get_var_time(&self, fid: impl VarId) -> Option<NaiveTime> {
688        let fid = fid.var_id(self);
689        assert!(self.get_var_type(fid) == ValueType::Time);
690        unsafe { self.get_var_time_unchecked(fid) }
691    }
692
693    /// 获取`time`类型实例变量值,不检查类型
694    ///
695    /// # Panics
696    ///
697    /// 访问不存在的变量时会触发Panic
698    ///
699    /// # Safety
700    ///
701    /// 类型不兼容时可能会出现未定义行为
702    #[cfg(feature = "datetime")]
703    pub unsafe fn get_var_time_unchecked(&self, fid: impl VarId) -> Option<NaiveTime> {
704        let mut is_null = Default::default();
705        let v = ffi::pbsession_GetTimeField(self.session.as_ptr(), self.ptr, fid.var_id(self), &mut is_null);
706        if is_null == true {
707            None
708        } else {
709            Some(self.session.get_time_unchecked(v))
710        }
711    }
712
713    /// 获取`datetime`类型实例变量值
714    ///
715    /// # Panics
716    ///
717    /// 访问不存在的变量或类型不匹配时会触发Panic
718    #[cfg(feature = "datetime")]
719    pub fn get_var_datetime(&self, fid: impl VarId) -> Option<NaiveDateTime> {
720        let fid = fid.var_id(self);
721        assert!(self.get_var_type(fid) == ValueType::DateTime);
722        unsafe { self.get_var_datetime_unchecked(fid) }
723    }
724
725    /// 获取`datetime`类型实例变量值,不检查类型
726    ///
727    /// # Panics
728    ///
729    /// 访问不存在的变量时会触发Panic
730    ///
731    /// # Safety
732    ///
733    /// 类型不兼容时可能会出现未定义行为
734    #[cfg(feature = "datetime")]
735    pub unsafe fn get_var_datetime_unchecked(&self, fid: impl VarId) -> Option<NaiveDateTime> {
736        let mut is_null = Default::default();
737        let v =
738            ffi::pbsession_GetDateTimeField(self.session.as_ptr(), self.ptr, fid.var_id(self), &mut is_null);
739        if is_null == true {
740            None
741        } else {
742            Some(self.session.get_datetime_unchecked(v))
743        }
744    }
745
746    /// 获取`char`类型实例变量值
747    ///
748    /// # Panics
749    ///
750    /// 访问不存在的变量或类型不匹配时会触发Panic
751    pub fn get_var_char(&self, fid: impl VarId) -> Option<PBChar> {
752        let fid = fid.var_id(self);
753        assert!(self.get_var_type(fid) == ValueType::Char);
754        unsafe { self.get_var_char_unchecked(fid) }
755    }
756
757    /// 获取`char`类型实例变量值,不检查类型
758    ///
759    /// # Panics
760    ///
761    /// 访问不存在的变量时会触发Panic
762    ///
763    /// # Safety
764    ///
765    /// 类型不兼容时可能会出现未定义行为
766    pub unsafe fn get_var_char_unchecked(&self, fid: impl VarId) -> Option<PBChar> {
767        let mut is_null = Default::default();
768        let v = ffi::pbsession_GetCharField(self.session.as_ptr(), self.ptr, fid.var_id(self), &mut is_null);
769        if is_null == true {
770            None
771        } else {
772            Some(v)
773        }
774    }
775
776    /// 获取`byte`类型实例变量值
777    ///
778    /// # Panics
779    ///
780    /// 访问不存在的变量或类型不匹配时会触发Panic
781    pub fn get_var_byte(&self, fid: impl VarId) -> Option<pbbyte> {
782        let fid = fid.var_id(self);
783        assert!(self.get_var_type(fid) == ValueType::Byte);
784        unsafe { self.get_var_byte_unchecked(fid) }
785    }
786
787    /// 获取`byte`类型实例变量值,不检查类型
788    ///
789    /// # Panics
790    ///
791    /// 访问不存在的变量时会触发Panic
792    ///
793    /// # Safety
794    ///
795    /// 类型不兼容时可能会出现未定义行为
796    pub unsafe fn get_var_byte_unchecked(&self, fid: impl VarId) -> Option<pbbyte> {
797        let mut is_null = Default::default();
798        let v = ffi::pbsession_GetByteField(self.session.as_ptr(), self.ptr, fid.var_id(self), &mut is_null);
799        if is_null == true {
800            None
801        } else {
802            Some(v)
803        }
804    }
805
806    /// 获取对象类型实例变量的引用
807    ///
808    /// # Panics
809    ///
810    /// 访问不存在的变量或类型不匹配时会触发Panic
811    ///
812    /// # Safety
813    ///
814    /// 引用类型不能保证始终有效,详情请阅读[内存安全]说明
815    ///
816    /// [内存安全]: ./index.html#内存安全
817    pub unsafe fn get_var_object(&self, fid: impl VarId) -> Option<Object<'obj>> {
818        let fid = fid.var_id(self);
819        assert!(self.is_var_object(fid));
820        self.get_var_object_unchecked(fid)
821    }
822
823    /// 获取对象类型实例变量的引用,不检查类型
824    ///
825    /// # Panics
826    ///
827    /// 访问不存在的变量时会触发Panic
828    ///
829    /// # Safety
830    ///
831    /// - 类型不兼容时可能会出现未定义行为
832    /// - 引用类型不能保证始终有效,详情请阅读[内存安全]说明
833    ///
834    /// [内存安全]: ./index.html#内存安全
835    pub unsafe fn get_var_object_unchecked(&self, fid: impl VarId) -> Option<Object<'obj>> {
836        let mut is_null = Default::default();
837        let v =
838            ffi::pbsession_GetObjectField(self.session.as_ptr(), self.ptr, fid.var_id(self), &mut is_null);
839        if is_null == true {
840            None
841        } else {
842            Some(Object::from_ptr(v, self.session.clone()))
843        }
844    }
845
846    /// 获取数组类型实例变量的引用
847    ///
848    /// # Panics
849    ///
850    /// 访问不存在的变量或类型不匹配时会触发Panic
851    ///
852    /// # Safety
853    ///
854    /// 引用类型不能保证始终有效,详情请阅读[内存安全]说明
855    ///
856    /// [内存安全]: ./index.html#内存安全
857    pub unsafe fn get_var_array(&self, fid: impl VarId) -> Option<Array<'obj>> {
858        let fid = fid.var_id(self);
859        assert!(self.is_var_array(fid));
860        self.get_var_array_unchecked(fid)
861    }
862
863    /// 获取数组类型实例变量的引用,不检查类型
864    ///
865    /// # Panics
866    ///
867    /// 访问不存在的变量时会触发Panic
868    ///
869    /// # Safety
870    ///
871    /// - 类型不兼容时可能会出现未定义行为
872    /// - 引用类型不能保证始终有效,详情请阅读[内存安全]说明
873    ///
874    /// [内存安全]: ./index.html#内存安全
875    pub unsafe fn get_var_array_unchecked(&self, fid: impl VarId) -> Option<Array<'obj>> {
876        let mut is_null = Default::default();
877        let v = ffi::pbsession_GetArrayField(self.session.as_ptr(), self.ptr, fid.var_id(self), &mut is_null);
878        if is_null == true {
879            None
880        } else {
881            Some(Array::from_ptr(v, self.is_var_object(fid), self.session.clone()))
882        }
883    }
884
885    /// 获取`any`类型实例变量的引用
886    ///
887    /// # Panics
888    ///
889    /// 访问不存在的变量或类型不匹配时会触发Panic
890    ///
891    /// # Safety
892    ///
893    /// 引用类型不能保证始终有效,详情请阅读[内存安全]说明
894    ///
895    /// [内存安全]: ./index.html#内存安全
896    pub unsafe fn get_var_any(&self, fid: impl VarId) -> Option<Value<'obj>> {
897        let fid = fid.var_id(self);
898        assert!(self.get_var_type(fid) == ValueType::Any);
899        self.get_var_any_unchecked(fid)
900    }
901
902    /// 获取`any`类型实例变量的引用,不检查类型
903    ///
904    /// # Panics
905    ///
906    /// 访问不存在的变量时会触发Panic
907    ///
908    /// # Safety
909    ///
910    /// - 类型不兼容时可能会出现未定义行为
911    /// - 引用类型不能保证始终有效,详情请阅读[内存安全]说明
912    ///
913    /// [内存安全]: ./index.html#内存安全
914    pub unsafe fn get_var_any_unchecked(&self, fid: impl VarId) -> Option<Value<'obj>> {
915        let mut is_null = Default::default();
916        let v = ffi::pbsession_GetPBAnyField(self.session.as_ptr(), self.ptr, fid.var_id(self), &mut is_null);
917        if is_null == true {
918            None
919        } else {
920            Some(Value::from_ptr(v, self.session.clone()))
921        }
922    }
923
924    /// 设置实例变量的值为NULL
925    ///
926    /// # Panics
927    ///
928    /// 访问不存在的变量时会触发Panic
929    pub fn set_var_to_null(&self, fid: impl VarId) {
930        unsafe { ffi::pbsession_SetFieldToNull(self.session.as_ptr(), self.ptr, fid.var_id(self)) }
931    }
932
933    /// 设置`int`类型实例变量的值
934    ///
935    /// # Panics
936    ///
937    /// 访问不存在的变量或类型不匹配时会触发Panic
938    pub fn set_var_int(&mut self, fid: impl VarId, value: pbint) -> Result<()> {
939        let fid = fid.var_id(self);
940        assert!(self.get_var_type(fid) == ValueType::Int);
941        unsafe { ffi::pbsession_SetIntField(self.session.as_ptr(), self.ptr, fid, value).into() }
942    }
943
944    /// 设置`int`类型实例变量的值,不检查类型
945    ///
946    /// # Panics
947    ///
948    /// 访问不存在的变量时会触发Panic
949    ///
950    /// # Safety
951    ///
952    /// 类型不兼容时可能会出现未定义行为
953    pub unsafe fn set_var_int_unchecked(&mut self, fid: impl VarId, value: pbint) -> Result<()> {
954        ffi::pbsession_SetIntField(self.session.as_ptr(), self.ptr, fid.var_id(self), value).into()
955    }
956
957    /// 设置`uint`类型实例变量的值
958    ///
959    /// # Panics
960    ///
961    /// 访问不存在的变量或类型不匹配时会触发Panic
962    pub fn set_var_uint(&mut self, fid: impl VarId, value: pbuint) -> Result<()> {
963        let fid = fid.var_id(self);
964        assert!(self.get_var_type(fid) == ValueType::Uint);
965        unsafe { ffi::pbsession_SetUintField(self.session.as_ptr(), self.ptr, fid, value).into() }
966    }
967
968    /// 设置`uint`类型实例变量的值,不检查类型
969    ///
970    /// # Panics
971    ///
972    /// 访问不存在的变量时会触发Panic
973    ///
974    /// # Safety
975    ///
976    /// 类型不兼容时可能会出现未定义行为
977    pub unsafe fn set_var_uint_unchecked(&mut self, fid: impl VarId, value: pbuint) -> Result<()> {
978        ffi::pbsession_SetUintField(self.session.as_ptr(), self.ptr, fid.var_id(self), value).into()
979    }
980
981    /// 设置`long`类型实例变量的值
982    ///
983    /// # Panics
984    ///
985    /// 访问不存在的变量或类型不匹配时会触发Panic
986    pub fn set_var_long(&mut self, fid: impl VarId, value: pblong) -> Result<()> {
987        let fid = fid.var_id(self);
988        assert!(self.get_var_type(fid) == ValueType::Long);
989        unsafe { ffi::pbsession_SetLongField(self.session.as_ptr(), self.ptr, fid, value).into() }
990    }
991
992    /// 设置`long`类型实例变量的值,不检查类型
993    ///
994    /// # Panics
995    ///
996    /// 访问不存在的变量时会触发Panic
997    ///
998    /// # Safety
999    ///
1000    /// 类型不兼容时可能会出现未定义行为
1001    pub unsafe fn set_var_long_unchecked(&mut self, fid: impl VarId, value: pblong) -> Result<()> {
1002        ffi::pbsession_SetLongField(self.session.as_ptr(), self.ptr, fid.var_id(self), value).into()
1003    }
1004
1005    /// 设置`ulong`类型实例变量的值
1006    ///
1007    /// # Panics
1008    ///
1009    /// 访问不存在的变量或类型不匹配时会触发Panic
1010    pub fn set_var_ulong(&mut self, fid: impl VarId, value: pbulong) -> Result<()> {
1011        let fid = fid.var_id(self);
1012        assert!(self.get_var_type(fid) == ValueType::Ulong);
1013        unsafe { ffi::pbsession_SetUlongField(self.session.as_ptr(), self.ptr, fid, value).into() }
1014    }
1015
1016    /// 设置`ulong`类型实例变量的值,不检查类型
1017    ///
1018    /// # Panics
1019    ///
1020    /// 访问不存在的变量时会触发Panic
1021    ///
1022    /// # Safety
1023    ///
1024    /// 类型不兼容时可能会出现未定义行为
1025    pub unsafe fn set_var_ulong_unchecked(&mut self, fid: impl VarId, value: pbulong) -> Result<()> {
1026        ffi::pbsession_SetUlongField(self.session.as_ptr(), self.ptr, fid.var_id(self), value).into()
1027    }
1028
1029    /// 设置`longlong`类型实例变量的值
1030    ///
1031    /// # Panics
1032    ///
1033    /// 访问不存在的变量或类型不匹配时会触发Panic
1034    pub fn set_var_longlong(&mut self, fid: impl VarId, value: pblonglong) -> Result<()> {
1035        let fid = fid.var_id(self);
1036        assert!(self.get_var_type(fid) == ValueType::LongLong);
1037        unsafe { ffi::pbsession_SetLongLongField(self.session.as_ptr(), self.ptr, fid, value).into() }
1038    }
1039
1040    /// 设置`longlong`类型实例变量的值,不检查类型
1041    ///
1042    /// # Panics
1043    ///
1044    /// 访问不存在的变量时会触发Panic
1045    ///
1046    /// # Safety
1047    ///
1048    /// 类型不兼容时可能会出现未定义行为
1049    pub unsafe fn set_var_longlong_unchecked(&mut self, fid: impl VarId, value: pblonglong) -> Result<()> {
1050        ffi::pbsession_SetLongLongField(self.session.as_ptr(), self.ptr, fid.var_id(self), value).into()
1051    }
1052
1053    /// 设置`real`类型实例变量的值
1054    ///
1055    /// # Panics
1056    ///
1057    /// 访问不存在的变量或类型不匹配时会触发Panic
1058    pub fn set_var_real(&mut self, fid: impl VarId, value: pbreal) -> Result<()> {
1059        let fid = fid.var_id(self);
1060        assert!(self.get_var_type(fid) == ValueType::Real);
1061        unsafe { ffi::pbsession_SetRealField(self.session.as_ptr(), self.ptr, fid, value).into() }
1062    }
1063
1064    /// 设置`real`类型实例变量的值,不检查类型
1065    ///
1066    /// # Panics
1067    ///
1068    /// 访问不存在的变量时会触发Panic
1069    ///
1070    /// # Safety
1071    ///
1072    /// 类型不兼容时可能会出现未定义行为
1073    pub unsafe fn set_var_real_unchecked(&mut self, fid: impl VarId, value: pbreal) -> Result<()> {
1074        ffi::pbsession_SetRealField(self.session.as_ptr(), self.ptr, fid.var_id(self), value).into()
1075    }
1076
1077    /// 设置`double`类型实例变量的值
1078    ///
1079    /// # Panics
1080    ///
1081    /// 访问不存在的变量或类型不匹配时会触发Panic
1082    pub fn set_var_double(&mut self, fid: impl VarId, value: pbdouble) -> Result<()> {
1083        let fid = fid.var_id(self);
1084        assert!(self.get_var_type(fid) == ValueType::Double);
1085        unsafe { ffi::pbsession_SetDoubleField(self.session.as_ptr(), self.ptr, fid, value).into() }
1086    }
1087
1088    /// 设置`double`类型实例变量的值,不检查类型
1089    ///
1090    /// # Panics
1091    ///
1092    /// 访问不存在的变量时会触发Panic
1093    ///
1094    /// # Safety
1095    ///
1096    /// 类型不兼容时可能会出现未定义行为
1097    pub unsafe fn set_var_double_unchecked(&mut self, fid: impl VarId, value: pbdouble) -> Result<()> {
1098        ffi::pbsession_SetDoubleField(self.session.as_ptr(), self.ptr, fid.var_id(self), value).into()
1099    }
1100
1101    /// 设置`decimal`类型实例变量的值
1102    ///
1103    /// # Panics
1104    ///
1105    /// 访问不存在的变量或类型不匹配时会触发Panic
1106    #[cfg(feature = "decimal")]
1107    pub fn set_var_dec(&mut self, fid: impl VarId, value: Decimal) -> Result<()> {
1108        let fid = fid.var_id(self);
1109        assert!(self.get_var_type(fid) == ValueType::Decimal);
1110        unsafe {
1111            ffi::pbsession_SetDecField(self.session.as_ptr(), self.ptr, fid, self.session.new_pbdec(value))
1112                .into()
1113        }
1114    }
1115
1116    /// 设置`decimal`类型实例变量的值,不检查类型
1117    ///
1118    /// # Panics
1119    ///
1120    /// 访问不存在的变量时会触发Panic
1121    ///
1122    /// # Safety
1123    ///
1124    /// 类型不兼容时可能会出现未定义行为
1125    #[cfg(feature = "decimal")]
1126    pub unsafe fn set_var_dec_unchecked(&mut self, fid: impl VarId, value: Decimal) -> Result<()> {
1127        ffi::pbsession_SetDecField(
1128            self.session.as_ptr(),
1129            self.ptr,
1130            fid.var_id(self),
1131            self.session.new_pbdec(value)
1132        )
1133        .into()
1134    }
1135
1136    /// 设置`string`类型实例变量的值
1137    ///
1138    /// # Panics
1139    ///
1140    /// 访问不存在的变量或类型不匹配时会触发Panic
1141    pub fn set_var_str(&mut self, fid: impl VarId, value: impl AsPBStr) -> Result<()> {
1142        let fid = fid.var_id(self);
1143        assert!(self.get_var_type(fid) == ValueType::String);
1144        unsafe {
1145            ffi::pbsession_SetStringField(self.session.as_ptr(), self.ptr, fid, value.as_pbstr().as_ptr())
1146                .into()
1147        }
1148    }
1149
1150    /// 设置`string`类型实例变量的值,不检查类型
1151    ///
1152    /// # Panics
1153    ///
1154    /// 访问不存在的变量时会触发Panic
1155    ///
1156    /// # Safety
1157    ///
1158    /// 类型不兼容时可能会出现未定义行为
1159    pub unsafe fn set_var_str_unchecked(&mut self, fid: impl VarId, value: impl AsPBStr) -> Result<()> {
1160        ffi::pbsession_SetStringField(
1161            self.session.as_ptr(),
1162            self.ptr,
1163            fid.var_id(self),
1164            value.as_pbstr().as_ptr()
1165        )
1166        .into()
1167    }
1168
1169    /// 设置`boolean`类型实例变量的值
1170    ///
1171    /// # Panics
1172    ///
1173    /// 访问不存在的变量或类型不匹配时会触发Panic
1174    pub fn set_var_bool(&mut self, fid: impl VarId, value: bool) -> Result<()> {
1175        let fid = fid.var_id(self);
1176        assert!(self.get_var_type(fid) == ValueType::Boolean);
1177        unsafe { ffi::pbsession_SetBoolField(self.session.as_ptr(), self.ptr, fid, value.into()).into() }
1178    }
1179
1180    /// 设置`boolean`类型实例变量的值,不检查类型
1181    ///
1182    /// # Panics
1183    ///
1184    /// 访问不存在的变量时会触发Panic
1185    ///
1186    /// # Safety
1187    ///
1188    /// 类型不兼容时可能会出现未定义行为
1189    pub unsafe fn set_var_bool_unchecked(&mut self, fid: impl VarId, value: bool) -> Result<()> {
1190        ffi::pbsession_SetBoolField(self.session.as_ptr(), self.ptr, fid.var_id(self), value.into()).into()
1191    }
1192
1193    /// 设置`blob`类型实例变量的值
1194    ///
1195    /// # Panics
1196    ///
1197    /// 访问不存在的变量或类型不匹配时会触发Panic
1198    pub fn set_var_blob(&mut self, fid: impl VarId, value: impl AsRef<[u8]>) -> Result<()> {
1199        let fid = fid.var_id(self);
1200        assert!(self.get_var_type(fid) == ValueType::Blob);
1201        unsafe {
1202            ffi::pbsession_SetBlobField(self.session.as_ptr(), self.ptr, fid, self.session.new_pbblob(value))
1203                .into()
1204        }
1205    }
1206
1207    /// 设置`blob`类型实例变量的值,不检查类型
1208    ///
1209    /// # Panics
1210    ///
1211    /// 访问不存在的变量时会触发Panic
1212    ///
1213    /// # Safety
1214    ///
1215    /// 类型不兼容时可能会出现未定义行为
1216    pub unsafe fn set_var_blob_unchecked(&mut self, fid: impl VarId, value: impl AsRef<[u8]>) -> Result<()> {
1217        let value = value.as_ref();
1218        if value.is_empty() {
1219            return Err(PBXRESULT::E_OUTOF_MEMORY);
1220        }
1221        ffi::pbsession_SetBlobField(
1222            self.session.as_ptr(),
1223            self.ptr,
1224            fid.var_id(self),
1225            self.session.new_pbblob(value)
1226        )
1227        .into()
1228    }
1229
1230    /// 设置`date`类型实例变量的值
1231    ///
1232    /// # Panics
1233    ///
1234    /// 访问不存在的变量或类型不匹配时会触发Panic
1235    #[cfg(feature = "datetime")]
1236    pub fn set_var_date(&mut self, fid: impl VarId, value: NaiveDate) -> Result<()> {
1237        let fid = fid.var_id(self);
1238        assert!(self.get_var_type(fid) == ValueType::Date);
1239        unsafe {
1240            ffi::pbsession_SetDateField(self.session.as_ptr(), self.ptr, fid, self.session.new_pbdate(value))
1241                .into()
1242        }
1243    }
1244
1245    /// 设置`date`类型实例变量的值,不检查类型
1246    ///
1247    /// # Panics
1248    ///
1249    /// 访问不存在的变量时会触发Panic
1250    ///
1251    /// # Safety
1252    ///
1253    /// 类型不兼容时可能会出现未定义行为
1254    #[cfg(feature = "datetime")]
1255    pub unsafe fn set_var_date_unchecked(&mut self, fid: impl VarId, value: NaiveDate) -> Result<()> {
1256        ffi::pbsession_SetDateField(
1257            self.session.as_ptr(),
1258            self.ptr,
1259            fid.var_id(self),
1260            self.session.new_pbdate(value)
1261        )
1262        .into()
1263    }
1264
1265    /// 设置`time`类型实例变量的值
1266    ///
1267    /// # Panics
1268    ///
1269    /// 访问不存在的变量或类型不匹配时会触发Panic
1270    #[cfg(feature = "datetime")]
1271    pub fn set_var_time(&mut self, fid: impl VarId, value: NaiveTime) -> Result<()> {
1272        let fid = fid.var_id(self);
1273        assert!(self.get_var_type(fid) == ValueType::Time);
1274        unsafe {
1275            ffi::pbsession_SetTimeField(self.session.as_ptr(), self.ptr, fid, self.session.new_pbtime(value))
1276                .into()
1277        }
1278    }
1279
1280    /// 设置`time`类型实例变量的值,不检查类型
1281    ///
1282    /// # Panics
1283    ///
1284    /// 访问不存在的变量时会触发Panic
1285    ///
1286    /// # Safety
1287    ///
1288    /// 类型不兼容时可能会出现未定义行为
1289    #[cfg(feature = "datetime")]
1290    pub unsafe fn set_var_time_unchecked(&mut self, fid: impl VarId, value: NaiveTime) -> Result<()> {
1291        ffi::pbsession_SetTimeField(
1292            self.session.as_ptr(),
1293            self.ptr,
1294            fid.var_id(self),
1295            self.session.new_pbtime(value)
1296        )
1297        .into()
1298    }
1299
1300    /// 设置`datetime`类型实例变量的值
1301    ///
1302    /// # Panics
1303    ///
1304    /// 访问不存在的变量或类型不匹配时会触发Panic
1305    #[cfg(feature = "datetime")]
1306    pub fn set_var_datetime(&mut self, fid: impl VarId, value: NaiveDateTime) -> Result<()> {
1307        let fid = fid.var_id(self);
1308        assert!(self.get_var_type(fid) == ValueType::DateTime);
1309        unsafe {
1310            ffi::pbsession_SetDateTimeField(
1311                self.session.as_ptr(),
1312                self.ptr,
1313                fid,
1314                self.session.new_pbdatetime(value)
1315            )
1316            .into()
1317        }
1318    }
1319
1320    /// 设置`datetime`类型实例变量的值,不检查类型
1321    ///
1322    /// # Panics
1323    ///
1324    /// 访问不存在的变量时会触发Panic
1325    ///
1326    /// # Safety
1327    ///
1328    /// 类型不兼容时可能会出现未定义行为
1329    #[cfg(feature = "datetime")]
1330    pub unsafe fn set_var_datetime_unchecked(&mut self, fid: impl VarId, value: NaiveDateTime) -> Result<()> {
1331        ffi::pbsession_SetDateTimeField(
1332            self.session.as_ptr(),
1333            self.ptr,
1334            fid.var_id(self),
1335            self.session.new_pbdatetime(value)
1336        )
1337        .into()
1338    }
1339
1340    /// 设置`char`类型实例变量的值
1341    ///
1342    /// # Panics
1343    ///
1344    /// 访问不存在的变量或类型不匹配时会触发Panic
1345    pub fn set_var_char(&mut self, fid: impl VarId, value: PBChar) -> Result<()> {
1346        let fid = fid.var_id(self);
1347        assert!(self.get_var_type(fid) == ValueType::Char);
1348        unsafe { ffi::pbsession_SetCharField(self.session.as_ptr(), self.ptr, fid, value).into() }
1349    }
1350
1351    /// 设置`char`类型实例变量的值,不检查类型
1352    ///
1353    /// # Panics
1354    ///
1355    /// 访问不存在的变量时会触发Panic
1356    ///
1357    /// # Safety
1358    ///
1359    /// 类型不兼容时可能会出现未定义行为
1360    pub unsafe fn set_var_char_unchecked(&mut self, fid: impl VarId, value: PBChar) -> Result<()> {
1361        ffi::pbsession_SetCharField(self.session.as_ptr(), self.ptr, fid.var_id(self), value).into()
1362    }
1363
1364    /// 设置`byte`类型实例变量的值
1365    ///
1366    /// # Panics
1367    ///
1368    /// 访问不存在的变量或类型不匹配时会触发Panic
1369    pub fn set_var_byte(&mut self, fid: impl VarId, value: pbbyte) -> Result<()> {
1370        let fid = fid.var_id(self);
1371        assert!(self.get_var_type(fid) == ValueType::Byte);
1372        unsafe { ffi::pbsession_SetByteField(self.session.as_ptr(), self.ptr, fid, value).into() }
1373    }
1374
1375    /// 设置`byte`类型实例变量的值,不检查类型
1376    ///
1377    /// # Panics
1378    ///
1379    /// 访问不存在的变量时会触发Panic
1380    ///
1381    /// # Safety
1382    ///
1383    /// 类型不兼容时可能会出现未定义行为
1384    pub unsafe fn set_var_byte_unchecked(&mut self, fid: impl VarId, value: pbbyte) -> Result<()> {
1385        ffi::pbsession_SetByteField(self.session.as_ptr(), self.ptr, fid.var_id(self), value).into()
1386    }
1387
1388    /// 设置对象类型实例变量的值
1389    ///
1390    /// # Panics
1391    ///
1392    /// 访问不存在的变量或类型不匹配时会触发Panic
1393    pub fn set_var_object(&mut self, fid: impl VarId, value: &Object) -> Result<()> {
1394        let fid = fid.var_id(self);
1395        assert!(self.is_var_object(fid));
1396        unsafe { ffi::pbsession_SetObjectField(self.session.as_ptr(), self.ptr, fid, value.as_ptr()).into() }
1397    }
1398
1399    /// 设置对象类型实例变量的值,不检查类型
1400    ///
1401    /// # Panics
1402    ///
1403    /// 访问不存在的变量时会触发Panic
1404    ///
1405    /// # Safety
1406    ///
1407    /// 类型不兼容时可能会出现未定义行为
1408    pub unsafe fn set_var_object_unchecked(&mut self, fid: impl VarId, value: &Object) -> Result<()> {
1409        ffi::pbsession_SetObjectField(self.session.as_ptr(), self.ptr, fid.var_id(self), value.as_ptr())
1410            .into()
1411    }
1412
1413    /// 设置数组类型实例变量的值
1414    ///
1415    /// # Panics
1416    ///
1417    /// 访问不存在的变量或类型不匹配时会触发Panic
1418    pub fn set_var_array(&mut self, fid: impl VarId, value: &Array) -> Result<()> {
1419        let fid = fid.var_id(self);
1420        assert!(self.is_var_array(fid));
1421        unsafe { ffi::pbsession_SetArrayField(self.session.as_ptr(), self.ptr, fid, value.as_ptr()).into() }
1422    }
1423
1424    /// 设置数组类型实例变量的值,不检查类型
1425    ///
1426    /// # Panics
1427    ///
1428    /// 访问不存在的变量时会触发Panic
1429    ///
1430    /// # Safety
1431    ///
1432    /// 类型不兼容时可能会出现未定义行为
1433    pub unsafe fn set_var_array_unchecked(&mut self, fid: impl VarId, value: &Array) -> Result<()> {
1434        ffi::pbsession_SetArrayField(self.session.as_ptr(), self.ptr, fid.var_id(self), value.as_ptr()).into()
1435    }
1436}
1437
1438/*
1439    Shared variable
1440*/
1441
1442/// 共享(静态)变量ID抽象
1443pub trait SharedVarId {
1444    fn var_id(&self, obj: &Object) -> FieldId;
1445}
1446
1447impl<T: AsPBStr> SharedVarId for T {
1448    #[inline]
1449    fn var_id(&self, obj: &Object) -> FieldId {
1450        let pbstr = self.as_pbstr();
1451        obj.get_shared_var_id(pbstr.as_ref())
1452            .ok_or_else(|| format!("invalid shared var {}", pbstr.to_string_lossy()))
1453            .unwrap()
1454    }
1455}
1456impl SharedVarId for FieldId {
1457    #[inline]
1458    fn var_id(&self, _obj: &Object) -> FieldId { *self }
1459}
1460impl SharedVarId for Option<FieldId> {
1461    #[inline]
1462    fn var_id(&self, _obj: &Object) -> FieldId { self.unwrap() }
1463}
1464
1465impl<'obj> Object<'obj> {
1466    /// 获取共享(静态)变量ID
1467    ///
1468    /// # Examples
1469    ///
1470    /// ```
1471    /// let fid = object.get_shared_var_id("ss_var").unwrap();
1472    /// object.set_shared_var_str(fid,"rust");
1473    /// ```
1474    pub fn get_shared_var_id(&self, name: impl AsPBStr) -> Option<FieldId> {
1475        unsafe {
1476            let fid = ffi::pbsession_GetSharedVarID(
1477                self.session.as_ptr(),
1478                self.get_group(),
1479                name.as_pbstr().as_ptr()
1480            );
1481            if fid.is_undefined() {
1482                None
1483            } else {
1484                Some(fid)
1485            }
1486        }
1487    }
1488
1489    /// 判断是否存在指定共享(静态)变量
1490    ///
1491    /// # Examples
1492    ///
1493    /// ```
1494    /// if object.has_shared_var("ss_var") {
1495    ///     object.set_shared_var_str("ss_var","rust");
1496    /// }
1497    /// ```
1498    pub fn has_shared_var(self, name: impl AsPBStr) -> bool { self.get_shared_var_id(name).is_some() }
1499
1500    /// 获取指定共享(静态)变量类型
1501    ///
1502    /// # Panics
1503    ///
1504    /// 访问不存在的变量时会触发Panic
1505    ///
1506    /// # Examples
1507    ///
1508    /// ```
1509    /// if object.get_shared_var_type("ss_var") == ValueType::String {
1510    ///     object.set_shared_var_str("ss_var","rust");
1511    /// }
1512    /// ```
1513    pub fn get_shared_var_type(&self, fid: impl SharedVarId) -> ValueType {
1514        unsafe { ffi::pbsession_GetSharedVarType(self.session.as_ptr(), self.get_group(), fid.var_id(self)) }
1515    }
1516
1517    /// 判断指定共享(静态)变量是否为NULL
1518    ///
1519    /// # Panics
1520    ///
1521    /// 访问不存在的变量时会触发Panic
1522    pub fn is_shared_var_null(&self, fid: impl SharedVarId) -> bool {
1523        unsafe {
1524            ffi::pbsession_IsSharedVarNull(self.session.as_ptr(), self.get_group(), fid.var_id(self)).into()
1525        }
1526    }
1527
1528    /// 判断指定共享(静态)变量是否为数组类型
1529    ///
1530    /// # Panics
1531    ///
1532    /// 访问不存在的变量时会触发Panic
1533    pub fn is_shared_var_array(&self, fid: impl SharedVarId) -> bool {
1534        unsafe {
1535            ffi::pbsession_IsSharedVarArray(self.session.as_ptr(), self.get_group(), fid.var_id(self)).into()
1536        }
1537    }
1538
1539    /// 判断指定共享(静态)变量是否为对象类型
1540    ///
1541    /// # Panics
1542    ///
1543    /// 访问不存在的变量时会触发Panic
1544    pub fn is_shared_var_object(&self, fid: impl SharedVarId) -> bool {
1545        unsafe {
1546            ffi::pbsession_IsSharedVarObject(self.session.as_ptr(), self.get_group(), fid.var_id(self)).into()
1547        }
1548    }
1549
1550    /// 获取`int`类型共享(静态)变量值
1551    ///
1552    /// # Panics
1553    ///
1554    /// 访问不存在的变量或类型不匹配时会触发Panic
1555    pub fn get_shared_var_int(&self, fid: impl VarId) -> Option<pbint> {
1556        let fid = fid.var_id(self);
1557        assert!(self.get_shared_var_type(fid) == ValueType::Int);
1558        unsafe { self.get_shared_var_int_unchecked(fid) }
1559    }
1560
1561    /// 获取`int`类型共享(静态)变量值,不检查类型
1562    ///
1563    /// # Panics
1564    ///
1565    /// 访问不存在的变量时会触发Panic
1566    ///
1567    /// # Safety
1568    ///
1569    /// 类型不兼容时可能会出现未定义行为
1570    pub unsafe fn get_shared_var_int_unchecked(&self, fid: impl VarId) -> Option<pbint> {
1571        let mut is_null = Default::default();
1572        let v = ffi::pbsession_GetIntSharedVar(
1573            self.session.as_ptr(),
1574            self.get_group(),
1575            fid.var_id(self),
1576            &mut is_null
1577        );
1578        if is_null == true {
1579            None
1580        } else {
1581            Some(v)
1582        }
1583    }
1584
1585    /// 获取`uint`类型共享(静态)变量值
1586    ///
1587    /// # Panics
1588    ///
1589    /// 访问不存在的变量或类型不匹配时会触发Panic
1590    pub fn get_shared_var_uint(&self, fid: impl VarId) -> Option<pbuint> {
1591        let fid = fid.var_id(self);
1592        assert!(self.get_shared_var_type(fid) == ValueType::Uint);
1593        unsafe { self.get_shared_var_uint_unchecked(fid) }
1594    }
1595
1596    /// 获取`uint`类型共享(静态)变量值,不检查类型
1597    ///
1598    /// # Panics
1599    ///
1600    /// 访问不存在的变量时会触发Panic
1601    ///
1602    /// # Safety
1603    ///
1604    /// 类型不兼容时可能会出现未定义行为
1605    pub unsafe fn get_shared_var_uint_unchecked(&self, fid: impl VarId) -> Option<pbuint> {
1606        let mut is_null = Default::default();
1607        let v = ffi::pbsession_GetUintSharedVar(
1608            self.session.as_ptr(),
1609            self.get_group(),
1610            fid.var_id(self),
1611            &mut is_null
1612        );
1613        if is_null == true {
1614            None
1615        } else {
1616            Some(v)
1617        }
1618    }
1619
1620    /// 获取`long`类型共享(静态)变量值
1621    ///
1622    /// # Panics
1623    ///
1624    /// 访问不存在的变量或类型不匹配时会触发Panic
1625    pub fn get_shared_var_long(&self, fid: impl VarId) -> Option<pblong> {
1626        let fid = fid.var_id(self);
1627        assert!(self.get_shared_var_type(fid) == ValueType::Long);
1628        unsafe { self.get_shared_var_long_unchecked(fid) }
1629    }
1630
1631    /// 获取`long`类型共享(静态)变量值,不检查类型
1632    ///
1633    /// # Panics
1634    ///
1635    /// 访问不存在的变量时会触发Panic
1636    ///
1637    /// # Safety
1638    ///
1639    /// 类型不兼容时可能会出现未定义行为
1640    pub unsafe fn get_shared_var_long_unchecked(&self, fid: impl VarId) -> Option<pblong> {
1641        let mut is_null = Default::default();
1642        let v = ffi::pbsession_GetLongSharedVar(
1643            self.session.as_ptr(),
1644            self.get_group(),
1645            fid.var_id(self),
1646            &mut is_null
1647        );
1648        if is_null == true {
1649            None
1650        } else {
1651            Some(v)
1652        }
1653    }
1654
1655    /// 获取`ulong`类型共享(静态)变量值
1656    ///
1657    /// # Panics
1658    ///
1659    /// 访问不存在的变量或类型不匹配时会触发Panic
1660    pub fn get_shared_var_ulong(&self, fid: impl VarId) -> Option<pbulong> {
1661        let fid = fid.var_id(self);
1662        assert!(self.get_shared_var_type(fid) == ValueType::Ulong);
1663        unsafe { self.get_shared_var_ulong_unchecked(fid) }
1664    }
1665
1666    /// 获取`ulong`类型共享(静态)变量值,不检查类型
1667    ///
1668    /// # Panics
1669    ///
1670    /// 访问不存在的变量时会触发Panic
1671    ///
1672    /// # Safety
1673    ///
1674    /// 类型不兼容时可能会出现未定义行为
1675    pub unsafe fn get_shared_var_ulong_unchecked(&self, fid: impl VarId) -> Option<pbulong> {
1676        let mut is_null = Default::default();
1677        let v = ffi::pbsession_GetUlongSharedVar(
1678            self.session.as_ptr(),
1679            self.get_group(),
1680            fid.var_id(self),
1681            &mut is_null
1682        );
1683        if is_null == true {
1684            None
1685        } else {
1686            Some(v)
1687        }
1688    }
1689
1690    /// 获取`longlong`类型共享(静态)变量值
1691    ///
1692    /// # Panics
1693    ///
1694    /// 访问不存在的变量或类型不匹配时会触发Panic
1695    pub fn get_shared_var_longlong(&self, fid: impl VarId) -> Option<pblonglong> {
1696        let fid = fid.var_id(self);
1697        assert!(self.get_shared_var_type(fid) == ValueType::LongLong);
1698        unsafe { self.get_shared_var_longlong_unchecked(fid) }
1699    }
1700
1701    /// 获取`longlong`类型共享(静态)变量值,不检查类型
1702    ///
1703    /// # Panics
1704    ///
1705    /// 访问不存在的变量时会触发Panic
1706    ///
1707    /// # Safety
1708    ///
1709    /// 类型不兼容时可能会出现未定义行为
1710    pub unsafe fn get_shared_var_longlong_unchecked(&self, fid: impl VarId) -> Option<pblonglong> {
1711        let mut is_null = Default::default();
1712        let v = ffi::pbsession_GetLongLongSharedVar(
1713            self.session.as_ptr(),
1714            self.get_group(),
1715            fid.var_id(self),
1716            &mut is_null
1717        );
1718        if is_null == true {
1719            None
1720        } else {
1721            Some(v)
1722        }
1723    }
1724
1725    /// 获取`real`类型共享(静态)变量值
1726    ///
1727    /// # Panics
1728    ///
1729    /// 访问不存在的变量或类型不匹配时会触发Panic
1730    pub fn get_shared_var_real(&self, fid: impl VarId) -> Option<pbreal> {
1731        let fid = fid.var_id(self);
1732        assert!(self.get_shared_var_type(fid) == ValueType::Real);
1733        unsafe { self.get_shared_var_real_unchecked(fid) }
1734    }
1735
1736    /// 获取`real`类型共享(静态)变量值,不检查类型
1737    ///
1738    /// # Panics
1739    ///
1740    /// 访问不存在的变量时会触发Panic
1741    ///
1742    /// # Safety
1743    ///
1744    /// 类型不兼容时可能会出现未定义行为
1745    pub unsafe fn get_shared_var_real_unchecked(&self, fid: impl VarId) -> Option<pbreal> {
1746        let mut is_null = Default::default();
1747        let v = ffi::pbsession_GetRealSharedVar(
1748            self.session.as_ptr(),
1749            self.get_group(),
1750            fid.var_id(self),
1751            &mut is_null
1752        );
1753        if is_null == true {
1754            None
1755        } else {
1756            Some(v)
1757        }
1758    }
1759
1760    /// 获取`double`类型共享(静态)变量值
1761    ///
1762    /// # Panics
1763    ///
1764    /// 访问不存在的变量或类型不匹配时会触发Panic
1765    pub fn get_shared_var_double(&self, fid: impl VarId) -> Option<pbdouble> {
1766        let fid = fid.var_id(self);
1767        assert!(self.get_shared_var_type(fid) == ValueType::Double);
1768        unsafe { self.get_shared_var_double_unchecked(fid) }
1769    }
1770
1771    /// 获取`double`类型共享(静态)变量值,不检查类型
1772    ///
1773    /// # Panics
1774    ///
1775    /// 访问不存在的变量时会触发Panic
1776    ///
1777    /// # Safety
1778    ///
1779    /// 类型不兼容时可能会出现未定义行为
1780    pub unsafe fn get_shared_var_double_unchecked(&self, fid: impl VarId) -> Option<pbdouble> {
1781        let mut is_null = Default::default();
1782        let v = ffi::pbsession_GetDoubleSharedVar(
1783            self.session.as_ptr(),
1784            self.get_group(),
1785            fid.var_id(self),
1786            &mut is_null
1787        );
1788        if is_null == true {
1789            None
1790        } else {
1791            Some(v)
1792        }
1793    }
1794
1795    /// 获取`decimal`类型共享(静态)变量值
1796    ///
1797    /// # Panics
1798    ///
1799    /// 访问不存在的变量或类型不匹配时会触发Panic
1800    #[cfg(feature = "decimal")]
1801    pub fn get_shared_var_dec(&self, fid: impl VarId) -> Option<Decimal> {
1802        let fid = fid.var_id(self);
1803        assert!(self.get_shared_var_type(fid) == ValueType::Decimal);
1804        unsafe { self.get_shared_var_dec_unchecked(fid) }
1805    }
1806
1807    /// 获取`decimal`类型共享(静态)变量值,不检查类型
1808    ///
1809    /// # Panics
1810    ///
1811    /// 访问不存在的变量时会触发Panic
1812    ///
1813    /// # Safety
1814    ///
1815    /// 类型不兼容时可能会出现未定义行为
1816    #[cfg(feature = "decimal")]
1817    pub unsafe fn get_shared_var_dec_unchecked(&self, fid: impl VarId) -> Option<Decimal> {
1818        let mut is_null = Default::default();
1819        let v = ffi::pbsession_GetDecSharedVar(
1820            self.session.as_ptr(),
1821            self.get_group(),
1822            fid.var_id(self),
1823            &mut is_null
1824        );
1825        if is_null == true {
1826            None
1827        } else {
1828            Some(self.session.get_dec_unchecked(v))
1829        }
1830    }
1831
1832    /// 获取`string`类型共享(静态)变量的引用
1833    ///
1834    /// # Panics
1835    ///
1836    /// 访问不存在的变量或类型不匹配时会触发Panic
1837    ///
1838    /// # Safety
1839    ///
1840    /// 引用类型不能保证始终有效,详情请阅读[内存安全]说明
1841    ///
1842    /// [内存安全]: ./index.html#内存安全
1843    pub unsafe fn get_shared_var_str(&self, fid: impl VarId) -> Option<&'obj PBStr> {
1844        let fid = fid.var_id(self);
1845        assert!(self.get_shared_var_type(fid) == ValueType::String);
1846        self.get_shared_var_str_unchecked(fid)
1847    }
1848
1849    /// 获取`string`类型共享(静态)变量的引用,不检查类型
1850    ///
1851    /// # Panics
1852    ///
1853    /// 访问不存在的变量时会触发Panic
1854    ///
1855    /// # Safety
1856    ///
1857    /// - 类型不兼容时可能会出现未定义行为
1858    /// - 引用类型不能保证始终有效,详情请阅读[内存安全]说明
1859    ///
1860    /// [内存安全]: ./index.html#内存安全
1861    pub unsafe fn get_shared_var_str_unchecked(&self, fid: impl VarId) -> Option<&'obj PBStr> {
1862        let mut is_null = Default::default();
1863        let v = ffi::pbsession_GetStringSharedVar(
1864            self.session.as_ptr(),
1865            self.get_group(),
1866            fid.var_id(self),
1867            &mut is_null
1868        );
1869        if is_null == true {
1870            None
1871        } else {
1872            self.session.get_string_unchecked(v)
1873        }
1874    }
1875
1876    /// 获取`string`类型共享(静态)变量值
1877    ///
1878    /// # Panics
1879    ///
1880    /// 访问不存在的变量或类型不匹配时会触发Panic
1881    pub fn get_shared_var_string(&self, fid: impl VarId) -> Option<PBString> {
1882        let fid = fid.var_id(self);
1883        assert!(self.get_shared_var_type(fid) == ValueType::String);
1884        unsafe { self.get_shared_var_string_unchecked(fid) }
1885    }
1886
1887    /// 获取`string`类型共享(静态)变量值,不检查类型
1888    ///
1889    /// # Panics
1890    ///
1891    /// 访问不存在的变量时会触发Panic
1892    ///
1893    /// # Safety
1894    ///
1895    /// 类型不兼容时可能会出现未定义行为
1896    pub unsafe fn get_shared_var_string_unchecked(&self, fid: impl VarId) -> Option<PBString> {
1897        self.get_shared_var_str_unchecked(fid).map(|v| v.to_ucstring())
1898    }
1899
1900    /// 获取`boolean`类型共享(静态)变量值
1901    ///
1902    /// # Panics
1903    ///
1904    /// 访问不存在的变量或类型不匹配时会触发Panic
1905    pub fn get_shared_var_bool(&self, fid: impl VarId) -> Option<bool> {
1906        let fid = fid.var_id(self);
1907        assert!(self.get_shared_var_type(fid) == ValueType::Boolean);
1908        unsafe { self.get_shared_var_bool_unchecked(fid) }
1909    }
1910
1911    /// 获取`boolean`类型共享(静态)变量值,不检查类型
1912    ///
1913    /// # Panics
1914    ///
1915    /// 访问不存在的变量时会触发Panic
1916    ///
1917    /// # Safety
1918    ///
1919    /// 类型不兼容时可能会出现未定义行为
1920    pub unsafe fn get_shared_var_bool_unchecked(&self, fid: impl VarId) -> Option<bool> {
1921        let mut is_null = Default::default();
1922        let v = ffi::pbsession_GetBoolSharedVar(
1923            self.session.as_ptr(),
1924            self.get_group(),
1925            fid.var_id(self),
1926            &mut is_null
1927        );
1928        if is_null == true {
1929            None
1930        } else {
1931            Some(v.into())
1932        }
1933    }
1934
1935    /// 获取`blob`类型共享(静态)变量的引用
1936    ///
1937    /// # Panics
1938    ///
1939    /// 访问不存在的变量或类型不匹配时会触发Panic
1940    ///
1941    /// # Safety
1942    ///
1943    /// 引用类型不能保证始终有效,详情请阅读[内存安全]说明
1944    ///
1945    /// [内存安全]: ./index.html#内存安全
1946    pub unsafe fn get_shared_var_blob(&self, fid: impl VarId) -> Option<&'obj [u8]> {
1947        let fid = fid.var_id(self);
1948        assert!(self.get_shared_var_type(fid) == ValueType::Blob);
1949        self.get_shared_var_blob_unchecked(fid)
1950    }
1951
1952    /// 获取`blob`类型共享(静态)变量的引用,不检查类型
1953    ///
1954    /// # Panics
1955    ///
1956    /// 访问不存在的变量时会触发Panic
1957    ///
1958    /// # Safety
1959    ///
1960    /// - 类型不兼容时可能会出现未定义行为
1961    /// - 引用类型不能保证始终有效,详情请阅读[内存安全]说明
1962    ///
1963    /// [内存安全]: ./index.html#内存安全
1964    pub unsafe fn get_shared_var_blob_unchecked(&self, fid: impl VarId) -> Option<&'obj [u8]> {
1965        let mut is_null = Default::default();
1966        let v = ffi::pbsession_GetBlobSharedVar(
1967            self.session.as_ptr(),
1968            self.get_group(),
1969            fid.var_id(self),
1970            &mut is_null
1971        );
1972        if is_null == true {
1973            None
1974        } else {
1975            Some(self.session.get_blob_unchecked(v))
1976        }
1977    }
1978
1979    /// 获取`date`类型共享(静态)变量值
1980    ///
1981    /// # Panics
1982    ///
1983    /// 访问不存在的变量或类型不匹配时会触发Panic
1984    #[cfg(feature = "datetime")]
1985    pub fn get_shared_var_date(&self, fid: impl VarId) -> Option<NaiveDate> {
1986        let fid = fid.var_id(self);
1987        assert!(self.get_shared_var_type(fid) == ValueType::Date);
1988        unsafe { self.get_shared_var_date_unchecked(fid) }
1989    }
1990
1991    /// 获取`date`类型共享(静态)变量值,不检查类型
1992    ///
1993    /// # Panics
1994    ///
1995    /// 访问不存在的变量时会触发Panic
1996    ///
1997    /// # Safety
1998    ///
1999    /// 类型不兼容时可能会出现未定义行为
2000    #[cfg(feature = "datetime")]
2001    pub unsafe fn get_shared_var_date_unchecked(&self, fid: impl VarId) -> Option<NaiveDate> {
2002        let mut is_null = Default::default();
2003        let v = ffi::pbsession_GetDateSharedVar(
2004            self.session.as_ptr(),
2005            self.get_group(),
2006            fid.var_id(self),
2007            &mut is_null
2008        );
2009        if is_null == true {
2010            None
2011        } else {
2012            Some(self.session.get_date_unchecked(v))
2013        }
2014    }
2015
2016    /// 获取`time`类型共享(静态)变量值
2017    ///
2018    /// # Panics
2019    ///
2020    /// 访问不存在的变量或类型不匹配时会触发Panic
2021    #[cfg(feature = "datetime")]
2022    pub fn get_shared_var_time(&self, fid: impl VarId) -> Option<NaiveTime> {
2023        let fid = fid.var_id(self);
2024        assert!(self.get_shared_var_type(fid) == ValueType::Time);
2025        unsafe { self.get_shared_var_time_unchecked(fid) }
2026    }
2027
2028    /// 获取`time`类型共享(静态)变量值,不检查类型
2029    ///
2030    /// # Panics
2031    ///
2032    /// 访问不存在的变量时会触发Panic
2033    ///
2034    /// # Safety
2035    ///
2036    /// 类型不兼容时可能会出现未定义行为
2037    #[cfg(feature = "datetime")]
2038    pub unsafe fn get_shared_var_time_unchecked(&self, fid: impl VarId) -> Option<NaiveTime> {
2039        let mut is_null = Default::default();
2040        let v = ffi::pbsession_GetTimeSharedVar(
2041            self.session.as_ptr(),
2042            self.get_group(),
2043            fid.var_id(self),
2044            &mut is_null
2045        );
2046        if is_null == true {
2047            None
2048        } else {
2049            Some(self.session.get_time_unchecked(v))
2050        }
2051    }
2052
2053    /// 获取`datetime`类型共享(静态)变量值
2054    ///
2055    /// # Panics
2056    ///
2057    /// 访问不存在的变量或类型不匹配时会触发Panic
2058    #[cfg(feature = "datetime")]
2059    pub fn get_shared_var_datetime(&self, fid: impl VarId) -> Option<NaiveDateTime> {
2060        let fid = fid.var_id(self);
2061        assert!(self.get_shared_var_type(fid) == ValueType::DateTime);
2062        unsafe { self.get_shared_var_datetime_unchecked(fid) }
2063    }
2064
2065    /// 获取`datetime`类型共享(静态)变量值,不检查类型
2066    ///
2067    /// # Panics
2068    ///
2069    /// 访问不存在的变量时会触发Panic
2070    ///
2071    /// # Safety
2072    ///
2073    /// 类型不兼容时可能会出现未定义行为
2074    #[cfg(feature = "datetime")]
2075    pub unsafe fn get_shared_var_datetime_unchecked(&self, fid: impl VarId) -> Option<NaiveDateTime> {
2076        let mut is_null = Default::default();
2077        let v = ffi::pbsession_GetDateTimeSharedVar(
2078            self.session.as_ptr(),
2079            self.get_group(),
2080            fid.var_id(self),
2081            &mut is_null
2082        );
2083        if is_null == true {
2084            None
2085        } else {
2086            Some(self.session.get_datetime_unchecked(v))
2087        }
2088    }
2089
2090    /// 获取`char`类型共享(静态)变量值
2091    ///
2092    /// # Panics
2093    ///
2094    /// 访问不存在的变量或类型不匹配时会触发Panic
2095    pub fn get_shared_var_char(&self, fid: impl VarId) -> Option<PBChar> {
2096        let fid = fid.var_id(self);
2097        assert!(self.get_shared_var_type(fid) == ValueType::Char);
2098        unsafe { self.get_shared_var_char_unchecked(fid) }
2099    }
2100
2101    /// 获取`char`类型共享(静态)变量值,不检查类型
2102    ///
2103    /// # Panics
2104    ///
2105    /// 访问不存在的变量时会触发Panic
2106    ///
2107    /// # Safety
2108    ///
2109    /// 类型不兼容时可能会出现未定义行为
2110    pub unsafe fn get_shared_var_char_unchecked(&self, fid: impl VarId) -> Option<PBChar> {
2111        let mut is_null = Default::default();
2112        let v = ffi::pbsession_GetCharSharedVar(
2113            self.session.as_ptr(),
2114            self.get_group(),
2115            fid.var_id(self),
2116            &mut is_null
2117        );
2118        if is_null == true {
2119            None
2120        } else {
2121            Some(v)
2122        }
2123    }
2124
2125    /// 获取`byte`类型共享(静态)变量值
2126    ///
2127    /// # Panics
2128    ///
2129    /// 访问不存在的变量或类型不匹配时会触发Panic
2130    pub fn get_shared_var_byte(&self, fid: impl VarId) -> Option<pbbyte> {
2131        let fid = fid.var_id(self);
2132        assert!(self.get_shared_var_type(fid) == ValueType::Byte);
2133        unsafe { self.get_shared_var_byte_unchecked(fid) }
2134    }
2135
2136    /// 获取`byte`类型共享(静态)变量值,不检查类型
2137    ///
2138    /// # Panics
2139    ///
2140    /// 访问不存在的变量时会触发Panic
2141    ///
2142    /// # Safety
2143    ///
2144    /// 类型不兼容时可能会出现未定义行为
2145    pub unsafe fn get_shared_var_byte_unchecked(&self, fid: impl VarId) -> Option<pbbyte> {
2146        let mut is_null = Default::default();
2147        let v = ffi::pbsession_GetByteSharedVar(
2148            self.session.as_ptr(),
2149            self.get_group(),
2150            fid.var_id(self),
2151            &mut is_null
2152        );
2153        if is_null == true {
2154            None
2155        } else {
2156            Some(v)
2157        }
2158    }
2159
2160    /// 获取对象类型共享(静态)变量的引用
2161    ///
2162    /// # Panics
2163    ///
2164    /// 访问不存在的变量或类型不匹配时会触发Panic
2165    ///
2166    /// # Safety
2167    ///
2168    /// 引用类型不能保证始终有效,详情请阅读[内存安全]说明
2169    ///
2170    /// [内存安全]: ./index.html#内存安全
2171    pub unsafe fn get_shared_var_object(&self, fid: impl VarId) -> Option<Object<'obj>> {
2172        let fid = fid.var_id(self);
2173        assert!(self.is_var_object(fid));
2174        self.get_shared_var_object_unchecked(fid)
2175    }
2176
2177    /// 获取对象类型共享(静态)变量的引用,不检查类型
2178    ///
2179    /// # Panics
2180    ///
2181    /// 访问不存在的变量时会触发Panic
2182    ///
2183    /// # Safety
2184    ///
2185    /// - 类型不兼容时可能会出现未定义行为
2186    /// - 引用类型不能保证始终有效,详情请阅读[内存安全]说明
2187    ///
2188    /// [内存安全]: ./index.html#内存安全
2189    pub unsafe fn get_shared_var_object_unchecked(&self, fid: impl VarId) -> Option<Object<'obj>> {
2190        let mut is_null = Default::default();
2191        let v = ffi::pbsession_GetObjectSharedVar(
2192            self.session.as_ptr(),
2193            self.get_group(),
2194            fid.var_id(self),
2195            &mut is_null
2196        );
2197        if is_null == true {
2198            None
2199        } else {
2200            Some(Object::from_ptr(v, self.session.clone()))
2201        }
2202    }
2203
2204    /// 获取数组类型共享(静态)变量的引用
2205    ///
2206    /// # Panics
2207    ///
2208    /// 访问不存在的变量或类型不匹配时会触发Panic
2209    ///
2210    /// # Safety
2211    ///
2212    /// 引用类型不能保证始终有效,详情请阅读[内存安全]说明
2213    ///
2214    /// [内存安全]: ./index.html#内存安全
2215    pub unsafe fn get_shared_var_array(&self, fid: impl VarId) -> Option<Array<'obj>> {
2216        let fid = fid.var_id(self);
2217        assert!(self.is_var_array(fid));
2218        self.get_shared_var_array_unchecked(fid)
2219    }
2220
2221    /// 获取数组类型共享(静态)变量的引用,不检查类型
2222    ///
2223    /// # Panics
2224    ///
2225    /// 访问不存在的变量时会触发Panic
2226    ///
2227    /// # Safety
2228    ///
2229    /// - 类型不兼容时可能会出现未定义行为
2230    /// - 引用类型不能保证始终有效,详情请阅读[内存安全]说明
2231    ///
2232    /// [内存安全]: ./index.html#内存安全
2233    pub unsafe fn get_shared_var_array_unchecked(&self, fid: impl VarId) -> Option<Array<'obj>> {
2234        let mut is_null = Default::default();
2235        let v = ffi::pbsession_GetArraySharedVar(
2236            self.session.as_ptr(),
2237            self.get_group(),
2238            fid.var_id(self),
2239            &mut is_null
2240        );
2241        if is_null == true {
2242            None
2243        } else {
2244            Some(Array::from_ptr(v, self.is_var_object(fid), self.session.clone()))
2245        }
2246    }
2247
2248    /// 获取`any`类型共享(静态)变量的引用
2249    ///
2250    /// # Panics
2251    ///
2252    /// 访问不存在的变量或类型不匹配时会触发Panic
2253    ///
2254    /// # Safety
2255    ///
2256    /// 引用类型不能保证始终有效,详情请阅读[内存安全]说明
2257    ///
2258    /// [内存安全]: ./index.html#内存安全
2259    pub unsafe fn get_shared_var_any(&self, fid: impl VarId) -> Option<Value<'obj>> {
2260        let fid = fid.var_id(self);
2261        assert!(self.get_shared_var_type(fid) == ValueType::Any);
2262        self.get_shared_var_any_unchecked(fid)
2263    }
2264
2265    /// 获取`any`类型共享(静态)变量的引用,不检查类型
2266    ///
2267    /// # Panics
2268    ///
2269    /// 访问不存在的变量时会触发Panic
2270    ///
2271    /// # Safety
2272    ///
2273    /// - 类型不兼容时可能会出现未定义行为
2274    /// - 引用类型不能保证始终有效,详情请阅读[内存安全]说明
2275    ///
2276    /// [内存安全]: ./index.html#内存安全
2277    pub unsafe fn get_shared_var_any_unchecked(&self, fid: impl VarId) -> Option<Value<'obj>> {
2278        let mut is_null = Default::default();
2279        let v = ffi::pbsession_GetPBAnySharedVar(
2280            self.session.as_ptr(),
2281            self.get_group(),
2282            fid.var_id(self),
2283            &mut is_null
2284        );
2285        if is_null == true {
2286            None
2287        } else {
2288            Some(Value::from_ptr(v, self.session.clone()))
2289        }
2290    }
2291
2292    /// 设置共享(静态)变量的值为NULL
2293    ///
2294    /// # Panics
2295    ///
2296    /// 访问不存在的变量时会触发Panic
2297    pub fn set_shared_var_to_null(&self, fid: impl VarId) {
2298        unsafe {
2299            ffi::pbsession_SetSharedVarToNull(self.session.as_ptr(), self.get_group(), fid.var_id(self))
2300        }
2301    }
2302
2303    /// 设置`int`类型共享(静态)变量的值
2304    ///
2305    /// # Panics
2306    ///
2307    /// 访问不存在的变量或类型不匹配时会触发Panic
2308    pub fn set_shared_var_int(&mut self, fid: impl VarId, value: pbint) -> Result<()> {
2309        let fid = fid.var_id(self);
2310        assert!(self.get_shared_var_type(fid) == ValueType::Int);
2311        unsafe { ffi::pbsession_SetIntSharedVar(self.session.as_ptr(), self.get_group(), fid, value).into() }
2312    }
2313
2314    /// 设置`int`类型共享(静态)变量的值,不检查类型
2315    ///
2316    /// # Panics
2317    ///
2318    /// 访问不存在的变量时会触发Panic
2319    ///
2320    /// # Safety
2321    ///
2322    /// 类型不兼容时可能会出现未定义行为
2323    pub unsafe fn set_shared_var_int_unchecked(&mut self, fid: impl VarId, value: pbint) -> Result<()> {
2324        ffi::pbsession_SetIntSharedVar(self.session.as_ptr(), self.get_group(), fid.var_id(self), value)
2325            .into()
2326    }
2327
2328    /// 设置`uint`类型共享(静态)变量的值
2329    ///
2330    /// # Panics
2331    ///
2332    /// 访问不存在的变量或类型不匹配时会触发Panic
2333    pub fn set_shared_var_uint(&mut self, fid: impl VarId, value: pbuint) -> Result<()> {
2334        let fid = fid.var_id(self);
2335        assert!(self.get_shared_var_type(fid) == ValueType::Uint);
2336        unsafe { ffi::pbsession_SetUintSharedVar(self.session.as_ptr(), self.get_group(), fid, value).into() }
2337    }
2338
2339    /// 设置`uint`类型共享(静态)变量的值,不检查类型
2340    ///
2341    /// # Panics
2342    ///
2343    /// 访问不存在的变量时会触发Panic
2344    ///
2345    /// # Safety
2346    ///
2347    /// 类型不兼容时可能会出现未定义行为
2348    pub unsafe fn set_shared_var_uint_unchecked(&mut self, fid: impl VarId, value: pbuint) -> Result<()> {
2349        ffi::pbsession_SetUintSharedVar(self.session.as_ptr(), self.get_group(), fid.var_id(self), value)
2350            .into()
2351    }
2352
2353    /// 设置`long`类型共享(静态)变量的值
2354    ///
2355    /// # Panics
2356    ///
2357    /// 访问不存在的变量或类型不匹配时会触发Panic
2358    pub fn set_shared_var_long(&mut self, fid: impl VarId, value: pblong) -> Result<()> {
2359        let fid = fid.var_id(self);
2360        assert!(self.get_shared_var_type(fid) == ValueType::Long);
2361        unsafe { ffi::pbsession_SetLongSharedVar(self.session.as_ptr(), self.get_group(), fid, value).into() }
2362    }
2363
2364    /// 设置`long`类型共享(静态)变量的值,不检查类型
2365    ///
2366    /// # Panics
2367    ///
2368    /// 访问不存在的变量时会触发Panic
2369    ///
2370    /// # Safety
2371    ///
2372    /// 类型不兼容时可能会出现未定义行为
2373    pub unsafe fn set_shared_var_long_unchecked(&mut self, fid: impl VarId, value: pblong) -> Result<()> {
2374        ffi::pbsession_SetLongSharedVar(self.session.as_ptr(), self.get_group(), fid.var_id(self), value)
2375            .into()
2376    }
2377
2378    /// 设置`ulong`类型共享(静态)变量的值
2379    ///
2380    /// # Panics
2381    ///
2382    /// 访问不存在的变量或类型不匹配时会触发Panic
2383    pub fn set_shared_var_ulong(&mut self, fid: impl VarId, value: pbulong) -> Result<()> {
2384        let fid = fid.var_id(self);
2385        assert!(self.get_shared_var_type(fid) == ValueType::Ulong);
2386        unsafe {
2387            ffi::pbsession_SetUlongSharedVar(self.session.as_ptr(), self.get_group(), fid, value).into()
2388        }
2389    }
2390
2391    /// 设置`ulong`类型共享(静态)变量的值,不检查类型
2392    ///
2393    /// # Panics
2394    ///
2395    /// 访问不存在的变量时会触发Panic
2396    ///
2397    /// # Safety
2398    ///
2399    /// 类型不兼容时可能会出现未定义行为
2400    pub unsafe fn set_shared_var_ulong_unchecked(&mut self, fid: impl VarId, value: pbulong) -> Result<()> {
2401        ffi::pbsession_SetUlongSharedVar(self.session.as_ptr(), self.get_group(), fid.var_id(self), value)
2402            .into()
2403    }
2404
2405    /// 设置`longlong`类型共享(静态)变量的值
2406    ///
2407    /// # Panics
2408    ///
2409    /// 访问不存在的变量或类型不匹配时会触发Panic
2410    pub fn set_shared_var_longlong(&mut self, fid: impl VarId, value: pblonglong) -> Result<()> {
2411        let fid = fid.var_id(self);
2412        assert!(self.get_shared_var_type(fid) == ValueType::LongLong);
2413        unsafe {
2414            ffi::pbsession_SetLongLongSharedVar(self.session.as_ptr(), self.get_group(), fid, value).into()
2415        }
2416    }
2417
2418    /// 设置`longlong`类型共享(静态)变量的值,不检查类型
2419    ///
2420    /// # Panics
2421    ///
2422    /// 访问不存在的变量时会触发Panic
2423    ///
2424    /// # Safety
2425    ///
2426    /// 类型不兼容时可能会出现未定义行为
2427    pub unsafe fn set_shared_var_longlong_unchecked(
2428        &mut self,
2429        fid: impl VarId,
2430        value: pblonglong
2431    ) -> Result<()> {
2432        ffi::pbsession_SetLongLongSharedVar(self.session.as_ptr(), self.get_group(), fid.var_id(self), value)
2433            .into()
2434    }
2435
2436    /// 设置`real`类型共享(静态)变量的值
2437    ///
2438    /// # Panics
2439    ///
2440    /// 访问不存在的变量或类型不匹配时会触发Panic
2441    pub fn set_shared_var_real(&mut self, fid: impl VarId, value: pbreal) -> Result<()> {
2442        let fid = fid.var_id(self);
2443        assert!(self.get_shared_var_type(fid) == ValueType::Real);
2444        unsafe { ffi::pbsession_SetRealSharedVar(self.session.as_ptr(), self.get_group(), fid, value).into() }
2445    }
2446
2447    /// 设置`real`类型共享(静态)变量的值,不检查类型
2448    ///
2449    /// # Panics
2450    ///
2451    /// 访问不存在的变量时会触发Panic
2452    ///
2453    /// # Safety
2454    ///
2455    /// 类型不兼容时可能会出现未定义行为
2456    pub unsafe fn set_shared_var_real_unchecked(&mut self, fid: impl VarId, value: pbreal) -> Result<()> {
2457        ffi::pbsession_SetRealSharedVar(self.session.as_ptr(), self.get_group(), fid.var_id(self), value)
2458            .into()
2459    }
2460
2461    /// 设置`double`类型共享(静态)变量的值
2462    ///
2463    /// # Panics
2464    ///
2465    /// 访问不存在的变量或类型不匹配时会触发Panic
2466    pub fn set_shared_var_double(&mut self, fid: impl VarId, value: pbdouble) -> Result<()> {
2467        let fid = fid.var_id(self);
2468        assert!(self.get_shared_var_type(fid) == ValueType::Double);
2469        unsafe {
2470            ffi::pbsession_SetDoubleSharedVar(self.session.as_ptr(), self.get_group(), fid, value).into()
2471        }
2472    }
2473
2474    /// 设置`double`类型共享(静态)变量的值,不检查类型
2475    ///
2476    /// # Panics
2477    ///
2478    /// 访问不存在的变量时会触发Panic
2479    ///
2480    /// # Safety
2481    ///
2482    /// 类型不兼容时可能会出现未定义行为
2483    pub unsafe fn set_shared_var_double_unchecked(&mut self, fid: impl VarId, value: pbdouble) -> Result<()> {
2484        ffi::pbsession_SetDoubleSharedVar(self.session.as_ptr(), self.get_group(), fid.var_id(self), value)
2485            .into()
2486    }
2487
2488    /// 设置`decimal`类型共享(静态)变量的值
2489    ///
2490    /// # Panics
2491    ///
2492    /// 访问不存在的变量或类型不匹配时会触发Panic
2493    #[cfg(feature = "decimal")]
2494    pub fn set_shared_var_dec(&mut self, fid: impl VarId, value: Decimal) -> Result<()> {
2495        let fid = fid.var_id(self);
2496        assert!(self.get_shared_var_type(fid) == ValueType::Decimal);
2497        unsafe {
2498            ffi::pbsession_SetDecSharedVar(
2499                self.session.as_ptr(),
2500                self.get_group(),
2501                fid,
2502                self.session.new_pbdec(value)
2503            )
2504            .into()
2505        }
2506    }
2507
2508    /// 设置`decimal`类型共享(静态)变量的值,不检查类型
2509    ///
2510    /// # Panics
2511    ///
2512    /// 访问不存在的变量时会触发Panic
2513    ///
2514    /// # Safety
2515    ///
2516    /// 类型不兼容时可能会出现未定义行为
2517    #[cfg(feature = "decimal")]
2518    pub unsafe fn set_shared_var_dec_unchecked(&mut self, fid: impl VarId, value: Decimal) -> Result<()> {
2519        ffi::pbsession_SetDecSharedVar(
2520            self.session.as_ptr(),
2521            self.get_group(),
2522            fid.var_id(self),
2523            self.session.new_pbdec(value)
2524        )
2525        .into()
2526    }
2527
2528    /// 设置`string`类型共享(静态)变量的值
2529    ///
2530    /// # Panics
2531    ///
2532    /// 访问不存在的变量或类型不匹配时会触发Panic
2533    pub fn set_shared_var_str(&mut self, fid: impl VarId, value: impl AsPBStr) -> Result<()> {
2534        let fid = fid.var_id(self);
2535        assert!(self.get_shared_var_type(fid) == ValueType::String);
2536        unsafe {
2537            ffi::pbsession_SetStringSharedVar(
2538                self.session.as_ptr(),
2539                self.get_group(),
2540                fid,
2541                value.as_pbstr().as_ptr()
2542            )
2543            .into()
2544        }
2545    }
2546
2547    /// 设置`string`类型共享(静态)变量的值,不检查类型
2548    ///
2549    /// # Panics
2550    ///
2551    /// 访问不存在的变量时会触发Panic
2552    ///
2553    /// # Safety
2554    ///
2555    /// 类型不兼容时可能会出现未定义行为
2556    pub unsafe fn set_shared_var_str_unchecked(
2557        &mut self,
2558        fid: impl VarId,
2559        value: impl AsPBStr
2560    ) -> Result<()> {
2561        ffi::pbsession_SetStringSharedVar(
2562            self.session.as_ptr(),
2563            self.get_group(),
2564            fid.var_id(self),
2565            value.as_pbstr().as_ptr()
2566        )
2567        .into()
2568    }
2569
2570    /// 设置`boolean`类型共享(静态)变量的值
2571    ///
2572    /// # Panics
2573    ///
2574    /// 访问不存在的变量或类型不匹配时会触发Panic
2575    pub fn set_shared_var_bool(&mut self, fid: impl VarId, value: bool) -> Result<()> {
2576        let fid = fid.var_id(self);
2577        assert!(self.get_shared_var_type(fid) == ValueType::Boolean);
2578        unsafe {
2579            ffi::pbsession_SetBoolSharedVar(self.session.as_ptr(), self.get_group(), fid, value.into()).into()
2580        }
2581    }
2582
2583    /// 设置`boolean`类型共享(静态)变量的值,不检查类型
2584    ///
2585    /// # Panics
2586    ///
2587    /// 访问不存在的变量时会触发Panic
2588    ///
2589    /// # Safety
2590    ///
2591    /// 类型不兼容时可能会出现未定义行为
2592    pub unsafe fn set_shared_var_bool_unchecked(&mut self, fid: impl VarId, value: bool) -> Result<()> {
2593        ffi::pbsession_SetBoolSharedVar(
2594            self.session.as_ptr(),
2595            self.get_group(),
2596            fid.var_id(self),
2597            value.into()
2598        )
2599        .into()
2600    }
2601
2602    /// 设置`blob`类型共享(静态)变量的值
2603    ///
2604    /// # Panics
2605    ///
2606    /// 访问不存在的变量或类型不匹配时会触发Panic
2607    pub fn set_shared_var_blob(&mut self, fid: impl VarId, value: impl AsRef<[u8]>) -> Result<()> {
2608        let fid = fid.var_id(self);
2609        assert!(self.get_shared_var_type(fid) == ValueType::Blob);
2610        unsafe {
2611            ffi::pbsession_SetBlobSharedVar(
2612                self.session.as_ptr(),
2613                self.get_group(),
2614                fid,
2615                self.session.new_pbblob(value)
2616            )
2617            .into()
2618        }
2619    }
2620
2621    /// 设置`blob`类型共享(静态)变量的值,不检查类型
2622    ///
2623    /// # Panics
2624    ///
2625    /// 访问不存在的变量时会触发Panic
2626    ///
2627    /// # Safety
2628    ///
2629    /// 类型不兼容时可能会出现未定义行为
2630    pub unsafe fn set_shared_var_blob_unchecked(
2631        &mut self,
2632        fid: impl VarId,
2633        value: impl AsRef<[u8]>
2634    ) -> Result<()> {
2635        let value = value.as_ref();
2636        if value.is_empty() {
2637            return Err(PBXRESULT::E_OUTOF_MEMORY);
2638        }
2639        ffi::pbsession_SetBlobSharedVar(
2640            self.session.as_ptr(),
2641            self.get_group(),
2642            fid.var_id(self),
2643            self.session.new_pbblob(value)
2644        )
2645        .into()
2646    }
2647
2648    /// 设置`date`类型共享(静态)变量的值
2649    ///
2650    /// # Panics
2651    ///
2652    /// 访问不存在的变量或类型不匹配时会触发Panic
2653    #[cfg(feature = "datetime")]
2654    pub fn set_shared_var_date(&mut self, fid: impl VarId, value: NaiveDate) -> Result<()> {
2655        let fid = fid.var_id(self);
2656        assert!(self.get_shared_var_type(fid) == ValueType::Date);
2657        unsafe {
2658            ffi::pbsession_SetDateSharedVar(
2659                self.session.as_ptr(),
2660                self.get_group(),
2661                fid,
2662                self.session.new_pbdate(value)
2663            )
2664            .into()
2665        }
2666    }
2667
2668    /// 设置`date`类型共享(静态)变量的值,不检查类型
2669    ///
2670    /// # Panics
2671    ///
2672    /// 访问不存在的变量时会触发Panic
2673    ///
2674    /// # Safety
2675    ///
2676    /// 类型不兼容时可能会出现未定义行为
2677    #[cfg(feature = "datetime")]
2678    pub unsafe fn set_shared_var_date_unchecked(&mut self, fid: impl VarId, value: NaiveDate) -> Result<()> {
2679        ffi::pbsession_SetDateSharedVar(
2680            self.session.as_ptr(),
2681            self.get_group(),
2682            fid.var_id(self),
2683            self.session.new_pbdate(value)
2684        )
2685        .into()
2686    }
2687
2688    /// 设置`time`类型共享(静态)变量的值
2689    ///
2690    /// # Panics
2691    ///
2692    /// 访问不存在的变量或类型不匹配时会触发Panic
2693    #[cfg(feature = "datetime")]
2694    pub fn set_shared_var_time(&mut self, fid: impl VarId, value: NaiveTime) -> Result<()> {
2695        let fid = fid.var_id(self);
2696        assert!(self.get_shared_var_type(fid) == ValueType::Time);
2697        unsafe {
2698            ffi::pbsession_SetTimeSharedVar(
2699                self.session.as_ptr(),
2700                self.get_group(),
2701                fid,
2702                self.session.new_pbtime(value)
2703            )
2704            .into()
2705        }
2706    }
2707
2708    /// 设置`time`类型共享(静态)变量的值,不检查类型
2709    ///
2710    /// # Panics
2711    ///
2712    /// 访问不存在的变量时会触发Panic
2713    ///
2714    /// # Safety
2715    ///
2716    /// 类型不兼容时可能会出现未定义行为
2717    #[cfg(feature = "datetime")]
2718    pub unsafe fn set_shared_var_time_unchecked(&mut self, fid: impl VarId, value: NaiveTime) -> Result<()> {
2719        ffi::pbsession_SetTimeSharedVar(
2720            self.session.as_ptr(),
2721            self.get_group(),
2722            fid.var_id(self),
2723            self.session.new_pbtime(value)
2724        )
2725        .into()
2726    }
2727
2728    /// 设置`datetime`类型共享(静态)变量的值
2729    ///
2730    /// # Panics
2731    ///
2732    /// 访问不存在的变量或类型不匹配时会触发Panic
2733    #[cfg(feature = "datetime")]
2734    pub fn set_shared_var_datetime(&mut self, fid: impl VarId, value: NaiveDateTime) -> Result<()> {
2735        let fid = fid.var_id(self);
2736        assert!(self.get_shared_var_type(fid) == ValueType::DateTime);
2737        unsafe {
2738            ffi::pbsession_SetDateTimeSharedVar(
2739                self.session.as_ptr(),
2740                self.get_group(),
2741                fid,
2742                self.session.new_pbdatetime(value)
2743            )
2744            .into()
2745        }
2746    }
2747
2748    /// 设置`datetime`类型共享(静态)变量的值,不检查类型
2749    ///
2750    /// # Panics
2751    ///
2752    /// 访问不存在的变量时会触发Panic
2753    ///
2754    /// # Safety
2755    ///
2756    /// 类型不兼容时可能会出现未定义行为
2757    #[cfg(feature = "datetime")]
2758    pub unsafe fn set_shared_var_datetime_unchecked(
2759        &mut self,
2760        fid: impl VarId,
2761        value: NaiveDateTime
2762    ) -> Result<()> {
2763        ffi::pbsession_SetDateTimeSharedVar(
2764            self.session.as_ptr(),
2765            self.get_group(),
2766            fid.var_id(self),
2767            self.session.new_pbdatetime(value)
2768        )
2769        .into()
2770    }
2771
2772    /// 设置`char`类型共享(静态)变量的值
2773    ///
2774    /// # Panics
2775    ///
2776    /// 访问不存在的变量或类型不匹配时会触发Panic
2777    pub fn set_shared_var_char(&mut self, fid: impl VarId, value: PBChar) -> Result<()> {
2778        let fid = fid.var_id(self);
2779        assert!(self.get_shared_var_type(fid) == ValueType::Char);
2780        unsafe { ffi::pbsession_SetCharSharedVar(self.session.as_ptr(), self.get_group(), fid, value).into() }
2781    }
2782
2783    /// 设置`char`类型共享(静态)变量的值,不检查类型
2784    ///
2785    /// # Panics
2786    ///
2787    /// 访问不存在的变量时会触发Panic
2788    ///
2789    /// # Safety
2790    ///
2791    /// 类型不兼容时可能会出现未定义行为
2792    pub unsafe fn set_shared_var_char_unchecked(&mut self, fid: impl VarId, value: PBChar) -> Result<()> {
2793        ffi::pbsession_SetCharSharedVar(self.session.as_ptr(), self.get_group(), fid.var_id(self), value)
2794            .into()
2795    }
2796
2797    /// 设置`byte`类型共享(静态)变量的值
2798    ///
2799    /// # Panics
2800    ///
2801    /// 访问不存在的变量或类型不匹配时会触发Panic
2802    pub fn set_shared_var_byte(&mut self, fid: impl VarId, value: pbbyte) -> Result<()> {
2803        let fid = fid.var_id(self);
2804        assert!(self.get_shared_var_type(fid) == ValueType::Byte);
2805        unsafe { ffi::pbsession_SetByteSharedVar(self.session.as_ptr(), self.get_group(), fid, value).into() }
2806    }
2807
2808    /// 设置`byte`类型共享(静态)变量的值,不检查类型
2809    ///
2810    /// # Panics
2811    ///
2812    /// 访问不存在的变量时会触发Panic
2813    ///
2814    /// # Safety
2815    ///
2816    /// 类型不兼容时可能会出现未定义行为
2817    pub unsafe fn set_shared_var_byte_unchecked(&mut self, fid: impl VarId, value: pbbyte) -> Result<()> {
2818        ffi::pbsession_SetByteSharedVar(self.session.as_ptr(), self.get_group(), fid.var_id(self), value)
2819            .into()
2820    }
2821
2822    /// 设置对象类型共享(静态)变量的值
2823    ///
2824    /// # Panics
2825    ///
2826    /// 访问不存在的变量或类型不匹配时会触发Panic
2827    pub fn set_shared_var_object(&mut self, fid: impl VarId, value: &Object) -> Result<()> {
2828        let fid = fid.var_id(self);
2829        assert!(self.is_var_object(fid));
2830        unsafe {
2831            ffi::pbsession_SetObjectSharedVar(self.session.as_ptr(), self.get_group(), fid, value.as_ptr())
2832                .into()
2833        }
2834    }
2835
2836    /// 设置对象类型共享(静态)变量的值,不检查类型
2837    ///
2838    /// # Panics
2839    ///
2840    /// 访问不存在的变量时会触发Panic
2841    ///
2842    /// # Safety
2843    ///
2844    /// 类型不兼容时可能会出现未定义行为
2845    pub unsafe fn set_shared_var_object_unchecked(&mut self, fid: impl VarId, value: &Object) -> Result<()> {
2846        ffi::pbsession_SetObjectSharedVar(
2847            self.session.as_ptr(),
2848            self.get_group(),
2849            fid.var_id(self),
2850            value.as_ptr()
2851        )
2852        .into()
2853    }
2854
2855    /// 设置数组类型共享(静态)变量的值
2856    ///
2857    /// # Panics
2858    ///
2859    /// 访问不存在的变量或类型不匹配时会触发Panic
2860    pub fn set_shared_var_array(&mut self, fid: impl VarId, value: &Array) -> Result<()> {
2861        let fid = fid.var_id(self);
2862        assert!(self.is_var_array(fid));
2863        unsafe {
2864            ffi::pbsession_SetArraySharedVar(self.session.as_ptr(), self.get_group(), fid, value.as_ptr())
2865                .into()
2866        }
2867    }
2868
2869    /// 设置数组类型共享(静态)变量的值,不检查类型
2870    ///
2871    /// # Panics
2872    ///
2873    /// 访问不存在的变量时会触发Panic
2874    ///
2875    /// # Safety
2876    ///
2877    /// 类型不兼容时可能会出现未定义行为
2878    pub unsafe fn set_shared_var_array_unchecked(&mut self, fid: impl VarId, value: &Array) -> Result<()> {
2879        ffi::pbsession_SetArraySharedVar(
2880            self.session.as_ptr(),
2881            self.get_group(),
2882            fid.var_id(self),
2883            value.as_ptr()
2884        )
2885        .into()
2886    }
2887}
2888
2889/*
2890    Method calling
2891*/
2892
2893/// 函数ID抽象
2894pub trait AsMethodId {
2895    fn as_mid(&self, obj: &Object) -> Result<MethodId>;
2896    fn as_eid(&self, obj: &Object) -> Result<MethodId>;
2897}
2898
2899impl<T: AsMethodName> AsMethodId for T {
2900    #[inline]
2901    fn as_mid(&self, obj: &Object) -> Result<MethodId> {
2902        obj.get_method_id(self.as_method_name()).ok_or(PBXRESULT::E_INVALID_METHOD_ID)
2903    }
2904    #[inline]
2905    fn as_eid(&self, obj: &Object) -> Result<MethodId> {
2906        obj.get_event_id(self.as_method_name()).ok_or(PBXRESULT::E_INVALID_METHOD_ID)
2907    }
2908}
2909impl AsMethodId for MethodId {
2910    #[inline]
2911    fn as_mid(&self, _obj: &Object) -> Result<MethodId> { Ok(*self) }
2912    #[inline]
2913    fn as_eid(&self, _obj: &Object) -> Result<MethodId> { Ok(*self) }
2914}
2915impl AsMethodId for Option<MethodId> {
2916    #[inline]
2917    fn as_mid(&self, _obj: &Object) -> Result<MethodId> { self.ok_or(PBXRESULT::E_INVALID_METHOD_ID) }
2918    #[inline]
2919    fn as_eid(&self, _obj: &Object) -> Result<MethodId> { self.ok_or(PBXRESULT::E_INVALID_METHOD_ID) }
2920}
2921
2922impl<'obj> Object<'obj> {
2923    /// 查找函数ID
2924    ///
2925    /// # Examples
2926    ///
2927    /// ```
2928    /// let fid = object.get_method_id("of_test").unwrap();
2929    /// let invoker = object.begin_invoke_method(fid).unwrap();
2930    /// invoker.invoke();
2931    /// ```
2932    pub fn get_method_id(&self, name: impl AsMethodName) -> Option<MethodId> {
2933        let (name, sign) = name.as_method_name();
2934        self.session.get_method_id(self.cls, name, RoutineType::Function, sign, false)
2935    }
2936
2937    /// 查找事件ID
2938    ///
2939    /// # Examples
2940    ///
2941    /// ```
2942    /// let fid = object.get_event_id("on_test").unwrap();
2943    /// let invoker = object.begin_invoke_event(fid).unwrap();
2944    /// invoker.trigger();
2945    /// ```
2946    pub fn get_event_id(&self, name: impl AsMethodName) -> Option<MethodId> {
2947        let (name, sign) = name.as_method_name();
2948        self.session.get_method_id(self.cls, name, RoutineType::Event, sign, false)
2949    }
2950
2951    /// 调用函数
2952    ///
2953    /// # Examples
2954    ///
2955    /// ```
2956    /// let rv: pbint = obj.invoke_method("of_Test", pbargs!["abcd", 123]).unwrap();
2957    /// ```
2958    pub fn invoke_method<F, R>(&mut self, mid: impl AsMethodId, arg_cb: F) -> Result<R>
2959    where
2960        F: FnOnce(Arguments) -> Result<()>,
2961        R: FromValueOwned
2962    {
2963        let invoker = self.begin_invoke_method(mid)?;
2964        arg_cb(invoker.args())?;
2965        let rv = invoker.invoke()?;
2966        R::from_value(Some(rv))
2967    }
2968
2969    /// 调用事件
2970    ///
2971    /// # Examples
2972    ///
2973    /// ```
2974    /// let rv: pbint = obj.trigger_event("onTest", pbargs!["abcd", 123]).unwrap();
2975    /// ```
2976    pub fn trigger_event<F, R>(&mut self, mid: impl AsMethodId, arg_cb: F) -> Result<R>
2977    where
2978        F: FnOnce(Arguments) -> Result<()>,
2979        R: FromValueOwned
2980    {
2981        let invoker = self.begin_invoke_event(mid)?;
2982        arg_cb(invoker.args())?;
2983        let rv = invoker.trigger()?;
2984        R::from_value(Some(rv))
2985    }
2986
2987    /// 初始化函数调用上下文
2988    ///
2989    /// # Examples
2990    ///
2991    /// ```
2992    /// let invoker = object.begin_invoke_method("of_test").unwrap();
2993    /// invoker.invoke();
2994    /// ```
2995    pub fn begin_invoke_method<'a>(
2996        &'a mut self,
2997        mid: impl AsMethodId
2998    ) -> Result<Invoker<ObjectMethod<'a, 'obj>>> {
2999        let mid = mid.as_mid(self)?;
3000        let ci = unsafe { CallInfo::new(self.cls, mid, self.session.clone())? };
3001        Ok(Invoker::<ObjectMethod>::new(ObjectMethod::new(self), ci))
3002    }
3003
3004    /// 初始化事件调用上下文
3005    ///
3006    /// # Examples
3007    ///
3008    /// ```
3009    /// let invoker = object.begin_invoke_event("on_test").unwrap();
3010    /// invoker.trigger();
3011    /// ```
3012    pub fn begin_invoke_event<'a>(
3013        &'a mut self,
3014        mid: impl AsMethodId
3015    ) -> Result<Invoker<ObjectEvent<'a, 'obj>>> {
3016        let mid = mid.as_eid(self)?;
3017        let ci = unsafe { CallInfo::new(self.cls, mid, self.session.clone())? };
3018        Ok(Invoker::<ObjectEvent>::new(ObjectEvent::new(self), ci))
3019    }
3020}
3021
3022/// 共享的对象
3023/// 增加了全局引用计数
3024#[derive(Clone)]
3025pub struct SharedObject {
3026    inner: Rc<RefCell<SharedObjectInner>>
3027}
3028
3029impl SharedObject {
3030    pub(crate) unsafe fn from_ptr(ptr: pbobject, session: Session) -> SharedObject {
3031        SharedObject {
3032            inner: Rc::new(RefCell::new(SharedObjectInner::from_ptr(ptr, session)))
3033        }
3034    }
3035}
3036
3037impl Deref for SharedObject {
3038    type Target = RefCell<SharedObjectInner>;
3039    fn deref(&self) -> &Self::Target { &self.inner }
3040}
3041
3042impl From<Object<'_>> for SharedObject {
3043    fn from(obj: Object) -> Self { unsafe { Self::from_ptr(obj.ptr, obj.session) } }
3044}
3045
3046pub struct SharedObjectInner {
3047    obj: Object<'static>
3048}
3049
3050impl SharedObjectInner {
3051    pub(crate) unsafe fn from_ptr(ptr: pbobject, session: Session) -> SharedObjectInner {
3052        ffi::pbsession_AddGlobalRef(session.as_ptr(), ptr);
3053        SharedObjectInner {
3054            obj: Object::from_ptr(ptr, session)
3055        }
3056    }
3057}
3058
3059impl Drop for SharedObjectInner {
3060    fn drop(&mut self) { unsafe { ffi::pbsession_RemoveGlobalRef(self.obj.session.as_ptr(), self.obj.ptr) } }
3061}
3062
3063impl Deref for SharedObjectInner {
3064    type Target = Object<'static>;
3065    fn deref(&self) -> &Self::Target { &self.obj }
3066}
3067
3068impl DerefMut for SharedObjectInner {
3069    fn deref_mut(&mut self) -> &mut Self::Target { &mut self.obj }
3070}
3071
3072/// Rust对象绑定的PB对象
3073pub struct ContextObject {
3074    obj: Object<'static>
3075}
3076
3077impl ContextObject {
3078    pub(crate) unsafe fn from_ptr(ptr: pbobject, session: &Session) -> ContextObject {
3079        ContextObject {
3080            obj: Object::from_ptr(ptr, session.clone())
3081        }
3082    }
3083}
3084
3085impl Deref for ContextObject {
3086    type Target = Object<'static>;
3087    fn deref(&self) -> &Self::Target { &self.obj }
3088}
3089
3090impl DerefMut for ContextObject {
3091    fn deref_mut(&mut self) -> &mut Self::Target { &mut self.obj }
3092}
3093
3094/// 用户自定义对象抽象
3095#[cfg(any(feature = "nonvisualobject", feature = "visualobject"))]
3096pub trait UserObject: Sized + 'static {
3097    /// 类名(小写)
3098    const CLASS_NAME: &'static PBStr;
3099
3100    /// 创建对象
3101    fn new(session: Session, ctx: ContextObject) -> Result<Self>;
3102
3103    /// 接口调用
3104    ///
3105    /// # Returns
3106    ///
3107    /// - 调用的方法ID被处理后返回`Ok(None)`
3108    /// - 调用的方法ID未处理则返回`Ok(Some(mid))`,`mid`为最后一个方法ID的偏移,此设计用于实现继承
3109    fn invoke(&mut self, mid: MethodId, ci: &CallInfoRef) -> Result<Option<MethodId>>;
3110}
3111
3112/// 不可视对象
3113#[cfg(feature = "nonvisualobject")]
3114pub trait NonVisualObject: UserObject {
3115    /// 注册
3116    fn register() { export::register_nonvisualobject::<Self>() }
3117}
3118
3119/// 可视对象
3120#[cfg(feature = "visualobject")]
3121pub trait VisualObject: UserObject {
3122    /// 窗口类名
3123    const WINDOW_CLASS_NAME: &'static PBStr;
3124
3125    /// 创建窗口
3126    fn create_control(
3127        &mut self,
3128        dwExStyle: u32,
3129        window_name: &PBStr,
3130        dwStyle: u32,
3131        x: i32,
3132        y: i32,
3133        width: i32,
3134        height: i32,
3135        parent: HWND,
3136        instance: HINSTANCE
3137    ) -> HWND;
3138
3139    /// 窗口消息与PB事件ID映射
3140    #[allow(unused_variables)]
3141    fn get_event_id(&self, hwnd: HWND, msg: u16, wparam: u32, lparam: u32) -> Option<i32> { None }
3142
3143    /// 注册
3144    fn register() { export::register_visualobject::<Self>() }
3145}
pbni/object.rs

pbni/
object.rs
