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 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93
/*! Integration between `sval` and `serde`. Add the `serde` feature to your `Cargo.toml` to enable this module: ```toml,no_run [dependencies.sval] features = ["serde"] ``` # From `sval` to `serde` A type that implements [`sval::Value`](../value/trait.Value.html) can be converted into a type that implements [`serde::Serialize`]: ``` # struct MyValue; # impl sval::value::Value for MyValue { # fn stream(&self, stream: &mut sval::value::Stream) -> Result<(), sval::value::Error> { # unimplemented!() # } # } # let my_value = MyValue; let my_serialize = sval::serde::to_serialize(my_value); ``` # From `serde` to `sval` A type that implements [`serde::Serialize`] can be converted into a type that implements [`sval::Value`](../value/trait.Value.html): ``` # struct MySerialize; # impl serde_lib::Serialize for MySerialize { # fn serialize<S: serde_lib::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> { # unimplemented!() # } # } # let my_serialize = MySerialize; let my_value = sval::serde::to_value(my_serialize); ``` */ mod error; mod to_serialize; mod to_value; use crate::{ Error, Stream, Value, }; use serde_lib::ser::{ Serialize, Serializer, }; /** Convert a [`Value`] into a [`Serialize`]. If the `Value` uses nested maps or sequences where the keys, values or elements aren't known upfront then this method will need to allocate for them. */ pub fn to_serialize(value: impl Value) -> impl Serialize { to_serialize::ToSerialize(value) } /** Serialize a [`Value`] using the given [`Serializer`]. */ pub fn serialize<S>(serializer: S, value: impl Value) -> Result<S::Ok, S::Error> where S: Serializer, { to_serialize(value).serialize(serializer) } /** Convert a [`Serialize`] into a [`Value`]. */ pub fn to_value(value: impl Serialize) -> impl Value { to_value::ToValue(value) } /** Stream a [`Serialize`] using the given [`Stream`]. */ pub fn stream(stream: impl Stream, value: impl Serialize) -> Result<(), Error> { crate::stream(stream, to_value(value)) }