问题描述
我想在Rust中编写一个无标准兼容的MessagePack序列化器/反序列化器。我有大部分的序列化工作，但是我在努力使用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: &'a mut [u8],pos: usize,}
pub struct SerializeSeq<'a> {
ser: &'a mut Serializer<'a>,}
impl<'a> ser::SerializeSeq for SerializeSeq<'a> {
type Ok = ();
type Error = Error;
fn serialize_element<T: ?Sized>(&mut self,value: &T) -> Result<Self::Ok,Self::Error>
where
T: ser::Serialize,{
// -------- This does not compile
value.serialize(&mut *self.ser)?;
Ok(())
}
fn end(self) -> Result<Self::Ok,Self::Error> {
Ok(())
}
}
impl<'a> ser::Serializer for &'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,_: &str) -> Result<Self::Ok,Self::Error> {
todo!()
}
fn serialize_bytes(self,_: &[u8]) -> Result<Self::Ok,Self::Error> {
todo!()
}
fn serialize_none(self) -> Result<Self::Ok,Self::Error> {
todo!()
}
fn serialize_some<T: ?Sized>(self,_: &T) -> Result<Self::Ok,{
todo!()
}
fn serialize_unit(self) -> Result<Self::Ok,Self::Error> {
todo!()
}
fn serialize_unit_struct(self,_: &'static str) -> Result<Self::Ok,Self::Error> {
todo!()
}
fn serialize_unit_variant(
self,_: &'static str,_: u32,) -> Result<Self::Ok,Self::Error> {
todo!()
}
fn serialize_newtype_struct<T: ?Sized>(
self,_: &T,Self::Error>
where
T: serde::Serialize,{
todo!()
}
fn serialize_newtype_variant<T: ?Sized>(
self,{
todo!()
}
fn serialize_tuple_struct(
self,_: usize,) -> std::result::Result<
<Self as serde::Serializer>::SerializeTupleStruct,<Self as serde::Serializer>::Error,> {
todo!()
}
fn serialize_tuple_variant(
self,) -> std::result::Result<
<Self as serde::Serializer>::SerializeTupleVariant,> {
todo!()
}
fn serialize_map(
self,_: std::option::Option<usize>,) -> std::result::Result<
<Self as serde::Serializer>::SerializeMap,> {
todo!()
}
fn serialize_struct(
self,) -> std::result::Result<
<Self as serde::Serializer>::SerializeStruct,> {
todo!()
}
fn serialize_struct_variant(
self,) -> std::result::Result<
<Self as serde::Serializer>::SerializeStructvariant,> {
todo!()
}
}
// ---- The remaining part is just to make the compiler stop complaining about missing implementations
impl<'a> SerializeSeq<'a> {
pub fn new(ser: &'a mut Serializer<'a>) -> Self {
SerializeSeq { ser }
}
}
pub struct SerializeMap<'a> {
ser: &'a mut Serializer<'a>,}
pub struct SerializeStruct<'a> {
ser: &'a mut Serializer<'a>,}
impl<'a> ser::SerializeTuple for SerializeSeq<'a> {
type Ok = ();
type Error = Error;
fn serialize_element<T: ?Sized>(&mut self,{
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>(
&mut self,key: &'static str,value: &T,{
//value.serialize(&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>(&mut self,key: &T) -> Result<Self::Ok,{
//key.serialize(&mut *self.ser)?;
Ok(())
}
fn serialize_value<T: ?Sized>(&mut self,{
//value.serialize(&mut *self.ser)?;
Ok(())
}
}
#[derive(Debug)]
enum Error {}
impl std::fmt::display for Error {
fn fmt(&self,f: &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>(&mut self,_value: &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>(&mut self,Self::Error> {
unreachable!()
}
}
impl ser::SerializeMap for Unreachable {
type Ok = ();
type Error = Error;
fn serialize_key<T: ?Sized>(&mut self,_key: &T) -> Result<Self::Ok,{
unreachable!()
}
fn serialize_value<T: ?Sized>(&mut self,{
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>(
&mut self,_key: &'static str,_value: &T,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(&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>(&mut self,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(&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(&mut *self.ser)?;
| ^^^^^^^^^
= note: expected `serde::Serializer`
found `serde::Serializer`
这与Serializer中字节片的生存期和&mut Serializer冲突的生存期有关，但是我一生都无法解决。我尝试添加更多的生命周期注释，并引入了特征绑定以摆脱第二生命周期，但没有任何效果...
解决方法
暂无找到可以解决该程序问题的有效方法，小编努力寻找整理中！
如果你已经找到好的解决方法，欢迎将解决方案带上本链接一起发送给小编。
小编邮箱:dio#foxmail.com (将#修改为@）