Trait miniconf::TreeSerialize

source ·
pub trait TreeSerialize<const Y: usize = 1>: TreeKey<Y> {
    // Required method
    fn serialize_by_key<K, S>(
        &self,
        keys: K,
        ser: S
    ) -> Result<usize, Error<S::Error>>
       where K: Keys,
             S: Serializer;
}
Expand description

Serialize a leaf node by its keys.

See also crate::JsonCoreSlash or Postcard for convenient super traits with blanket implementations using this trait.

§Derive macro

crate::TreeSerialize derives TreeSerialize for structs with named fields and tuple structs. The field attributes are described in the TreeKey trait.

Required Methods§

source

fn serialize_by_key<K, S>( &self, keys: K, ser: S ) -> Result<usize, Error<S::Error>>
where K: Keys, S: Serializer,

Serialize a node by keys.

use miniconf::{TreeSerialize, TreeKey};
#[derive(TreeKey, TreeSerialize)]
struct S {
    foo: u32,
    #[tree(depth=1)]
    bar: [u16; 2],
};
let s = S { foo: 9, bar: [11, 3] };
let mut buf = [0u8; 10];
let mut ser = serde_json_core::ser::Serializer::new(&mut buf);
s.serialize_by_key(["bar", "0"].into_iter(), &mut ser).unwrap();
let len = ser.end();
assert_eq!(&buf[..len], b"11");
§Args
  • keys: An Iterator of Keys identifying the node.
  • ser: A Serializer to to serialize the value.
§Returns

Node depth on success.

Object Safety§

This trait is not object safe.

Implementations on Foreign Types§

source§

impl<T: Serialize> TreeSerialize for Option<T>

source§

fn serialize_by_key<K, S>( &self, keys: K, ser: S ) -> Result<usize, Error<S::Error>>
where K: Keys, S: Serializer,

source§

impl<T: Serialize, const N: usize> TreeSerialize for [T; N]

source§

fn serialize_by_key<K, S>( &self, keys: K, ser: S ) -> Result<usize, Error<S::Error>>
where K: Keys, S: Serializer,

source§

impl<T: TreeSerialize<{ _ }>> TreeSerialize<2> for Option<T>

source§

fn serialize_by_key<K, S>( &self, keys: K, ser: S ) -> Result<usize, Error<S::Error>>
where K: Keys, S: Serializer,

source§

impl<T: TreeSerialize<{ _ }>> TreeSerialize<3> for Option<T>

source§

fn serialize_by_key<K, S>( &self, keys: K, ser: S ) -> Result<usize, Error<S::Error>>
where K: Keys, S: Serializer,

source§

impl<T: TreeSerialize<{ _ }>> TreeSerialize<4> for Option<T>

source§

fn serialize_by_key<K, S>( &self, keys: K, ser: S ) -> Result<usize, Error<S::Error>>
where K: Keys, S: Serializer,

source§

impl<T: TreeSerialize<{ _ }>> TreeSerialize<5> for Option<T>

source§

fn serialize_by_key<K, S>( &self, keys: K, ser: S ) -> Result<usize, Error<S::Error>>
where K: Keys, S: Serializer,

source§

impl<T: TreeSerialize<{ _ }>> TreeSerialize<6> for Option<T>

source§

fn serialize_by_key<K, S>( &self, keys: K, ser: S ) -> Result<usize, Error<S::Error>>
where K: Keys, S: Serializer,

source§

impl<T: TreeSerialize<{ _ }>> TreeSerialize<7> for Option<T>

source§

fn serialize_by_key<K, S>( &self, keys: K, ser: S ) -> Result<usize, Error<S::Error>>
where K: Keys, S: Serializer,

source§

impl<T: TreeSerialize<{ _ }>> TreeSerialize<8> for Option<T>

source§

fn serialize_by_key<K, S>( &self, keys: K, ser: S ) -> Result<usize, Error<S::Error>>
where K: Keys, S: Serializer,

source§

impl<T: TreeSerialize<{ _ }>> TreeSerialize<9> for Option<T>

source§

fn serialize_by_key<K, S>( &self, keys: K, ser: S ) -> Result<usize, Error<S::Error>>
where K: Keys, S: Serializer,

source§

impl<T: TreeSerialize<{ _ }>> TreeSerialize<10> for Option<T>

source§

fn serialize_by_key<K, S>( &self, keys: K, ser: S ) -> Result<usize, Error<S::Error>>
where K: Keys, S: Serializer,

source§

impl<T: TreeSerialize<{ _ }>> TreeSerialize<11> for Option<T>

source§

fn serialize_by_key<K, S>( &self, keys: K, ser: S ) -> Result<usize, Error<S::Error>>
where K: Keys, S: Serializer,

source§

impl<T: TreeSerialize<{ _ }>> TreeSerialize<12> for Option<T>

source§

fn serialize_by_key<K, S>( &self, keys: K, ser: S ) -> Result<usize, Error<S::Error>>
where K: Keys, S: Serializer,

source§

impl<T: TreeSerialize<{ _ }>> TreeSerialize<13> for Option<T>

source§

fn serialize_by_key<K, S>( &self, keys: K, ser: S ) -> Result<usize, Error<S::Error>>
where K: Keys, S: Serializer,

source§

impl<T: TreeSerialize<{ _ }>> TreeSerialize<14> for Option<T>

source§

fn serialize_by_key<K, S>( &self, keys: K, ser: S ) -> Result<usize, Error<S::Error>>
where K: Keys, S: Serializer,

source§

impl<T: TreeSerialize<{ _ }>> TreeSerialize<15> for Option<T>

source§

fn serialize_by_key<K, S>( &self, keys: K, ser: S ) -> Result<usize, Error<S::Error>>
where K: Keys, S: Serializer,

source§

impl<T: TreeSerialize<{ _ }>> TreeSerialize<16> for Option<T>

source§

fn serialize_by_key<K, S>( &self, keys: K, ser: S ) -> Result<usize, Error<S::Error>>
where K: Keys, S: Serializer,

source§

impl<T: TreeSerialize<{ _ }>, const N: usize> TreeSerialize<2> for [T; N]

source§

fn serialize_by_key<K, S>( &self, keys: K, ser: S ) -> Result<usize, Error<S::Error>>
where K: Keys, S: Serializer,

source§

impl<T: TreeSerialize<{ _ }>, const N: usize> TreeSerialize<3> for [T; N]

source§

fn serialize_by_key<K, S>( &self, keys: K, ser: S ) -> Result<usize, Error<S::Error>>
where K: Keys, S: Serializer,

source§

impl<T: TreeSerialize<{ _ }>, const N: usize> TreeSerialize<4> for [T; N]

source§

fn serialize_by_key<K, S>( &self, keys: K, ser: S ) -> Result<usize, Error<S::Error>>
where K: Keys, S: Serializer,

source§

impl<T: TreeSerialize<{ _ }>, const N: usize> TreeSerialize<5> for [T; N]

source§

fn serialize_by_key<K, S>( &self, keys: K, ser: S ) -> Result<usize, Error<S::Error>>
where K: Keys, S: Serializer,

source§

impl<T: TreeSerialize<{ _ }>, const N: usize> TreeSerialize<6> for [T; N]

source§

fn serialize_by_key<K, S>( &self, keys: K, ser: S ) -> Result<usize, Error<S::Error>>
where K: Keys, S: Serializer,

source§

impl<T: TreeSerialize<{ _ }>, const N: usize> TreeSerialize<7> for [T; N]

source§

fn serialize_by_key<K, S>( &self, keys: K, ser: S ) -> Result<usize, Error<S::Error>>
where K: Keys, S: Serializer,

source§

impl<T: TreeSerialize<{ _ }>, const N: usize> TreeSerialize<8> for [T; N]

source§

fn serialize_by_key<K, S>( &self, keys: K, ser: S ) -> Result<usize, Error<S::Error>>
where K: Keys, S: Serializer,

source§

impl<T: TreeSerialize<{ _ }>, const N: usize> TreeSerialize<9> for [T; N]

source§

fn serialize_by_key<K, S>( &self, keys: K, ser: S ) -> Result<usize, Error<S::Error>>
where K: Keys, S: Serializer,

source§

impl<T: TreeSerialize<{ _ }>, const N: usize> TreeSerialize<10> for [T; N]

source§

fn serialize_by_key<K, S>( &self, keys: K, ser: S ) -> Result<usize, Error<S::Error>>
where K: Keys, S: Serializer,

source§

impl<T: TreeSerialize<{ _ }>, const N: usize> TreeSerialize<11> for [T; N]

source§

fn serialize_by_key<K, S>( &self, keys: K, ser: S ) -> Result<usize, Error<S::Error>>
where K: Keys, S: Serializer,

source§

impl<T: TreeSerialize<{ _ }>, const N: usize> TreeSerialize<12> for [T; N]

source§

fn serialize_by_key<K, S>( &self, keys: K, ser: S ) -> Result<usize, Error<S::Error>>
where K: Keys, S: Serializer,

source§

impl<T: TreeSerialize<{ _ }>, const N: usize> TreeSerialize<13> for [T; N]

source§

fn serialize_by_key<K, S>( &self, keys: K, ser: S ) -> Result<usize, Error<S::Error>>
where K: Keys, S: Serializer,

source§

impl<T: TreeSerialize<{ _ }>, const N: usize> TreeSerialize<14> for [T; N]

source§

fn serialize_by_key<K, S>( &self, keys: K, ser: S ) -> Result<usize, Error<S::Error>>
where K: Keys, S: Serializer,

source§

impl<T: TreeSerialize<{ _ }>, const N: usize> TreeSerialize<15> for [T; N]

source§

fn serialize_by_key<K, S>( &self, keys: K, ser: S ) -> Result<usize, Error<S::Error>>
where K: Keys, S: Serializer,

source§

impl<T: TreeSerialize<{ _ }>, const N: usize> TreeSerialize<16> for [T; N]

source§

fn serialize_by_key<K, S>( &self, keys: K, ser: S ) -> Result<usize, Error<S::Error>>
where K: Keys, S: Serializer,

Implementors§