Trait abomonation::Abomonation

pub trait Abomonation {
    unsafe fn entomb<W: Write>(&self, _write: &mut W) -> IOResult<()> { ... }
    unsafe fn exhume<'a, 'b>(
        &'a mut self, 
        bytes: &'b mut [u8]
    ) -> Option<&'b mut [u8]> { ... }
    fn extent(&self) -> usize { ... }
}

Abomonation provides methods to serialize any heap data the implementor owns.

The default implementations for Abomonation's methods are all empty. Many types have no owned data to transcribe. Some do, however, and need to carefully implement these unsafe methods.

Safety

Abomonation has no safe methods. Please do not call them. They should be called only by encode and decode, each of which impose restrictions on ownership and lifetime of the data they take as input and return as output.

If you are concerned about safety, it may be best to avoid Abomonation all together. It does several things that may be undefined behavior, depending on how undefined behavior is defined.

Provided methods

unsafe fn entomb<W: Write>(&self, _write: &mut W) -> IOResult<()>

Write any additional information about &self beyond its binary representation.

Most commonly this is owned data on the other end of pointers in &self. The return value reports any failures in writing to write.

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

Recover any information for &mut self not evident from its binary representation.

Most commonly this populates pointers with valid references into bytes.

fn extent(&self) -> usize

Reports the number of further bytes required to entomb self.

Loading content...

Implementations on Foreign Types

impl Abomonation for u8

unsafe fn entomb<W: Write>(&self, _write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl Abomonation for u16

unsafe fn entomb<W: Write>(&self, _write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl Abomonation for u32

unsafe fn entomb<W: Write>(&self, _write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl Abomonation for u64

unsafe fn entomb<W: Write>(&self, _write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl Abomonation for u128

unsafe fn entomb<W: Write>(&self, _write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl Abomonation for usize

unsafe fn entomb<W: Write>(&self, _write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl Abomonation for i8

unsafe fn entomb<W: Write>(&self, _write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl Abomonation for i16

unsafe fn entomb<W: Write>(&self, _write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl Abomonation for i32

unsafe fn entomb<W: Write>(&self, _write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl Abomonation for i64

unsafe fn entomb<W: Write>(&self, _write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl Abomonation for i128

unsafe fn entomb<W: Write>(&self, _write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl Abomonation for isize

unsafe fn entomb<W: Write>(&self, _write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl Abomonation for NonZeroU8

unsafe fn entomb<W: Write>(&self, _write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl Abomonation for NonZeroU16

unsafe fn entomb<W: Write>(&self, _write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl Abomonation for NonZeroU32

unsafe fn entomb<W: Write>(&self, _write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl Abomonation for NonZeroU64

unsafe fn entomb<W: Write>(&self, _write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl Abomonation for NonZeroU128

unsafe fn entomb<W: Write>(&self, _write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl Abomonation for NonZeroUsize

unsafe fn entomb<W: Write>(&self, _write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl Abomonation for f32

unsafe fn entomb<W: Write>(&self, _write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl Abomonation for f64

unsafe fn entomb<W: Write>(&self, _write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl Abomonation for bool

unsafe fn entomb<W: Write>(&self, _write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl Abomonation for ()

unsafe fn entomb<W: Write>(&self, _write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl Abomonation for char

unsafe fn entomb<W: Write>(&self, _write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl Abomonation for Duration

unsafe fn entomb<W: Write>(&self, _write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<T> Abomonation for PhantomData<T>

unsafe fn entomb<W: Write>(&self, _write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<T: Abomonation> Abomonation for Option<T>

unsafe fn entomb<W: Write>(&self, write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<T: Abomonation, E: Abomonation> Abomonation for Result<T, E>

unsafe fn entomb<W: Write>(&self, write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<A: Abomonation> Abomonation for (A,)

unsafe fn entomb<WRITE: Write>(&self, write: &mut WRITE) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<A: Abomonation, B: Abomonation> Abomonation for (A, B)

unsafe fn entomb<WRITE: Write>(&self, write: &mut WRITE) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<A: Abomonation, B: Abomonation, C: Abomonation> Abomonation for (A, B, C)

unsafe fn entomb<WRITE: Write>(&self, write: &mut WRITE) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<A: Abomonation, B: Abomonation, C: Abomonation, D: Abomonation> Abomonation for (A, B, C, D)

unsafe fn entomb<WRITE: Write>(&self, write: &mut WRITE) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<A: Abomonation, B: Abomonation, C: Abomonation, D: Abomonation, E: Abomonation> Abomonation for (A, B, C, D, E)

unsafe fn entomb<WRITE: Write>(&self, write: &mut WRITE) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<A: Abomonation, B: Abomonation, C: Abomonation, D: Abomonation, E: Abomonation, F: Abomonation> Abomonation for (A, B, C, D, E, F)

unsafe fn entomb<WRITE: Write>(&self, write: &mut WRITE) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<A: Abomonation, B: Abomonation, C: Abomonation, D: Abomonation, E: Abomonation, F: Abomonation, G: Abomonation> Abomonation for (A, B, C, D, E, F, G)

unsafe fn entomb<WRITE: Write>(&self, write: &mut WRITE) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<A: Abomonation, B: Abomonation, C: Abomonation, D: Abomonation, E: Abomonation, F: Abomonation, G: Abomonation, H: Abomonation> Abomonation for (A, B, C, D, E, F, G, H)

unsafe fn entomb<WRITE: Write>(&self, write: &mut WRITE) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<A: Abomonation, B: Abomonation, C: Abomonation, D: Abomonation, E: Abomonation, F: Abomonation, G: Abomonation, H: Abomonation, I: Abomonation> Abomonation for (A, B, C, D, E, F, G, H, I)

unsafe fn entomb<WRITE: Write>(&self, write: &mut WRITE) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<A: Abomonation, B: Abomonation, C: Abomonation, D: Abomonation, E: Abomonation, F: Abomonation, G: Abomonation, H: Abomonation, I: Abomonation, J: Abomonation> Abomonation for (A, B, C, D, E, F, G, H, I, J)

unsafe fn entomb<WRITE: Write>(&self, write: &mut WRITE) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<A: Abomonation, B: Abomonation, C: Abomonation, D: Abomonation, E: Abomonation, F: Abomonation, G: Abomonation, H: Abomonation, I: Abomonation, J: Abomonation, K: Abomonation> Abomonation for (A, B, C, D, E, F, G, H, I, J, K)

unsafe fn entomb<WRITE: Write>(&self, write: &mut WRITE) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<A: Abomonation, B: Abomonation, C: Abomonation, D: Abomonation, E: Abomonation, F: Abomonation, G: Abomonation, H: Abomonation, I: Abomonation, J: Abomonation, K: Abomonation, L: Abomonation> Abomonation for (A, B, C, D, E, F, G, H, I, J, K, L)

unsafe fn entomb<WRITE: Write>(&self, write: &mut WRITE) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<A: Abomonation, B: Abomonation, C: Abomonation, D: Abomonation, E: Abomonation, F: Abomonation, G: Abomonation, H: Abomonation, I: Abomonation, J: Abomonation, K: Abomonation, L: Abomonation, M: Abomonation> Abomonation for (A, B, C, D, E, F, G, H, I, J, K, L, M)

unsafe fn entomb<WRITE: Write>(&self, write: &mut WRITE) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<A: Abomonation, B: Abomonation, C: Abomonation, D: Abomonation, E: Abomonation, F: Abomonation, G: Abomonation, H: Abomonation, I: Abomonation, J: Abomonation, K: Abomonation, L: Abomonation, M: Abomonation, N: Abomonation> Abomonation for (A, B, C, D, E, F, G, H, I, J, K, L, M, N)

unsafe fn entomb<WRITE: Write>(&self, write: &mut WRITE) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<A: Abomonation, B: Abomonation, C: Abomonation, D: Abomonation, E: Abomonation, F: Abomonation, G: Abomonation, H: Abomonation, I: Abomonation, J: Abomonation, K: Abomonation, L: Abomonation, M: Abomonation, N: Abomonation, O: Abomonation> Abomonation for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)

unsafe fn entomb<WRITE: Write>(&self, write: &mut WRITE) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<A: Abomonation, B: Abomonation, C: Abomonation, D: Abomonation, E: Abomonation, F: Abomonation, G: Abomonation, H: Abomonation, I: Abomonation, J: Abomonation, K: Abomonation, L: Abomonation, M: Abomonation, N: Abomonation, O: Abomonation, P: Abomonation> Abomonation for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)

unsafe fn entomb<WRITE: Write>(&self, write: &mut WRITE) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<A: Abomonation, B: Abomonation, C: Abomonation, D: Abomonation, E: Abomonation, F: Abomonation, G: Abomonation, H: Abomonation, I: Abomonation, J: Abomonation, K: Abomonation, L: Abomonation, M: Abomonation, N: Abomonation, O: Abomonation, P: Abomonation, Q: Abomonation> Abomonation for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)

unsafe fn entomb<WRITE: Write>(&self, write: &mut WRITE) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<A: Abomonation, B: Abomonation, C: Abomonation, D: Abomonation, E: Abomonation, F: Abomonation, G: Abomonation, H: Abomonation, I: Abomonation, J: Abomonation, K: Abomonation, L: Abomonation, M: Abomonation, N: Abomonation, O: Abomonation, P: Abomonation, Q: Abomonation, R: Abomonation> Abomonation for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)

unsafe fn entomb<WRITE: Write>(&self, write: &mut WRITE) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<A: Abomonation, B: Abomonation, C: Abomonation, D: Abomonation, E: Abomonation, F: Abomonation, G: Abomonation, H: Abomonation, I: Abomonation, J: Abomonation, K: Abomonation, L: Abomonation, M: Abomonation, N: Abomonation, O: Abomonation, P: Abomonation, Q: Abomonation, R: Abomonation, S: Abomonation> Abomonation for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)

unsafe fn entomb<WRITE: Write>(&self, write: &mut WRITE) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<A: Abomonation, B: Abomonation, C: Abomonation, D: Abomonation, E: Abomonation, F: Abomonation, G: Abomonation, H: Abomonation, I: Abomonation, J: Abomonation, K: Abomonation, L: Abomonation, M: Abomonation, N: Abomonation, O: Abomonation, P: Abomonation, Q: Abomonation, R: Abomonation, S: Abomonation, T: Abomonation> Abomonation for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)

unsafe fn entomb<WRITE: Write>(&self, write: &mut WRITE) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<A: Abomonation, B: Abomonation, C: Abomonation, D: Abomonation, E: Abomonation, F: Abomonation, G: Abomonation, H: Abomonation, I: Abomonation, J: Abomonation, K: Abomonation, L: Abomonation, M: Abomonation, N: Abomonation, O: Abomonation, P: Abomonation, Q: Abomonation, R: Abomonation, S: Abomonation, T: Abomonation, U: Abomonation> Abomonation for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)

unsafe fn entomb<WRITE: Write>(&self, write: &mut WRITE) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<A: Abomonation, B: Abomonation, C: Abomonation, D: Abomonation, E: Abomonation, F: Abomonation, G: Abomonation, H: Abomonation, I: Abomonation, J: Abomonation, K: Abomonation, L: Abomonation, M: Abomonation, N: Abomonation, O: Abomonation, P: Abomonation, Q: Abomonation, R: Abomonation, S: Abomonation, T: Abomonation, U: Abomonation, V: Abomonation> Abomonation for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)

unsafe fn entomb<WRITE: Write>(&self, write: &mut WRITE) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<A: Abomonation, B: Abomonation, C: Abomonation, D: Abomonation, E: Abomonation, F: Abomonation, G: Abomonation, H: Abomonation, I: Abomonation, J: Abomonation, K: Abomonation, L: Abomonation, M: Abomonation, N: Abomonation, O: Abomonation, P: Abomonation, Q: Abomonation, R: Abomonation, S: Abomonation, T: Abomonation, U: Abomonation, V: Abomonation, W: Abomonation> Abomonation for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)

unsafe fn entomb<WRITE: Write>(&self, write: &mut WRITE) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<A: Abomonation, B: Abomonation, C: Abomonation, D: Abomonation, E: Abomonation, F: Abomonation, G: Abomonation, H: Abomonation, I: Abomonation, J: Abomonation, K: Abomonation, L: Abomonation, M: Abomonation, N: Abomonation, O: Abomonation, P: Abomonation, Q: Abomonation, R: Abomonation, S: Abomonation, T: Abomonation, U: Abomonation, V: Abomonation, W: Abomonation, X: Abomonation> Abomonation for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)

unsafe fn entomb<WRITE: Write>(&self, write: &mut WRITE) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<A: Abomonation, B: Abomonation, C: Abomonation, D: Abomonation, E: Abomonation, F: Abomonation, G: Abomonation, H: Abomonation, I: Abomonation, J: Abomonation, K: Abomonation, L: Abomonation, M: Abomonation, N: Abomonation, O: Abomonation, P: Abomonation, Q: Abomonation, R: Abomonation, S: Abomonation, T: Abomonation, U: Abomonation, V: Abomonation, W: Abomonation, X: Abomonation, Y: Abomonation> Abomonation for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)

unsafe fn entomb<WRITE: Write>(&self, write: &mut WRITE) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<A: Abomonation, B: Abomonation, C: Abomonation, D: Abomonation, E: Abomonation, F: Abomonation, G: Abomonation, H: Abomonation, I: Abomonation, J: Abomonation, K: Abomonation, L: Abomonation, M: Abomonation, N: Abomonation, O: Abomonation, P: Abomonation, Q: Abomonation, R: Abomonation, S: Abomonation, T: Abomonation, U: Abomonation, V: Abomonation, W: Abomonation, X: Abomonation, Y: Abomonation, Z: Abomonation> Abomonation for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)

unsafe fn entomb<WRITE: Write>(&self, write: &mut WRITE) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<A: Abomonation, B: Abomonation, C: Abomonation, D: Abomonation, E: Abomonation, F: Abomonation, G: Abomonation, H: Abomonation, I: Abomonation, J: Abomonation, K: Abomonation, L: Abomonation, M: Abomonation, N: Abomonation, O: Abomonation, P: Abomonation, Q: Abomonation, R: Abomonation, S: Abomonation, T: Abomonation, U: Abomonation, V: Abomonation, W: Abomonation, X: Abomonation, Y: Abomonation, Z: Abomonation, AA: Abomonation> Abomonation for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA)

unsafe fn entomb<WRITE: Write>(&self, write: &mut WRITE) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<A: Abomonation, B: Abomonation, C: Abomonation, D: Abomonation, E: Abomonation, F: Abomonation, G: Abomonation, H: Abomonation, I: Abomonation, J: Abomonation, K: Abomonation, L: Abomonation, M: Abomonation, N: Abomonation, O: Abomonation, P: Abomonation, Q: Abomonation, R: Abomonation, S: Abomonation, T: Abomonation, U: Abomonation, V: Abomonation, W: Abomonation, X: Abomonation, Y: Abomonation, Z: Abomonation, AA: Abomonation, AB: Abomonation> Abomonation for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB)

unsafe fn entomb<WRITE: Write>(&self, write: &mut WRITE) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<A: Abomonation, B: Abomonation, C: Abomonation, D: Abomonation, E: Abomonation, F: Abomonation, G: Abomonation, H: Abomonation, I: Abomonation, J: Abomonation, K: Abomonation, L: Abomonation, M: Abomonation, N: Abomonation, O: Abomonation, P: Abomonation, Q: Abomonation, R: Abomonation, S: Abomonation, T: Abomonation, U: Abomonation, V: Abomonation, W: Abomonation, X: Abomonation, Y: Abomonation, Z: Abomonation, AA: Abomonation, AB: Abomonation, AC: Abomonation> Abomonation for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC)

unsafe fn entomb<WRITE: Write>(&self, write: &mut WRITE) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<A: Abomonation, B: Abomonation, C: Abomonation, D: Abomonation, E: Abomonation, F: Abomonation, G: Abomonation, H: Abomonation, I: Abomonation, J: Abomonation, K: Abomonation, L: Abomonation, M: Abomonation, N: Abomonation, O: Abomonation, P: Abomonation, Q: Abomonation, R: Abomonation, S: Abomonation, T: Abomonation, U: Abomonation, V: Abomonation, W: Abomonation, X: Abomonation, Y: Abomonation, Z: Abomonation, AA: Abomonation, AB: Abomonation, AC: Abomonation, AD: Abomonation> Abomonation for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD)

unsafe fn entomb<WRITE: Write>(&self, write: &mut WRITE) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<A: Abomonation, B: Abomonation, C: Abomonation, D: Abomonation, E: Abomonation, F: Abomonation, G: Abomonation, H: Abomonation, I: Abomonation, J: Abomonation, K: Abomonation, L: Abomonation, M: Abomonation, N: Abomonation, O: Abomonation, P: Abomonation, Q: Abomonation, R: Abomonation, S: Abomonation, T: Abomonation, U: Abomonation, V: Abomonation, W: Abomonation, X: Abomonation, Y: Abomonation, Z: Abomonation, AA: Abomonation, AB: Abomonation, AC: Abomonation, AD: Abomonation, AE: Abomonation> Abomonation for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE)

unsafe fn entomb<WRITE: Write>(&self, write: &mut WRITE) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<A: Abomonation, B: Abomonation, C: Abomonation, D: Abomonation, E: Abomonation, F: Abomonation, G: Abomonation, H: Abomonation, I: Abomonation, J: Abomonation, K: Abomonation, L: Abomonation, M: Abomonation, N: Abomonation, O: Abomonation, P: Abomonation, Q: Abomonation, R: Abomonation, S: Abomonation, T: Abomonation, U: Abomonation, V: Abomonation, W: Abomonation, X: Abomonation, Y: Abomonation, Z: Abomonation, AA: Abomonation, AB: Abomonation, AC: Abomonation, AD: Abomonation, AE: Abomonation, AF: Abomonation> Abomonation for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF)

unsafe fn entomb<WRITE: Write>(&self, write: &mut WRITE) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<T: Abomonation> Abomonation for [T; 0]

unsafe fn entomb<W: Write>(&self, write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<T: Abomonation> Abomonation for [T; 1]

unsafe fn entomb<W: Write>(&self, write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<T: Abomonation> Abomonation for [T; 2]

unsafe fn entomb<W: Write>(&self, write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<T: Abomonation> Abomonation for [T; 3]

unsafe fn entomb<W: Write>(&self, write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<T: Abomonation> Abomonation for [T; 4]

unsafe fn entomb<W: Write>(&self, write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<T: Abomonation> Abomonation for [T; 5]

unsafe fn entomb<W: Write>(&self, write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<T: Abomonation> Abomonation for [T; 6]

unsafe fn entomb<W: Write>(&self, write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<T: Abomonation> Abomonation for [T; 7]

unsafe fn entomb<W: Write>(&self, write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<T: Abomonation> Abomonation for [T; 8]

unsafe fn entomb<W: Write>(&self, write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<T: Abomonation> Abomonation for [T; 9]

unsafe fn entomb<W: Write>(&self, write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<T: Abomonation> Abomonation for [T; 10]

unsafe fn entomb<W: Write>(&self, write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<T: Abomonation> Abomonation for [T; 11]

unsafe fn entomb<W: Write>(&self, write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<T: Abomonation> Abomonation for [T; 12]

unsafe fn entomb<W: Write>(&self, write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<T: Abomonation> Abomonation for [T; 13]

unsafe fn entomb<W: Write>(&self, write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<T: Abomonation> Abomonation for [T; 14]

unsafe fn entomb<W: Write>(&self, write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<T: Abomonation> Abomonation for [T; 15]

unsafe fn entomb<W: Write>(&self, write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<T: Abomonation> Abomonation for [T; 16]

unsafe fn entomb<W: Write>(&self, write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<T: Abomonation> Abomonation for [T; 17]

unsafe fn entomb<W: Write>(&self, write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<T: Abomonation> Abomonation for [T; 18]

unsafe fn entomb<W: Write>(&self, write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<T: Abomonation> Abomonation for [T; 19]

unsafe fn entomb<W: Write>(&self, write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<T: Abomonation> Abomonation for [T; 20]

unsafe fn entomb<W: Write>(&self, write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<T: Abomonation> Abomonation for [T; 21]

unsafe fn entomb<W: Write>(&self, write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<T: Abomonation> Abomonation for [T; 22]

unsafe fn entomb<W: Write>(&self, write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<T: Abomonation> Abomonation for [T; 23]

unsafe fn entomb<W: Write>(&self, write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<T: Abomonation> Abomonation for [T; 24]

unsafe fn entomb<W: Write>(&self, write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<T: Abomonation> Abomonation for [T; 25]

unsafe fn entomb<W: Write>(&self, write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<T: Abomonation> Abomonation for [T; 26]

unsafe fn entomb<W: Write>(&self, write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<T: Abomonation> Abomonation for [T; 27]

unsafe fn entomb<W: Write>(&self, write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<T: Abomonation> Abomonation for [T; 28]

unsafe fn entomb<W: Write>(&self, write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<T: Abomonation> Abomonation for [T; 29]

unsafe fn entomb<W: Write>(&self, write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<T: Abomonation> Abomonation for [T; 30]

unsafe fn entomb<W: Write>(&self, write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<T: Abomonation> Abomonation for [T; 31]

unsafe fn entomb<W: Write>(&self, write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<T: Abomonation> Abomonation for [T; 32]

unsafe fn entomb<W: Write>(&self, write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl Abomonation for String

unsafe fn entomb<W: Write>(&self, write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<T: Abomonation> Abomonation for Vec<T>

unsafe fn entomb<W: Write>(&self, write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl<T: Abomonation> Abomonation for Box<T>

unsafe fn entomb<W: Write>(&self, bytes: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl Abomonation for IpAddr

unsafe fn entomb<W: Write>(&self, _write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl Abomonation for Ipv4Addr

unsafe fn entomb<W: Write>(&self, _write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl Abomonation for Ipv6Addr

unsafe fn entomb<W: Write>(&self, _write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl Abomonation for SocketAddr

unsafe fn entomb<W: Write>(&self, _write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl Abomonation for SocketAddrV4

unsafe fn entomb<W: Write>(&self, _write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

impl Abomonation for SocketAddrV6

unsafe fn entomb<W: Write>(&self, _write: &mut W) -> IOResult<()>

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

fn extent(&self) -> usize

Loading content...

Implementors

Loading content...