libai/
rune.rs

1use super::dynamic::Dynamic;
2use rune::{ToValue, Value};
3
4//rune Value 和 Dynamic 类型的相互转换
5use std::sync::{Arc, RwLock};
6use smol_str::SmolStr;
7use std::collections::BTreeMap;
8
9impl From<Value> for Dynamic {
10    fn from(value: Value)-> Self {
11        match value {
12            Value::EmptyTuple | Value::EmptyStruct(_)=> Self::Null,
13            Value::Bool(b)=> Self::Bool(b),
14            Value::Byte(b)=> Self::Byte(b),
15            Value::Integer(i)=> Self::Int(i),
16            Value::Float(f)=> Self::Double(f),
17            Value::String(s)=> Self::String(Arc::new(SmolStr::new(s.borrow_ref().unwrap().as_str()))),
18            Value::Vec(v)=> {
19                let array: Vec<Dynamic> = v.borrow_ref().unwrap().iter().map(|v| Self::from(v.clone()) ).collect();     //Shared<T> Clone 是一个 cheap 操作
20                Self::Array(Arc::new(RwLock::new(array)))
21            },
22            Value::Object(o)=> {
23                let mut objec = BTreeMap::new();
24                o.borrow_ref().unwrap().iter().for_each(|(k, v)| {
25                    objec.insert(SmolStr::from(k.as_str()), Self::from(v.clone()) );
26                });
27                Self::Object(Arc::new(RwLock::new(objec))) 
28            },
29            Value::Bytes(b)=> Self::Bytes(Arc::new(b.borrow_ref().unwrap().to_vec())),
30            Value::Any(any_obj)=> if let Ok(obj) = any_obj.take_downcast::<Dynamic>() { obj } else { Dynamic::Null}     //一次性转换
31            _=> {
32                Self::Null
33            }
34        }
35    }
36}
37
38pub fn str_to_rune(s: &str)-> rune::alloc::String {
39    let mut v = rune::alloc::Vec::try_with_capacity(s.len()).unwrap();
40    v.try_extend_from_slice(s.as_bytes()).unwrap();
41    unsafe {rune::alloc::String::from_utf8_unchecked(v) }
42}
43
44pub fn bytes_to_rune(bytes: &[u8])-> rune::alloc::String {
45    unsafe {rune::alloc::String::from_utf8_unchecked(rune::alloc::Vec::try_from(bytes).unwrap()) }
46}
47
48impl From<Dynamic> for Value {
49    fn from(d: Dynamic) -> Self {
50        match d {
51            Dynamic::Null=> Value::EmptyTuple,
52            Dynamic::Bool(b)=> Value::Bool(b),
53            Dynamic::Byte(b)=> Value::Byte(b),
54            Dynamic::Int(i)=> Value::Integer(i),
55            Dynamic::UInt(u)=> Value::Integer(u as i64),
56            Dynamic::Float(f)=> Value::Float(f as f64),
57            Dynamic::Double(f)=> Value::Float(f),
58            Dynamic::String(s)=> str_to_rune(s.as_str()).to_value().unwrap(),
59            Dynamic::Array(array)=> {
60                let mut vec = rune::alloc::Vec::new();
61                while let Some(item) = array.read().unwrap().iter().next() {
62                    vec.try_push(Self::from(item.clone())).unwrap();
63                }
64                vec.to_value().unwrap()
65            },
66            Dynamic::Object(object)=> {
67                let mut objs = rune::runtime::Object::default();
68                while let Some((k, v)) = object.read().unwrap().iter().next() {
69                    objs.insert(str_to_rune(k.as_str()), Self::from(v.clone())).unwrap();
70                }
71                objs.to_value().unwrap()
72            },
73            Dynamic::Bytes(b)=> {
74                b.to_vec().to_value().unwrap()
75            },
76        }
77    }
78}
79
80use super::msgpack::MsgPack;
81use byteorder::{BigEndian, WriteBytesExt};
82
83impl MsgPack for Value {
84    fn encode(&self, buf: &mut Vec<u8>) {
85        match self {
86            Value::EmptyTuple | Value::EmptyStruct(_) => buf.push(0xc0),
87            Value::Bool(v) => buf.push(if *v { 0xc3 } else { 0xc2 }),
88            Value::Byte(b) => {
89                buf.push(0xcc);
90                buf.push(*b as u8);
91            }
92            Value::Integer(v) => v.encode(buf),
93            Value::Float(v) => {
94                buf.push(0xcb);
95                let int_value = unsafe { std::mem::transmute::<f64, u64>(*v) };
96                buf.write_u64::<BigEndian>(int_value).unwrap();
97            }
98            Value::String(s) => s.borrow_ref().unwrap().as_str().encode(buf),
99            Value::Bytes(v) => {
100                v.borrow_ref()
101                    .map(|raw| {
102                        let length = raw.len();
103                        if length < 0x100 {
104                            buf.push(0xc4);
105                            buf.push(length as u8);
106                        } else if length < 0x10000 {
107                            buf.push(0xc5);
108                            buf.write_u16::<BigEndian>(length as u16).unwrap();
109                        } else {
110                            buf.push(0xc6);
111                            buf.write_u32::<BigEndian>(length as u32).unwrap();
112                        }
113                        buf.extend_from_slice(raw.as_slice());
114                    })
115                    .unwrap();
116            }
117            Value::Vec(v) => {
118                v.borrow_ref()
119                    .map(|raw| {
120                        let length = raw.len();
121                        if length < 0x10 {
122                            buf.push(0x90 | length as u8);
123                        } else if length < 0x10000 {
124                            buf.push(0xdc);
125                            buf.write_u16::<BigEndian>(length as u16).unwrap();
126                        } else {
127                            buf.push(0xdd);
128                            buf.write_u32::<BigEndian>(length as u32).unwrap();
129                        }
130                        raw.iter().for_each(|item| item.encode(buf));
131                    })
132                    .unwrap();
133            }
134            Value::Object(v) => {
135                v.borrow_ref()
136                    .map(|raw| {
137                        let length = raw.len();
138                        if length < 16 {
139                            buf.push(0x80 | length as u8);
140                        } else if length <= 0x10000 {
141                            buf.push(0xde);
142                            buf.write_u16::<BigEndian>(length as u16).unwrap();
143                        } else {
144                            buf.push(0xdf);
145                            buf.write_u32::<BigEndian>(length as u32).unwrap();
146                        }
147                        raw.iter().for_each(|(k, v)| {
148                            k.as_str().encode(buf);
149                            v.encode(buf);
150                        });
151                    })
152                    .unwrap();
153            }
154            _ => {}
155        }
156    }
157}
158
159#[macro_export]
160macro_rules! object {
161    ($($k:expr => $v:expr), *) => {{
162        let mut obj = rune::runtime::Object::default();
163        $( let _ = obj.insert(rune::alloc::String::try_from($k).unwrap(), rune::runtime::Value::try_from($v)?); )*
164        obj.try_into().unwrap()
165    }};
166}
167
168use super::json::{FromJson, ToJson};
169use super::skip_white;
170impl FromJson for Value {
171    fn from_json(buf: &[u8])-> Result<(Self, usize)> {
172        let mut pos = skip_white(buf)?;
173        if buf[pos] == b'[' {           //是一个 vec
174            pos += 1;
175            pos += skip_white(&buf[pos..])?;
176            let mut vec = rune::alloc::Vec::<Self>::new();
177            while buf[pos] != b']' {
178                let (item, size) = Self::from_json(&buf[pos..])?;
179                vec.try_push(item)?;
180                pos += size;
181                pos += skip_white(&buf[pos..])?;
182                if buf[pos] == b',' {
183                    pos += 1;
184                    pos += skip_white(&buf[pos..])?;
185                }
186            };
187            Ok((vec.to_value().unwrap(), pos + 1))
188        } else if buf[pos] == b'{' {           //是一个 object
189            pos += 1;
190            pos += skip_white(&buf[pos..])?;
191            let mut obj = rune::runtime::Object::new();
192            while buf[pos] != b'}' {
193                assert_err!(buf[pos] != b'"', anyhow!("need a string key"));
194                let (key, size) = Self::get_string(&buf[pos..])?;
195                pos += size;
196                pos += skip_white(&buf[pos..])?;
197                assert_err!(buf[pos] != b':', anyhow!("need a :"));
198                pos += 1;
199                pos += skip_white(&buf[pos..])?;
200                let (item, size) = Self::from_json(&buf[pos..])?;
201                obj.insert(str_to_rune(key.as_str()), item)?;
202                pos += size;
203                pos += skip_white(&buf[pos..])?;
204                if buf[pos] == b',' {
205                    pos += 1;
206                    pos += skip_white(&buf[pos..])?;
207                }
208            }
209            Ok((obj.to_value().unwrap(), pos + 1))
210        } else if buf[pos] == b'"' {
211            let (s, size) = Self::get_string(&buf[pos..])?;
212            Ok((str_to_rune(s.as_str()).to_value().into_result()?, size))
213        } else {
214            let (token, size) = Self::get_token(&buf[pos..])?;
215            if token == "true" {
216                Ok((Value::from(true), size))
217            } else if token == "false" {
218                Ok((Value::from(false), size))
219            } else if token == "null" {
220                Ok((Value::from(()), size))
221            } else if token.contains('.') {
222                let v = token.parse::<f64>()?;
223                Ok((Value::from(v), size))
224            } else {
225                let v = token.parse::<i64>()?;
226                Ok((Value::from(v), size))
227            }
228        }
229    }
230}
231
232use rune::runtime::{Bytes, Object};
233impl ToJson for Object {
234    fn to_json(&self, buf: &mut String) {
235        buf.push('{');
236        let mut once = super::ZOnce::new("", ",\n");
237        self.iter().for_each(|item| {
238            buf.push_str(once.take());
239            item.0.as_str().to_json(buf);
240            buf.push_str(": ");
241            item.1.to_json(buf);
242        });
243        buf.push('}');
244    }
245}
246
247impl ToJson for Value {
248    fn to_json(&self, buf: &mut String) {
249        match self {
250            Self::Bool(b) => if *b { buf.push_str("true") } else { buf.push_str("false") }
251            Self::Float(f) => buf.push_str(&f.to_string()),
252            Self::Integer(i) => i.to_json(buf),
253            Self::EmptyTuple | Value::EmptyStruct(_) => buf.push_str("null"),
254            Self::String(s) =>s.borrow_ref().unwrap().as_str().to_json(buf),
255            Self::Vec(v) => {
256                buf.push('[');
257                let mut once = super::ZOnce::new("", ",\n");
258                v.borrow_ref().map(|raw| raw.iter().for_each(|item| {
259                    buf.push_str(once.take());
260                    item.to_json(buf);
261                })).unwrap();
262                buf.push(']');
263            }
264            Self::Object(m) => m.borrow_ref().map(|o| o.to_json(buf)).unwrap(),
265            _ => {
266                buf.push_str("null");
267            }
268        }
269    }
270}
271
272use super::msgpack::MsgUnpack;
273use super::{assert_err, assert_ok};
274use anyhow::{Result, anyhow};
275
276fn slice_to_string(slice: &[u8]) -> Result<Value> {
277    let buf: rune::alloc::Vec<u8> = slice.try_into()?;
278    let s = rune::alloc::String::from_utf8(buf)?;
279    Ok(s.try_into()?)
280}
281
282fn slice_to_bytes(slice: &[u8]) -> Result<Value> {
283    Ok(Value::try_from(rune::runtime::Bytes::from_slice(slice)?)?)
284}
285
286fn vec_to_object(kvs: Vec<Value>) -> Result<Value> {
287    let mut obj = rune::runtime::Object::with_capacity(kvs.len())?;
288    let mut k: Option<Value> = None;
289    for kv in kvs {
290        if let Some(k) = k.take() {
291            obj.insert(k.into_string().unwrap().take()?, kv)?;
292        } else {
293            k = Some(kv);
294        }
295    }
296    Ok(obj.try_into()?)
297}
298
299use super::msgpack::{read_8, read_16, read_32, read_64};
300impl MsgUnpack for Value {
301    fn decode(buf: &[u8]) -> Result<(Self, usize)> {
302        assert_err!(buf.len() < 1, anyhow!("no data"));
303        let first_byte = buf[0];
304        assert_ok!(first_byte <= 0x7f, (Value::from(first_byte as i64), 1));
305        assert_ok!(first_byte >= 0xe0, (Value::from(first_byte as i64 - 256), 1));
306        if first_byte >= 0x80 && first_byte <= 0x8f {
307            let len = (first_byte & 0x0f) as usize;
308            let (value, size) = Self::decode_array(&buf[1..], len * 2)?;
309            return vec_to_object(value).map(|r| (r, 1 + size));
310        }
311        if first_byte >= 0x90 && first_byte <= 0x9f {
312            let len = (first_byte & 0x0f) as usize;
313            let (value, size) = Self::decode_array(&buf[1..], len)?;
314            return Ok((value.to_value().unwrap(), 1 + size));
315        }
316
317        if first_byte >= 0xa0 && first_byte <= 0xbf {
318            let len = (first_byte & 0x1f) as usize;
319            assert_err!(buf.len() < 1 + len, anyhow!("no data"));
320            return slice_to_string(&buf[1..1 + len]).map(|r| (r, 1 + len));
321        }
322
323        assert_ok!(first_byte == 0xc0, (().into(), 1));
324        assert_err!(first_byte == 0xc1, anyhow!("0xc1 never used"));
325        assert_ok!(first_byte == 0xc2, (false.into(), 1));
326        assert_ok!(first_byte == 0xc3, (true.into(), 1));
327
328        if first_byte == 0xc4 {
329            assert_err!(buf.len() < 2, anyhow!("no data"));
330            let len = read_8(&buf[1..]) as usize;
331            assert_err!(buf.len() < 2 + len, anyhow!("no data"));
332            return slice_to_bytes(&buf[2..2 + len]).map(|r| (r, 2 + len));
333        }
334
335        if first_byte == 0xc5 {
336            assert_err!(buf.len() < 3, anyhow!("no data"));
337            let len = read_16(&buf[1..]) as usize;
338            assert_err!(buf.len() < 2 + len, anyhow!("no data"));
339            return slice_to_bytes(&buf[3..3 + len]).map(|r| (r, 3 + len));
340        }
341
342        if first_byte == 0xc6 {
343            assert_err!(buf.len() < 5, anyhow!("no data"));
344            let len = read_32(&buf[1..]) as usize;
345            assert_err!(buf.len() < 5 + len, anyhow!("no data"));
346            return slice_to_bytes(&buf[5..5 + len]).map(|r| (r, 5 + len));
347        }
348
349        if first_byte == 0xc7 {
350            assert_err!(buf.len() < 3, anyhow!("no data"));
351            let len = read_8(&buf[1..]) as usize;
352            let _type_id = unsafe { std::mem::transmute::<u8, i8>(buf[2]) };
353            assert_err!(buf.len() < 3 + len, anyhow!("no data"));
354            //let _value = raw[3..3 + len].to_vec();
355            return Ok((().into(), 3 + len)); //暂时没实现
356        }
357
358        if first_byte == 0xc8 {
359            assert_err!(buf.len() < 4, anyhow!("no data"));
360            let len = read_16(&buf[1..]) as usize;
361            let _type_id = unsafe { std::mem::transmute::<u8, i8>(buf[3]) };
362            assert_err!(buf.len() < 4 + len, anyhow!("no data"));
363            //let _value = raw[4..4 + len].to_vec();
364            return Ok((().into(), 4 + len)); //暂时没实现
365        }
366
367        if first_byte == 0xc9 {
368            assert_err!(buf.len() < 6, anyhow!("no data"));
369            let len = read_32(&buf[1..]) as usize;
370            let _type_id = unsafe { std::mem::transmute::<u8, i8>(buf[5]) };
371            assert_err!(buf.len() < 6 + len, anyhow!("no data"));
372            //let _value = raw[6..6 + len].to_vec();
373            return Ok((().into(), 6 + len)); //暂时没实现
374        }
375
376        if first_byte == 0xca {
377            assert_err!(buf.len() < 5, anyhow!("no data"));
378            let raw_value = read_32(&buf[1..]) as u32;
379            let value = unsafe { std::mem::transmute::<u32, f32>(raw_value) };
380            return Ok((Value::from(value as f64), 5));
381        }
382
383        if first_byte == 0xcb {
384            assert_err!(buf.len() < 9, anyhow!("no data"));
385            let raw_value = read_64(&buf[1..]);
386            let value = unsafe { std::mem::transmute::<u64, f64>(raw_value) };
387            return Ok((Value::from(value), 9));
388        }
389
390        if first_byte == 0xcc {
391            assert_err!(buf.len() < 2, anyhow!("no data"));
392            let value = read_8(&buf[1..]);
393            return Ok((Value::from(value as i64), 2));
394        }
395
396        if first_byte == 0xcd {
397            assert_err!(buf.len() < 3, anyhow!("no data"));
398            let value = read_16(&buf[1..]);
399            return Ok((Value::from(value as i64), 3));
400        }
401
402        if first_byte == 0xce {
403            assert_err!(buf.len() < 5, anyhow!("no data"));
404            let value = read_32(&buf[1..]);
405            return Ok((Value::from(value as i64), 5));
406        }
407
408        if first_byte == 0xcf {
409            assert_err!(buf.len() < 9, anyhow!("no data"));
410            let value = read_64(&buf[1..]);
411            return Ok((Value::from(value as i64), 9));
412        }
413
414        if first_byte == 0xd0 {
415            assert_err!(buf.len() < 2, anyhow!("no data"));
416            let raw_value = read_8(&buf[1..]) as i8;
417            let value = raw_value as i64; //unsafe { std::mem::transmute::<u64, i64>(raw_value) };
418            return Ok((Value::from(value), 2));
419        }
420
421        if first_byte == 0xd1 {
422            assert_err!(buf.len() < 3, anyhow!("no data"));
423            let raw_value = read_16(&buf[1..]);
424            let value = unsafe { std::mem::transmute::<u16, i16>(raw_value) } as i64;
425            return Ok((Value::from(value), 3));
426        }
427
428        if first_byte == 0xd2 {
429            assert_err!(buf.len() < 5, anyhow!("no data"));
430            let raw_value = read_32(&buf[1..]);
431            let value = unsafe { std::mem::transmute::<u32, i32>(raw_value) } as i64;
432            return Ok((Value::from(value), 5));
433        }
434
435        if first_byte == 0xd3 {
436            assert_err!(buf.len() < 9, anyhow!("no data"));
437            let raw_value = read_64(&buf[1..]);
438            let value = unsafe { std::mem::transmute::<u64, i64>(raw_value) };
439            return Ok((Value::from(value), 9));
440        }
441
442        if first_byte == 0xd4 {
443            assert_err!(buf.len() < 3, anyhow!("no data"));
444            let _type_id = unsafe { std::mem::transmute::<u8, i8>(buf[1]) };
445            //let _value = raw[2..3].to_vec();
446            return Ok((().into(), 3));
447        }
448
449        if first_byte == 0xd5 {
450            assert_err!(buf.len() < 4, anyhow!("no data"));
451            let _type_id = unsafe { std::mem::transmute::<u8, i8>(buf[1]) };
452            //let _value = raw[2..4].to_vec();
453            return Ok((().into(), 4));
454        }
455
456        if first_byte == 0xd6 {
457            assert_err!(buf.len() < 6, anyhow!("no data"));
458            let _type_id = unsafe { std::mem::transmute::<u8, i8>(buf[1]) };
459            //let _value = raw[2..6].to_vec();
460            return Ok((().into(), 6));
461        }
462
463        if first_byte == 0xd7 {
464            assert_err!(buf.len() < 10, anyhow!("no data"));
465            let _type_id = unsafe { std::mem::transmute::<u8, i8>(buf[1]) };
466            //let _value = raw[2..10].to_vec();
467            return Ok((().into(), 10));
468        }
469
470        if first_byte == 0xd8 {
471            assert_err!(buf.len() < 18, anyhow!("no data"));
472            let _type_id = unsafe { std::mem::transmute::<u8, i8>(buf[1]) };
473            //let _value = raw[2..18].to_vec();
474            return Ok((().into(), 18));
475        }
476
477        if first_byte == 0xd9 {
478            assert_err!(buf.len() < 2, anyhow!("no data"));
479            let len = read_8(&buf[1..]) as usize;
480            assert_err!(buf.len() < 2 + len, anyhow!("no data"));
481            return slice_to_string(&buf[2..2 + len]).map(|r| (r, 2 + len));
482        }
483
484        if first_byte == 0xda {
485            assert_err!(buf.len() < 3, anyhow!("no data"));
486            let len = read_16(&buf[1..]) as usize;
487            assert_err!(buf.len() < 3 + len, anyhow!("no data"));
488            return slice_to_string(&buf[3..3 + len]).map(|r| (r, 3 + len));
489        }
490
491        if first_byte == 0xdb {
492            assert_err!(buf.len() < 5, anyhow!("no data"));
493            let len = read_32(&buf[1..]) as usize;
494            assert_err!(buf.len() < 5 + len, anyhow!("no data"));
495            return slice_to_string(&buf[5..5 + len]).map(|r| (r, 5 + len));
496        }
497
498        if first_byte == 0xdc {
499            assert_err!(buf.len() < 3, anyhow!("no data"));
500            let len = read_16(&buf[1..]) as usize;
501            let (value, size) = Self::decode_array(&buf[3..], len)?;
502            return Ok((value.to_value().unwrap(), 3 + size));
503        }
504
505        if first_byte == 0xdd {
506            assert_err!(buf.len() < 5, anyhow!("no data"));
507            let len = read_32(&buf[1..]) as usize;
508            let (value, size) = Self::decode_array(&buf[5..], len)?;
509            return Ok((value.to_value().unwrap(), 5 + size));
510        }
511
512        if first_byte == 0xde {
513            assert_err!(buf.len() < 3, anyhow!("no data"));
514            let len = read_16(&buf[1..]) as usize;
515            let (value, size) = Self::decode_array(&buf[3..], len * 2)?;
516            return vec_to_object(value).map(|r| (r, 3 + size));
517        }
518
519        if first_byte == 0xdf {
520            assert_err!(buf.len() < 5, anyhow!("no data"));
521            let len = read_32(&buf[1..]) as usize;
522            let (value, size) = Self::decode_array(&buf[5..], len * 2)?;
523            return vec_to_object(value).map(|r| (r, 5 + size));
524        }
525        Err(anyhow!("error code {}", first_byte))
526    }
527}
libai/rune.rs

libai/
rune.rs
