mirror of
https://github.com/weyne85/rustdesk.git
synced 2025-10-29 17:00:05 +00:00
156 lines
3.1 KiB
Rust
156 lines
3.1 KiB
Rust
// This component uses Sciter Engine,
|
|
// copyright Terra Informatica Software, Inc.
|
|
// (http://terrainformatica.com/).
|
|
|
|
/*!
|
|
|
|
[Serde](https://docs.rs/serde) support for [Sciter](https://docs.rs/sciter-rs) engine.
|
|
|
|
While technically you could just use the `serde_json` crate and perform serialization via
|
|
an intermediate string (something like `sciter::Value::from_str(&serde_json::to_string(<your data>)?)?`),
|
|
you can also use direct serialization between your data and `sciter::Value`.
|
|
|
|
## Supported types of Sciter value
|
|
|
|
+ Bool (`bool`)
|
|
+ Integer (`i8`-`i32`)
|
|
+ Float (`f32`-`f64`)
|
|
+ String (`&str`, `String`)
|
|
+ Bytes (`&[u8]`)
|
|
+ Array (`&[T]`, `Vec<T>`)
|
|
+ Object (key-value mapping like `struct` or `HashMap`, `BTreeMap`, etc.)
|
|
|
|
Unsupported:
|
|
|
|
- Date
|
|
- Currency
|
|
- Length
|
|
- Range
|
|
- Duration
|
|
- Angle
|
|
- Color
|
|
|
|
## Supported types of the Serde data model
|
|
|
|
* [x] `bool`
|
|
* [x] integer types except the following:
|
|
* [-] `i64`/`u64` - 64-bit integers stored as `f64` in Sciter
|
|
* [x] strings
|
|
* [x] byte arrays
|
|
* [x] option
|
|
* [x] unit (stored as `null`)
|
|
* [x] unit struct (stored as `null`)
|
|
* [x] unit variant (aka `enum`, stored just as enum index of `i32` type)
|
|
* [x] newtype struct (aka `struct Io(u32)`, stored as underlaying value)
|
|
* [-] newtype variant
|
|
* [x] seq, like vector (stored as array)
|
|
* [x] tuple (stored as array)
|
|
* [x] tuple struct (stored as array)
|
|
* [-] tuple variant
|
|
* [x] map (stored as map)
|
|
* [x] struct (stored as map)
|
|
* [-] struct variant
|
|
|
|
See the [Serde data model](https://serde.rs/data-model.html) for reference.
|
|
|
|
# Examples
|
|
|
|
```rust
|
|
extern crate sciter;
|
|
extern crate sciter_serde;
|
|
|
|
use sciter::Value;
|
|
use sciter_serde::{from_value, to_value};
|
|
|
|
fn back_and_forth() {
|
|
let v: Value = to_value(&true).unwrap();
|
|
let b: bool = from_value(&v).unwrap();
|
|
assert_eq!(b, true);
|
|
}
|
|
|
|
fn main() {
|
|
|
|
// bool
|
|
let v: Value = to_value(&true).unwrap();
|
|
assert!(v.is_bool());
|
|
assert_eq!(v, Value::from(true));
|
|
|
|
// numbers
|
|
let v = to_value(&12u32).unwrap();
|
|
assert_eq!(v, 12.into());
|
|
|
|
let v = to_value(& 42.0f64).unwrap();
|
|
assert_eq!(v, 42.0f64.into());
|
|
|
|
// strings
|
|
let v = to_value("hello").unwrap();
|
|
assert_eq!(v, "hello".into());
|
|
|
|
// arrays
|
|
let a = [1,2,3];
|
|
let v = to_value(&a).unwrap();
|
|
assert_eq!(v, a.iter().cloned().collect());
|
|
|
|
// maps
|
|
let m = {
|
|
use std::collections::BTreeMap;
|
|
let mut m = BTreeMap::new();
|
|
m.insert("17", 17);
|
|
m.insert("42", 42);
|
|
m
|
|
};
|
|
let v = to_value(&m).unwrap();
|
|
assert_eq!(v, Value::parse(r#"{ "17": 17, "42": 42 }"#).unwrap());
|
|
}
|
|
```
|
|
|
|
With derived serialization:
|
|
|
|
```rust
|
|
# #![doc(test(no_crate_inject))]
|
|
#[macro_use]
|
|
extern crate serde_derive;
|
|
extern crate serde;
|
|
|
|
extern crate sciter;
|
|
extern crate sciter_serde;
|
|
|
|
use sciter::Value;
|
|
use sciter_serde::to_value;
|
|
|
|
fn main() {
|
|
|
|
// structs
|
|
#[derive(Serialize)]
|
|
struct Test {
|
|
x: i32,
|
|
y: i32,
|
|
}
|
|
|
|
let v = to_value(&Test {x: 1, y: 2}).unwrap();
|
|
assert_eq!(v, Value::parse(r#"{ "x": 1, "y": 2 }"#).unwrap());
|
|
}
|
|
|
|
```
|
|
|
|
*/
|
|
#![allow(clippy::redundant_field_names)]
|
|
#![allow(clippy::tabs_in_doc_comments)]
|
|
|
|
#[macro_use]
|
|
extern crate serde;
|
|
extern crate sciter;
|
|
|
|
|
|
mod error;
|
|
mod ser;
|
|
mod de;
|
|
|
|
#[doc(inline)]
|
|
pub use ser::to_value;
|
|
|
|
#[doc(inline)]
|
|
pub use de::from_value;
|
|
|
|
pub use error::{Result, Error};
|