1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64
//! This crate allows you to serialize and deserialize any type that implements //! `serde::Serialize` and `serde::Deserialize` into/from `rlua::Value`. //! //! Implementation is similar to `serde_json::Value` //! //! Example usage: //! //! ```rust //! extern crate serde; //! #[macro_use] //! extern crate serde_derive; //! extern crate rlua; //! extern crate rlua_serde; //! //! fn main() { //! #[derive(Serialize, Deserialize)] //! struct Foo { //! bar: u32, //! baz: Vec<String>, //! } //! //! let lua = rlua::Lua::new(); //! lua.context(|lua| { //! let foo = Foo { //! bar: 42, //! baz: vec![String::from("fizz"), String::from("buzz")], //! }; //! //! let value = rlua_serde::to_value(lua, &foo).unwrap(); //! lua.globals().set("value", value).unwrap(); //! lua.load( //! r#" //! assert(value["bar"] == 42) //! assert(value["baz"][2] == "buzz") //! "#).exec().unwrap(); //! }); //! } //! ``` extern crate rlua; #[macro_use] extern crate serde; #[cfg(test)] #[macro_use] extern crate serde_derive; pub mod error; pub mod ser; pub mod de; use rlua::{Context, Value, Error}; pub fn to_value<T: serde::Serialize>(lua: Context, t: T) -> Result<Value, Error> { let serializer = ser::Serializer { lua }; Ok(t.serialize(serializer)?) } pub fn from_value<'de, T: serde::Deserialize<'de>>(value: Value<'de>) -> Result<T, Error> { let deserializer = de::Deserializer { value }; Ok(T::deserialize(deserializer)?) }