Не удается правильно определить время жизни при реализации serde-сериализатора последовательности для MessagePack

ProgramBox

Не удается правильно определить время жизни при реализации serde-сериализатора последовательности для MessagePack

Post author:admin
Запись опубликована:2 апреля, 2023
Post category:Вопросы по программированию

#rust #lifetime #serde

#Ржавчина #время жизни #serde

Вопрос:

Я хочу написать сериализатор / десериализатор, не совместимый с std, MessagePack в Rust. У меня работает большая часть сериализации, но я испытываю трудности с сериализацией структур, последовательностей и карт с использованием serde. Я многое скопировал из serde_json_core, но я не могу правильно определить время жизни для сериализатора последовательности.

игровая площадка

 extern crate generic_array_0_13_2; // 0.13.2
extern crate serde; 

use serde::ser;

pub struct Serializer<'a> {
    buf: amp;'a mut [u8],
    pos: usize,
}
pub struct SerializeSeq<'a> {
    ser: amp;'a mut Serializer<'a>,
}

impl<'a> ser::SerializeSeq for SerializeSeq<'a> {
    type Ok = ();
    type Error = Error;

    fn serialize_element<T: ?Sized>(amp;mut self, value: amp;T) -> Result<Self::Ok, Self::Error>
    where
        T: ser::Serialize,
    {
        // -------- This does not compile
        value.serialize(amp;mut *self.ser)?;
        Ok(())
    }
    fn end(self) -> Result<Self::Ok, Self::Error> {
        Ok(())
    }
}

impl<'a> ser::Serializer for amp;'a mut Serializer<'a> {
    type Ok = ();
    type Error = Error;
    type SerializeSeq = SerializeSeq<'a>;
    type SerializeTuple = SerializeSeq<'a>;
    type SerializeTupleStruct = Unreachable;
    type SerializeTupleVariant = Unreachable;
    type SerializeMap = SerializeMap<'a>;
    type SerializeStruct = SerializeStruct<'a>;
    type SerializeStructVariant = Unreachable;
    // ...

    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
        Ok(SerializeSeq::new(self))
    }
    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
        self.serialize_seq(Some(len))
    }

    fn serialize_bool(self, _: bool) -> Result<Self::Ok, Self::Error> {
        todo!()
    }
    fn serialize_i8(self, _: i8) -> Result<Self::Ok, Self::Error> {
        todo!()
    }
    fn serialize_i16(self, _: i16) -> Result<Self::Ok, Self::Error> {
        todo!()
    }
    fn serialize_i32(self, _: i32) -> Result<Self::Ok, Self::Error> {
        todo!()
    }
    fn serialize_i64(self, _: i64) -> Result<Self::Ok, Self::Error> {
        todo!()
    }
    fn serialize_u8(self, _: u8) -> Result<Self::Ok, Self::Error> {
        todo!()
    }
    fn serialize_u16(self, _: u16) -> Result<Self::Ok, Self::Error> {
        todo!()
    }
    fn serialize_u32(self, _: u32) -> Result<Self::Ok, Self::Error> {
        todo!()
    }
    fn serialize_u64(self, _: u64) -> Result<Self::Ok, Self::Error> {
        todo!()
    }
    fn serialize_f32(self, _: f32) -> Result<Self::Ok, Self::Error> {
        todo!()
    }
    fn serialize_f64(self, _: f64) -> Result<Self::Ok, Self::Error> {
        todo!()
    }
    fn serialize_char(self, _: char) -> Result<Self::Ok, Self::Error> {
        todo!()
    }
    fn serialize_str(self, _: amp;str) -> Result<Self::Ok, Self::Error> {
        todo!()
    }
    fn serialize_bytes(self, _: amp;[u8]) -> Result<Self::Ok, Self::Error> {
        todo!()
    }
    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
        todo!()
    }
    fn serialize_some<T: ?Sized>(self, _: amp;T) -> Result<Self::Ok, Self::Error>
    where
        T: ser::Serialize,
    {
        todo!()
    }
    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
        todo!()
    }
    fn serialize_unit_struct(self, _: amp;'static str) -> Result<Self::Ok, Self::Error> {
        todo!()
    }
    fn serialize_unit_variant(
        self,
        _: amp;'static str,
        _: u32,
        _: amp;'static str,
    ) -> Result<Self::Ok, Self::Error> {
        todo!()
    }
    fn serialize_newtype_struct<T: ?Sized>(
        self,
        _: amp;'static str,
        _: amp;T,
    ) -> Result<Self::Ok, Self::Error>
    where
        T: serde::Serialize,
    {
        todo!()
    }
    fn serialize_newtype_variant<T: ?Sized>(
        self,
        _: amp;'static str,
        _: u32,
        _: amp;'static str,
        _: amp;T,
    ) -> Result<Self::Ok, Self::Error>
    where
        T: serde::Serialize,
    {
        todo!()
    }
    fn serialize_tuple_struct(
        self,
        _: amp;'static str,
        _: usize,
    ) -> std::result::Result<
        <Self as serde::Serializer>::SerializeTupleStruct,
        <Self as serde::Serializer>::Error,
    > {
        todo!()
    }
    fn serialize_tuple_variant(
        self,
        _: amp;'static str,
        _: u32,
        _: amp;'static str,
        _: usize,
    ) -> std::result::Result<
        <Self as serde::Serializer>::SerializeTupleVariant,
        <Self as serde::Serializer>::Error,
    > {
        todo!()
    }
    fn serialize_map(
        self,
        _: std::option::Option<usize>,
    ) -> std::result::Result<
        <Self as serde::Serializer>::SerializeMap,
        <Self as serde::Serializer>::Error,
    > {
        todo!()
    }
    fn serialize_struct(
        self,
        _: amp;'static str,
        _: usize,
    ) -> std::result::Result<
        <Self as serde::Serializer>::SerializeStruct,
        <Self as serde::Serializer>::Error,
    > {
        todo!()
    }
    fn serialize_struct_variant(
        self,
        _: amp;'static str,
        _: u32,
        _: amp;'static str,
        _: usize,
    ) -> std::result::Result<
        <Self as serde::Serializer>::SerializeStructVariant,
        <Self as serde::Serializer>::Error,
    > {
        todo!()
    }
}

// ---- The remaining part is just to make the compiler stop complaining about missing implementations

impl<'a> SerializeSeq<'a> {
    pub fn new(ser: amp;'a mut Serializer<'a>) -> Self {
        SerializeSeq { ser }
    }
}

pub struct SerializeMap<'a> {
    ser: amp;'a mut Serializer<'a>,
}
pub struct SerializeStruct<'a> {
    ser: amp;'a mut Serializer<'a>,
}

impl<'a> ser::SerializeTuple for SerializeSeq<'a> {
    type Ok = ();
    type Error = Error;

    fn serialize_element<T: ?Sized>(amp;mut self, value: amp;T) -> Result<Self::Ok, Self::Error>
    where
        T: ser::Serialize,
    {
        ser::SerializeSeq::serialize_element(self, value)
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        ser::SerializeSeq::end(self)
    }
}

impl<'a> ser::SerializeStruct for SerializeStruct<'a> {
    type Ok = ();
    type Error = Error;

    fn serialize_field<T: ?Sized>(
        amp;mut self,
        key: amp;'static str,
        value: amp;T,
    ) -> Result<Self::Ok, Self::Error>
    where
        T: ser::Serialize,
    {
        //value.serialize(amp;mut *self.ser)?;
        Ok(())
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        Ok(())
    }
}

impl<'a> ser::SerializeMap for SerializeMap<'a> {
    type Ok = ();
    type Error = Error;

    fn end(self) -> Result<Self::Ok, Self::Error> {
        Ok(())
    }

    fn serialize_key<T: ?Sized>(amp;mut self, key: amp;T) -> Result<Self::Ok, Self::Error>
    where
        T: ser::Serialize,
    {
        //key.serialize(amp;mut *self.ser)?;
        Ok(())
    }

    fn serialize_value<T: ?Sized>(amp;mut self, value: amp;T) -> Result<Self::Ok, Self::Error>
    where
        T: ser::Serialize,
    {
        //value.serialize(amp;mut *self.ser)?;
        Ok(())
    }
}

#[derive(Debug)]
enum Error {}
impl std::fmt::Display for Error {
    fn fmt(amp;self, f: amp;mut std::fmt::Formatter) -> std::fmt::Result {
        todo!()
    }
}
impl std::error::Error for Error {}
impl serde::ser::Error for Error {
    fn custom<T>(_: T) -> Self
    where
        T: std::fmt::Display,
    {
        todo!()
    }
}
pub enum Unreachable {}

impl ser::SerializeTupleStruct for Unreachable {
    type Ok = ();
    type Error = Error;

    fn serialize_field<T: ?Sized>(amp;mut self, _value: amp;T) -> Result<Self::Ok, Self::Error> {
        unreachable!()
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        unreachable!()
    }
}

impl ser::SerializeTupleVariant for Unreachable {
    type Ok = ();
    type Error = Error;

    fn serialize_field<T: ?Sized>(amp;mut self, _value: amp;T) -> Result<Self::Ok, Self::Error> {
        unreachable!()
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        unreachable!()
    }
}

impl ser::SerializeMap for Unreachable {
    type Ok = ();
    type Error = Error;

    fn serialize_key<T: ?Sized>(amp;mut self, _key: amp;T) -> Result<Self::Ok, Self::Error>
    where
        T: ser::Serialize,
    {
        unreachable!()
    }

    fn serialize_value<T: ?Sized>(amp;mut self, _value: amp;T) -> Result<Self::Ok, Self::Error>
    where
        T: ser::Serialize,
    {
        unreachable!()
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        unreachable!()
    }
}

impl ser::SerializeStructVariant for Unreachable {
    type Ok = ();
    type Error = Error;

    fn serialize_field<T: ?Sized>(
        amp;mut self,
        _key: amp;'static str,
        _value: amp;T,
    ) -> Result<Self::Ok, Self::Error>
    where
        T: ser::Serialize,
    {
        unreachable!()
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        unreachable!()
    }
}

Это ошибка, которую я получаю:

 error[E0495]: cannot infer an appropriate lifetime for borrow expression due to conflicting requirements
  --> src/lib.rs:23:25
   |
23 |         value.serialize(amp;mut *self.ser)?;
   |                         ^^^^^^^^^^^^^^
   |
note: first, the lifetime cannot outlive the anonymous lifetime #1 defined on the method body at 18:5...
  --> src/lib.rs:18:5
   |
18 | /     fn serialize_element<T: ?Sized>(amp;mut self, value: amp;T) -> Result<Self::Ok, Self::Error>
19 | |     where
20 | |         T: ser::Serialize,
21 | |     {
...  |
24 | |         Ok(())
25 | |     }
   | |_____^
note: ...so that reference does not outlive borrowed content
  --> src/lib.rs:23:25
   |
23 |         value.serialize(amp;mut *self.ser)?;
   |                         ^^^^^^^^^^^^^^
note: but, the lifetime must be valid for the lifetime `'a` as defined on the impl at 14:6...
  --> src/lib.rs:14:6
   |
14 | impl<'a> ser::SerializeSeq for SerializeSeq<'a> {
   |      ^^
note: ...so that the types are compatible
  --> src/lib.rs:23:15
   |
23 |         value.serialize(amp;mut *self.ser)?;
   |               ^^^^^^^^^
   = note: expected `serde::Serializer`
              found `serde::Serializer`

Это как-то связано с временем жизни фрагмента байта в Serializer и временем жизни amp;mut Serializer столкновения, но я ни за что на свете не могу понять, как это решить. Я попытался добавить больше аннотаций срока службы и ввел привязку к черте, чтобы избавиться от второго срока службы, но ничего не сработало…

1. play.rust-lang.org/…

2. пожалуйста, отформатируйте с помощью rustformat, и ваш MCVE может быть намного короче.

3. @Stargateur Большое вам спасибо! Я почти уверен, что в какой-то момент я пробовал что-то подобное… Должно быть, немного отличалось. Если вы опубликуете это в качестве ответа, я приму его.

Вопрос:

Комментарии:

Вам также может понравиться

Убедитесь, что весь код на всех машинах одинаков — python mpi

Сетевая сетка MATLAB в C

От UTF-8 до UTF-16LE Javascript