1 //! Support code for encoding and decoding types.
4 Core encoding and decoding interfaces.
8 use std
::cell
::{Cell, RefCell}
;
9 use std
::marker
::PhantomData
;
18 fn emit_unit(&mut self) -> Result
<(), Self::Error
>;
19 fn emit_usize(&mut self, v
: usize) -> Result
<(), Self::Error
>;
20 fn emit_u128(&mut self, v
: u128
) -> Result
<(), Self::Error
>;
21 fn emit_u64(&mut self, v
: u64) -> Result
<(), Self::Error
>;
22 fn emit_u32(&mut self, v
: u32) -> Result
<(), Self::Error
>;
23 fn emit_u16(&mut self, v
: u16) -> Result
<(), Self::Error
>;
24 fn emit_u8(&mut self, v
: u8) -> Result
<(), Self::Error
>;
25 fn emit_isize(&mut self, v
: isize) -> Result
<(), Self::Error
>;
26 fn emit_i128(&mut self, v
: i128
) -> Result
<(), Self::Error
>;
27 fn emit_i64(&mut self, v
: i64) -> Result
<(), Self::Error
>;
28 fn emit_i32(&mut self, v
: i32) -> Result
<(), Self::Error
>;
29 fn emit_i16(&mut self, v
: i16) -> Result
<(), Self::Error
>;
30 fn emit_i8(&mut self, v
: i8) -> Result
<(), Self::Error
>;
31 fn emit_bool(&mut self, v
: bool
) -> Result
<(), Self::Error
>;
32 fn emit_f64(&mut self, v
: f64) -> Result
<(), Self::Error
>;
33 fn emit_f32(&mut self, v
: f32) -> Result
<(), Self::Error
>;
34 fn emit_char(&mut self, v
: char) -> Result
<(), Self::Error
>;
35 fn emit_str(&mut self, v
: &str) -> Result
<(), Self::Error
>;
39 fn emit_enum
<F
>(&mut self, _name
: &str, f
: F
) -> Result
<(), Self::Error
>
41 F
: FnOnce(&mut Self) -> Result
<(), Self::Error
>,
46 fn emit_enum_variant
<F
>(
52 ) -> Result
<(), Self::Error
>
54 F
: FnOnce(&mut Self) -> Result
<(), Self::Error
>,
56 self.emit_usize(v_id
)?
;
61 fn emit_enum_variant_arg
<F
>(&mut self, _a_idx
: usize, f
: F
) -> Result
<(), Self::Error
>
63 F
: FnOnce(&mut Self) -> Result
<(), Self::Error
>,
68 fn emit_enum_struct_variant
<F
>(
74 ) -> Result
<(), Self::Error
>
76 F
: FnOnce(&mut Self) -> Result
<(), Self::Error
>,
78 self.emit_enum_variant(v_name
, v_id
, len
, f
)
81 fn emit_enum_struct_variant_field
<F
>(
86 ) -> Result
<(), Self::Error
>
88 F
: FnOnce(&mut Self) -> Result
<(), Self::Error
>,
90 self.emit_enum_variant_arg(f_idx
, f
)
94 fn emit_struct
<F
>(&mut self, _name
: &str, _len
: usize, f
: F
) -> Result
<(), Self::Error
>
96 F
: FnOnce(&mut Self) -> Result
<(), Self::Error
>,
102 fn emit_struct_field
<F
>(
107 ) -> Result
<(), Self::Error
>
109 F
: FnOnce(&mut Self) -> Result
<(), Self::Error
>,
115 fn emit_tuple
<F
>(&mut self, _len
: usize, f
: F
) -> Result
<(), Self::Error
>
117 F
: FnOnce(&mut Self) -> Result
<(), Self::Error
>,
123 fn emit_tuple_arg
<F
>(&mut self, _idx
: usize, f
: F
) -> Result
<(), Self::Error
>
125 F
: FnOnce(&mut Self) -> Result
<(), Self::Error
>,
130 fn emit_tuple_struct
<F
>(&mut self, _name
: &str, len
: usize, f
: F
) -> Result
<(), Self::Error
>
132 F
: FnOnce(&mut Self) -> Result
<(), Self::Error
>,
134 self.emit_tuple(len
, f
)
137 fn emit_tuple_struct_arg
<F
>(&mut self, f_idx
: usize, f
: F
) -> Result
<(), Self::Error
>
139 F
: FnOnce(&mut Self) -> Result
<(), Self::Error
>,
141 self.emit_tuple_arg(f_idx
, f
)
144 // Specialized types:
145 fn emit_option
<F
>(&mut self, f
: F
) -> Result
<(), Self::Error
>
147 F
: FnOnce(&mut Self) -> Result
<(), Self::Error
>,
149 self.emit_enum("Option", f
)
153 fn emit_option_none(&mut self) -> Result
<(), Self::Error
> {
154 self.emit_enum_variant("None", 0, 0, |_
| Ok(()))
157 fn emit_option_some
<F
>(&mut self, f
: F
) -> Result
<(), Self::Error
>
159 F
: FnOnce(&mut Self) -> Result
<(), Self::Error
>,
161 self.emit_enum_variant("Some", 1, 1, f
)
164 fn emit_seq
<F
>(&mut self, len
: usize, f
: F
) -> Result
<(), Self::Error
>
166 F
: FnOnce(&mut Self) -> Result
<(), Self::Error
>,
168 self.emit_usize(len
)?
;
173 fn emit_seq_elt
<F
>(&mut self, _idx
: usize, f
: F
) -> Result
<(), Self::Error
>
175 F
: FnOnce(&mut Self) -> Result
<(), Self::Error
>,
180 fn emit_map
<F
>(&mut self, len
: usize, f
: F
) -> Result
<(), Self::Error
>
182 F
: FnOnce(&mut Self) -> Result
<(), Self::Error
>,
184 self.emit_usize(len
)?
;
189 fn emit_map_elt_key
<F
>(&mut self, _idx
: usize, f
: F
) -> Result
<(), Self::Error
>
191 F
: FnOnce(&mut Self) -> Result
<(), Self::Error
>,
197 fn emit_map_elt_val
<F
>(&mut self, _idx
: usize, f
: F
) -> Result
<(), Self::Error
>
199 F
: FnOnce(&mut Self) -> Result
<(), Self::Error
>,
209 fn read_nil(&mut self) -> Result
<(), Self::Error
>;
210 fn read_usize(&mut self) -> Result
<usize, Self::Error
>;
211 fn read_u128(&mut self) -> Result
<u128
, Self::Error
>;
212 fn read_u64(&mut self) -> Result
<u64, Self::Error
>;
213 fn read_u32(&mut self) -> Result
<u32, Self::Error
>;
214 fn read_u16(&mut self) -> Result
<u16, Self::Error
>;
215 fn read_u8(&mut self) -> Result
<u8, Self::Error
>;
216 fn read_isize(&mut self) -> Result
<isize, Self::Error
>;
217 fn read_i128(&mut self) -> Result
<i128
, Self::Error
>;
218 fn read_i64(&mut self) -> Result
<i64, Self::Error
>;
219 fn read_i32(&mut self) -> Result
<i32, Self::Error
>;
220 fn read_i16(&mut self) -> Result
<i16, Self::Error
>;
221 fn read_i8(&mut self) -> Result
<i8, Self::Error
>;
222 fn read_bool(&mut self) -> Result
<bool
, Self::Error
>;
223 fn read_f64(&mut self) -> Result
<f64, Self::Error
>;
224 fn read_f32(&mut self) -> Result
<f32, Self::Error
>;
225 fn read_char(&mut self) -> Result
<char, Self::Error
>;
226 fn read_str(&mut self) -> Result
<Cow
<'_
, str>, Self::Error
>;
230 fn read_enum
<T
, F
>(&mut self, _name
: &str, f
: F
) -> Result
<T
, Self::Error
>
232 F
: FnOnce(&mut Self) -> Result
<T
, Self::Error
>,
238 fn read_enum_variant
<T
, F
>(&mut self, _names
: &[&str], mut f
: F
) -> Result
<T
, Self::Error
>
240 F
: FnMut(&mut Self, usize) -> Result
<T
, Self::Error
>,
242 let disr
= self.read_usize()?
;
247 fn read_enum_variant_arg
<T
, F
>(&mut self, _a_idx
: usize, f
: F
) -> Result
<T
, Self::Error
>
249 F
: FnOnce(&mut Self) -> Result
<T
, Self::Error
>,
254 fn read_enum_struct_variant
<T
, F
>(&mut self, names
: &[&str], f
: F
) -> Result
<T
, Self::Error
>
256 F
: FnMut(&mut Self, usize) -> Result
<T
, Self::Error
>,
258 self.read_enum_variant(names
, f
)
261 fn read_enum_struct_variant_field
<T
, F
>(
266 ) -> Result
<T
, Self::Error
>
268 F
: FnOnce(&mut Self) -> Result
<T
, Self::Error
>,
270 self.read_enum_variant_arg(f_idx
, f
)
274 fn read_struct
<T
, F
>(&mut self, _s_name
: &str, _len
: usize, f
: F
) -> Result
<T
, Self::Error
>
276 F
: FnOnce(&mut Self) -> Result
<T
, Self::Error
>,
282 fn read_struct_field
<T
, F
>(
287 ) -> Result
<T
, Self::Error
>
289 F
: FnOnce(&mut Self) -> Result
<T
, Self::Error
>,
295 fn read_tuple
<T
, F
>(&mut self, _len
: usize, f
: F
) -> Result
<T
, Self::Error
>
297 F
: FnOnce(&mut Self) -> Result
<T
, Self::Error
>,
303 fn read_tuple_arg
<T
, F
>(&mut self, _a_idx
: usize, f
: F
) -> Result
<T
, Self::Error
>
305 F
: FnOnce(&mut Self) -> Result
<T
, Self::Error
>,
310 fn read_tuple_struct
<T
, F
>(&mut self, _s_name
: &str, len
: usize, f
: F
) -> Result
<T
, Self::Error
>
312 F
: FnOnce(&mut Self) -> Result
<T
, Self::Error
>,
314 self.read_tuple(len
, f
)
317 fn read_tuple_struct_arg
<T
, F
>(&mut self, a_idx
: usize, f
: F
) -> Result
<T
, Self::Error
>
319 F
: FnOnce(&mut Self) -> Result
<T
, Self::Error
>,
321 self.read_tuple_arg(a_idx
, f
)
324 // Specialized types:
325 fn read_option
<T
, F
>(&mut self, mut f
: F
) -> Result
<T
, Self::Error
>
327 F
: FnMut(&mut Self, bool
) -> Result
<T
, Self::Error
>,
329 self.read_enum("Option", move |this
| {
330 this
.read_enum_variant(&["None", "Some"], move |this
, idx
| match idx
{
333 _
=> Err(this
.error("read_option: expected 0 for None or 1 for Some")),
338 fn read_seq
<T
, F
>(&mut self, f
: F
) -> Result
<T
, Self::Error
>
340 F
: FnOnce(&mut Self, usize) -> Result
<T
, Self::Error
>,
342 let len
= self.read_usize()?
;
347 fn read_seq_elt
<T
, F
>(&mut self, _idx
: usize, f
: F
) -> Result
<T
, Self::Error
>
349 F
: FnOnce(&mut Self) -> Result
<T
, Self::Error
>,
354 fn read_map
<T
, F
>(&mut self, f
: F
) -> Result
<T
, Self::Error
>
356 F
: FnOnce(&mut Self, usize) -> Result
<T
, Self::Error
>,
358 let len
= self.read_usize()?
;
363 fn read_map_elt_key
<T
, F
>(&mut self, _idx
: usize, f
: F
) -> Result
<T
, Self::Error
>
365 F
: FnOnce(&mut Self) -> Result
<T
, Self::Error
>,
371 fn read_map_elt_val
<T
, F
>(&mut self, _idx
: usize, f
: F
) -> Result
<T
, Self::Error
>
373 F
: FnOnce(&mut Self) -> Result
<T
, Self::Error
>,
379 fn error(&mut self, err
: &str) -> Self::Error
;
382 /// Trait for types that can be serialized
384 /// This can be implemented using the `Encodable`, `TyEncodable` and
385 /// `MetadataEncodable` macros.
387 /// * `Encodable` should be used in crates that don't depend on
389 /// * `MetadataEncodable` is used in `rustc_metadata` for types that contain
390 /// `rustc_metadata::rmeta::Lazy`.
391 /// * `TyEncodable` should be used for types that are only serialized in crate
392 /// metadata or the incremental cache. This is most types in `rustc_middle`.
393 pub trait Encodable
<S
: Encoder
> {
394 fn encode(&self, s
: &mut S
) -> Result
<(), S
::Error
>;
397 /// Trait for types that can be deserialized
399 /// This can be implemented using the `Decodable`, `TyDecodable` and
400 /// `MetadataDecodable` macros.
402 /// * `Decodable` should be used in crates that don't depend on
404 /// * `MetadataDecodable` is used in `rustc_metadata` for types that contain
405 /// `rustc_metadata::rmeta::Lazy`.
406 /// * `TyDecodable` should be used for types that are only serialized in crate
407 /// metadata or the incremental cache. This is most types in `rustc_middle`.
408 pub trait Decodable
<D
: Decoder
>: Sized
{
409 fn decode(d
: &mut D
) -> Result
<Self, D
::Error
>;
412 macro_rules
! direct_serialize_impls
{
413 ($
($ty
:ident $emit_method
:ident $read_method
:ident
),*) => {
415 impl<S
: Encoder
> Encodable
<S
> for $ty
{
416 fn encode(&self, s
: &mut S
) -> Result
<(), S
::Error
> {
417 s
.$
emit_method(*self)
421 impl<D
: Decoder
> Decodable
<D
> for $ty
{
422 fn decode(d
: &mut D
) -> Result
<$ty
, D
::Error
> {
430 direct_serialize_impls
! {
431 usize emit_usize read_usize
,
433 u16 emit_u16 read_u16
,
434 u32 emit_u32 read_u32
,
435 u64 emit_u64 read_u64
,
436 u128 emit_u128 read_u128
,
437 isize emit_isize read_isize
,
439 i16 emit_i16 read_i16
,
440 i32 emit_i32 read_i32
,
441 i64 emit_i64 read_i64
,
442 i128 emit_i128 read_i128
,
443 f32 emit_f32 read_f32
,
444 f64 emit_f64 read_f64
,
445 bool emit_bool read_bool
,
446 char emit_char read_char
449 impl<S
: Encoder
> Encodable
<S
> for ::std
::num
::NonZeroU32
{
450 fn encode(&self, s
: &mut S
) -> Result
<(), S
::Error
> {
451 s
.emit_u32(self.get())
455 impl<D
: Decoder
> Decodable
<D
> for ::std
::num
::NonZeroU32
{
456 fn decode(d
: &mut D
) -> Result
<Self, D
::Error
> {
457 d
.read_u32().map(|d
| ::std
::num
::NonZeroU32
::new(d
).unwrap())
461 impl<S
: Encoder
> Encodable
<S
> for str {
462 fn encode(&self, s
: &mut S
) -> Result
<(), S
::Error
> {
467 impl<S
: Encoder
> Encodable
<S
> for &str {
468 fn encode(&self, s
: &mut S
) -> Result
<(), S
::Error
> {
473 impl<S
: Encoder
> Encodable
<S
> for String
{
474 fn encode(&self, s
: &mut S
) -> Result
<(), S
::Error
> {
475 s
.emit_str(&self[..])
479 impl<D
: Decoder
> Decodable
<D
> for String
{
480 fn decode(d
: &mut D
) -> Result
<String
, D
::Error
> {
481 Ok(d
.read_str()?
.into_owned())
485 impl<S
: Encoder
> Encodable
<S
> for () {
486 fn encode(&self, s
: &mut S
) -> Result
<(), S
::Error
> {
491 impl<D
: Decoder
> Decodable
<D
> for () {
492 fn decode(d
: &mut D
) -> Result
<(), D
::Error
> {
497 impl<S
: Encoder
, T
> Encodable
<S
> for PhantomData
<T
> {
498 fn encode(&self, s
: &mut S
) -> Result
<(), S
::Error
> {
503 impl<D
: Decoder
, T
> Decodable
<D
> for PhantomData
<T
> {
504 fn decode(d
: &mut D
) -> Result
<PhantomData
<T
>, D
::Error
> {
510 impl<D
: Decoder
, T
: Decodable
<D
>> Decodable
<D
> for Box
<[T
]> {
511 fn decode(d
: &mut D
) -> Result
<Box
<[T
]>, D
::Error
> {
512 let v
: Vec
<T
> = Decodable
::decode(d
)?
;
513 Ok(v
.into_boxed_slice())
517 impl<S
: Encoder
, T
: Encodable
<S
>> Encodable
<S
> for Rc
<T
> {
518 fn encode(&self, s
: &mut S
) -> Result
<(), S
::Error
> {
523 impl<D
: Decoder
, T
: Decodable
<D
>> Decodable
<D
> for Rc
<T
> {
524 fn decode(d
: &mut D
) -> Result
<Rc
<T
>, D
::Error
> {
525 Ok(Rc
::new(Decodable
::decode(d
)?
))
529 impl<S
: Encoder
, T
: Encodable
<S
>> Encodable
<S
> for [T
] {
530 fn encode(&self, s
: &mut S
) -> Result
<(), S
::Error
> {
531 s
.emit_seq(self.len(), |s
| {
532 for (i
, e
) in self.iter().enumerate() {
533 s
.emit_seq_elt(i
, |s
| e
.encode(s
))?
540 impl<S
: Encoder
, T
: Encodable
<S
>> Encodable
<S
> for Vec
<T
> {
541 fn encode(&self, s
: &mut S
) -> Result
<(), S
::Error
> {
542 s
.emit_seq(self.len(), |s
| {
543 for (i
, e
) in self.iter().enumerate() {
544 s
.emit_seq_elt(i
, |s
| e
.encode(s
))?
551 impl<D
: Decoder
, T
: Decodable
<D
>> Decodable
<D
> for Vec
<T
> {
552 fn decode(d
: &mut D
) -> Result
<Vec
<T
>, D
::Error
> {
553 d
.read_seq(|d
, len
| {
554 let mut v
= Vec
::with_capacity(len
);
556 v
.push(d
.read_seq_elt(i
, |d
| Decodable
::decode(d
))?
);
563 impl<S
: Encoder
> Encodable
<S
> for [u8; 20] {
564 fn encode(&self, s
: &mut S
) -> Result
<(), S
::Error
> {
565 s
.emit_seq(self.len(), |s
| {
566 for (i
, e
) in self.iter().enumerate() {
567 s
.emit_seq_elt(i
, |s
| e
.encode(s
))?
574 impl<D
: Decoder
> Decodable
<D
> for [u8; 20] {
575 fn decode(d
: &mut D
) -> Result
<[u8; 20], D
::Error
> {
576 d
.read_seq(|d
, len
| {
578 let mut v
= [0u8; 20];
580 v
[i
] = d
.read_seq_elt(i
, |d
| Decodable
::decode(d
))?
;
587 impl<'a
, S
: Encoder
, T
: Encodable
<S
>> Encodable
<S
> for Cow
<'a
, [T
]>
589 [T
]: ToOwned
<Owned
= Vec
<T
>>,
591 fn encode(&self, s
: &mut S
) -> Result
<(), S
::Error
> {
592 s
.emit_seq(self.len(), |s
| {
593 for (i
, e
) in self.iter().enumerate() {
594 s
.emit_seq_elt(i
, |s
| e
.encode(s
))?
601 impl<D
: Decoder
, T
: Decodable
<D
> + ToOwned
> Decodable
<D
> for Cow
<'
static, [T
]>
603 [T
]: ToOwned
<Owned
= Vec
<T
>>,
605 fn decode(d
: &mut D
) -> Result
<Cow
<'
static, [T
]>, D
::Error
> {
606 d
.read_seq(|d
, len
| {
607 let mut v
= Vec
::with_capacity(len
);
609 v
.push(d
.read_seq_elt(i
, |d
| Decodable
::decode(d
))?
);
616 impl<S
: Encoder
, T
: Encodable
<S
>> Encodable
<S
> for Option
<T
> {
617 fn encode(&self, s
: &mut S
) -> Result
<(), S
::Error
> {
618 s
.emit_option(|s
| match *self {
619 None
=> s
.emit_option_none(),
620 Some(ref v
) => s
.emit_option_some(|s
| v
.encode(s
)),
625 impl<D
: Decoder
, T
: Decodable
<D
>> Decodable
<D
> for Option
<T
> {
626 fn decode(d
: &mut D
) -> Result
<Option
<T
>, D
::Error
> {
627 d
.read_option(|d
, b
| if b { Ok(Some(Decodable::decode(d)?)) }
else { Ok(None) }
)
631 impl<S
: Encoder
, T1
: Encodable
<S
>, T2
: Encodable
<S
>> Encodable
<S
> for Result
<T1
, T2
> {
632 fn encode(&self, s
: &mut S
) -> Result
<(), S
::Error
> {
633 s
.emit_enum("Result", |s
| match *self {
635 s
.emit_enum_variant("Ok", 0, 1, |s
| s
.emit_enum_variant_arg(0, |s
| v
.encode(s
)))
638 s
.emit_enum_variant("Err", 1, 1, |s
| s
.emit_enum_variant_arg(0, |s
| v
.encode(s
)))
644 impl<D
: Decoder
, T1
: Decodable
<D
>, T2
: Decodable
<D
>> Decodable
<D
> for Result
<T1
, T2
> {
645 fn decode(d
: &mut D
) -> Result
<Result
<T1
, T2
>, D
::Error
> {
646 d
.read_enum("Result", |d
| {
647 d
.read_enum_variant(&["Ok", "Err"], |d
, disr
| match disr
{
648 0 => Ok(Ok(d
.read_enum_variant_arg(0, |d
| T1
::decode(d
))?
)),
649 1 => Ok(Err(d
.read_enum_variant_arg(0, |d
| T2
::decode(d
))?
)),
652 "Encountered invalid discriminant while \
662 ($name
:ident
, $
($other
:ident
,)*) => (tuple
! { $($other,)* }
)
665 /// Evaluates to the number of tokens passed to it.
667 /// Logarithmic counting: every one or two recursive expansions, the number of
668 /// tokens to count is divided by two, instead of being reduced by one.
669 /// Therefore, the recursion depth is the binary logarithm of the number of
670 /// tokens to count, and the expanded tree is likewise very small.
673 ($one
:tt
) => (1usize
);
674 ($
($pairs
:tt $_p
:tt
)*) => (count
!($
($pairs
)*) << 1usize
);
675 ($odd
:tt $
($rest
:tt
)*) => (count
!($
($rest
)*) | 1usize
);
680 ( $
($name
:ident
,)+ ) => (
681 impl<D
: Decoder
, $
($name
: Decodable
<D
>),+> Decodable
<D
> for ($
($name
,)+) {
682 #[allow(non_snake_case)]
683 fn decode(d
: &mut D
) -> Result
<($
($name
,)+), D
::Error
> {
684 let len
: usize = count
!($
($name
)+);
685 d
.read_tuple(len
, |d
| {
687 let ret
= ($
(d
.read_tuple_arg({ i+=1; i-1 }
, |d
| -> Result
<$name
, D
::Error
> {
694 impl<S
: Encoder
, $
($name
: Encodable
<S
>),+> Encodable
<S
> for ($
($name
,)+) {
695 #[allow(non_snake_case)]
696 fn encode(&self, s
: &mut S
) -> Result
<(), S
::Error
> {
697 let ($
(ref $name
,)+) = *self;
699 $
(let $name
= $name
; n
+= 1;)+
700 s
.emit_tuple(n
, |s
| {
702 $
(s
.emit_tuple_arg({ i+=1; i-1 }
, |s
| $name
.encode(s
))?
;)+
711 tuple
! { T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, }
713 impl<S
: Encoder
> Encodable
<S
> for path
::Path
{
714 fn encode(&self, e
: &mut S
) -> Result
<(), S
::Error
> {
715 self.to_str().unwrap().encode(e
)
719 impl<S
: Encoder
> Encodable
<S
> for path
::PathBuf
{
720 fn encode(&self, e
: &mut S
) -> Result
<(), S
::Error
> {
721 path
::Path
::encode(self, e
)
725 impl<D
: Decoder
> Decodable
<D
> for path
::PathBuf
{
726 fn decode(d
: &mut D
) -> Result
<path
::PathBuf
, D
::Error
> {
727 let bytes
: String
= Decodable
::decode(d
)?
;
728 Ok(path
::PathBuf
::from(bytes
))
732 impl<S
: Encoder
, T
: Encodable
<S
> + Copy
> Encodable
<S
> for Cell
<T
> {
733 fn encode(&self, s
: &mut S
) -> Result
<(), S
::Error
> {
738 impl<D
: Decoder
, T
: Decodable
<D
> + Copy
> Decodable
<D
> for Cell
<T
> {
739 fn decode(d
: &mut D
) -> Result
<Cell
<T
>, D
::Error
> {
740 Ok(Cell
::new(Decodable
::decode(d
)?
))
745 // Should use `try_borrow`, returning a
746 // `encoder.error("attempting to Encode borrowed RefCell")`
747 // from `encode` when `try_borrow` returns `None`.
749 impl<S
: Encoder
, T
: Encodable
<S
>> Encodable
<S
> for RefCell
<T
> {
750 fn encode(&self, s
: &mut S
) -> Result
<(), S
::Error
> {
751 self.borrow().encode(s
)
755 impl<D
: Decoder
, T
: Decodable
<D
>> Decodable
<D
> for RefCell
<T
> {
756 fn decode(d
: &mut D
) -> Result
<RefCell
<T
>, D
::Error
> {
757 Ok(RefCell
::new(Decodable
::decode(d
)?
))
761 impl<S
: Encoder
, T
: Encodable
<S
>> Encodable
<S
> for Arc
<T
> {
762 fn encode(&self, s
: &mut S
) -> Result
<(), S
::Error
> {
767 impl<D
: Decoder
, T
: Decodable
<D
>> Decodable
<D
> for Arc
<T
> {
768 fn decode(d
: &mut D
) -> Result
<Arc
<T
>, D
::Error
> {
769 Ok(Arc
::new(Decodable
::decode(d
)?
))
773 impl<S
: Encoder
, T
: ?Sized
+ Encodable
<S
>> Encodable
<S
> for Box
<T
> {
774 fn encode(&self, s
: &mut S
) -> Result
<(), S
::Error
> {
778 impl<D
: Decoder
, T
: Decodable
<D
>> Decodable
<D
> for Box
<T
> {
779 fn decode(d
: &mut D
) -> Result
<Box
<T
>, D
::Error
> {
780 Ok(box Decodable
::decode(d
)?
)