Trait ReadXDR

Source

pub trait ReadXDR<'r>: Sized {
    // Required method
    fn read_xdr<R>(r: &mut R) -> Result<Self, ReadError>
       where R: Reader<'r>;

    // Provided method
    fn read_xdr_in_place<'s, R>(
        r: &mut R,
        slot: Slot<'s, Self>,
    ) -> Result<Init<'s, Self>, ReadError>
       where R: Reader<'r> { ... }
}

Expand description

Types that can be constructed by reading XDR-encoded data, possibly sharing data from the input.

The lifetime parameter 'r represents the lifetime of data borrowed from the reader.

Borrowed types implement this for every lifetime the reader outlives: &'a [u8], &'a [u8; N] and &'a str are ReadXDR<'r> whenever 'r: 'a, not only when 'a is 'r itself. So a decoded borrow can be placed somewhere whose type is already fixed to a shorter lifetime, such as a slot behind &mut or a generic parameter inferred from one, without relying on the use site to shorten it.

§Derived impls and struct lifetimes

#[derive(ReadXDR)] on a type Foo<'a, 'b, ..> emits an impl of the form impl<'_r: 'a + 'b + .., 'a, 'b, ..> ReadXDR<'_r> for Foo<'a, 'b, ..>. That is: every lifetime parameter on the type must be <= the lifetime of the reader buffer, regardless of whether that parameter is actually used to borrow from the buffer. In particular, a phantom lifetime such as PhantomData<&'a ()> is constrained alongside any “real” borrow.

Practical implication: you cannot decode Foo<'static> from a buffer whose lifetime isn’t 'static. If a type has a lifetime parameter that doesn’t actually borrow from the buffer (e.g. it’s purely a phantom marker), let the lifetime be inferred from the buffer rather than naming it explicitly, or implement ReadXDR by hand.

Custom borrowed field types need the same bounds as the built-in borrows: implement ReadXDR<'r> for Borrowed<'a> whenever 'r: 'a. An impl only for ReadXDR<'a> for Borrowed<'a> can work by value through lifetime coercion, but cannot fill a field whose type is fixed behind &mut.

use xdrs::{ReadXDR, ReadResult};
use xdrs::serialize::reader::Reader;

struct Borrowed<'a>(&'a [u8]);

impl<'r: 'a, 'a> ReadXDR<'r> for Borrowed<'a> {
    fn read_xdr<R: Reader<'r>>(r: &mut R) -> ReadResult<Self> {
        Ok(Self(r.read_opaque_variable(u32::MAX)?))
    }
}

§In-place decoding

ReadXDR::read_xdr_in_place decodes straight into a destination that the decoder hands over as a Slot, and returns an Init proving that the slot was filled. The trait is safe to implement because an Init can only be produced from the slot it refers to: safely through Slot::write, or through Slot::assume_init once the implementation has initialized the value itself. A decoder such as Box, Vec or a derived struct relies on that proof to treat the destination as initialized and, later, to drop it.

Most types keep the default, which decodes with ReadXDR::read_xdr and writes the result into the slot. An override only has to make sure that on an error or panic nothing is left in the slot that needs dropping: callers never drop a destination they did not get an Init for, so an override that initializes part of the value before failing must drop what it wrote.

A safe override cannot return a value that lives somewhere else:

use xdrs::{Init, ReadXDR, ReadResult, Slot};
use xdrs::serialize::reader::Reader;

struct Elsewhere(u32);

impl<'r> ReadXDR<'r> for Elsewhere {
    fn read_xdr<R: Reader<'r>>(r: &mut R) -> ReadResult<Self> {
        Ok(Self(r.read_u32()?))
    }

    fn read_xdr_in_place<'s, R: Reader<'r>>(
        r: &mut R,
        slot: Slot<'s, Self>,
    ) -> ReadResult<Init<'s, Self>> {
        // error: expected `Init<'s, Elsewhere>`, found `&mut Elsewhere`
        Ok(Box::leak(Box::new(Self::read_xdr(r)?)))
    }
}

§Example

use xdrs::{ReadXDR, cxs};

let data = [0u8]; // valid CXS encoding for the unsigned integer 0
let _value: u32 = cxs::decode(&data)?;

Required Methods§

Source

fn read_xdr<R>(r: &mut R) -> Result<Self, ReadError>
where R: Reader<'r>,

Reads an XDR value from the reader.

This method should read the appropriate amount of data from the reader and construct a value of type Self.

Provided Methods§

Source

fn read_xdr_in_place<'s, R>( r: &mut R, slot: Slot<'s, Self>, ) -> Result<Init<'s, Self>, ReadError>
where R: Reader<'r>,

Reads an XDR value directly into slot, without first building it on the stack.

The returned Init proves that slot holds a valid Self; it comes from Slot::write, or from Slot::assume_init after the implementation initialized the value through Slot::as_mut_ptr. On error, nothing in slot may be left that needs dropping: an implementation that writes part of the value before failing must drop what it wrote.

The default implementation decodes with ReadXDR::read_xdr and moves the result into slot. Overriding it pays off for large values, such as structs with big fixed-size arrays, that would otherwise be built in a stack frame and then copied. Callers with a MaybeUninit destination go through read_xdr_in_place.

Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Trait ReadXDR Copy item path

§Derived impls and struct lifetimes

§In-place decoding

§Example

Required Methods§

fn read_xdr<R>(r: &mut R) -> Result<Self, ReadError>where R: Reader<'r>,

Provided Methods§

fn read_xdr_in_place<'s, R>( r: &mut R, slot: Slot<'s, Self>, ) -> Result<Init<'s, Self>, ReadError>where R: Reader<'r>,

Dyn Compatibility§

Implementations on Foreign Types§

impl<'_r> ReadXDR<'_r> for AddressAuthData

fn read_xdr<R>(r: &mut R) -> Result<AddressAuthData, ReadError>where R: Reader<'_r>,

fn read_xdr_in_place<R, '__xdrs_s>( r: &mut R, __xdrs_slot: Slot<'__xdrs_s, AddressAuthData>, ) -> Result<Init<'__xdrs_s, AddressAuthData>, ReadError>where R: Reader<'_r>,

impl<'_r> ReadXDR<'_r> for ApprovalEvent

fn read_xdr<R>(r: &mut R) -> Result<ApprovalEvent, ReadError>where R: Reader<'_r>,

fn read_xdr_in_place<R, '__xdrs_s>( r: &mut R, __xdrs_slot: Slot<'__xdrs_s, ApprovalEvent>, ) -> Result<Init<'__xdrs_s, ApprovalEvent>, ReadError>where R: Reader<'_r>,

impl<'_r> ReadXDR<'_r> for AuthClaim_source_address_claim

fn read_xdr<R>(r: &mut R) -> Result<AuthClaim_source_address_claim, ReadError>where R: Reader<'_r>,

fn read_xdr_in_place<R, '__xdrs_s>( r: &mut R, __xdrs_slot: Slot<'__xdrs_s, AuthClaim_source_address_claim>, ) -> Result<Init<'__xdrs_s, AuthClaim_source_address_claim>, ReadError>where R: Reader<'_r>,

impl<'_r> ReadXDR<'_r> for AuthDataChangeArgs

fn read_xdr<R>(r: &mut R) -> Result<AuthDataChangeArgs, ReadError>where R: Reader<'_r>,

fn read_xdr_in_place<R, '__xdrs_s>( r: &mut R, __xdrs_slot: Slot<'__xdrs_s, AuthDataChangeArgs>, ) -> Result<Init<'__xdrs_s, AuthDataChangeArgs>, ReadError>where R: Reader<'_r>,

impl<'_r> ReadXDR<'_r> for AuthDataChangeSigner

fn read_xdr<R>(r: &mut R) -> Result<AuthDataChangeSigner, ReadError>where R: Reader<'_r>,

fn read_xdr_in_place<R, '__xdrs_s>( r: &mut R, __xdrs_slot: Slot<'__xdrs_s, AuthDataChangeSigner>, ) -> Result<Init<'__xdrs_s, AuthDataChangeSigner>, ReadError>where R: Reader<'_r>,

impl<'_r> ReadXDR<'_r> for AuthVerifyErrorCode

fn read_xdr<R>(r: &mut R) -> Result<AuthVerifyErrorCode, ReadError>where R: Reader<'_r>,

fn read_xdr_in_place<R, '__xdrs_s>( r: &mut R, __xdrs_slot: Slot<'__xdrs_s, AuthVerifyErrorCode>, ) -> Result<Init<'__xdrs_s, AuthVerifyErrorCode>, ReadError>where R: Reader<'_r>,

impl<'_r> ReadXDR<'_r> for ConfigHashPreimage

fn read_xdr<R>(r: &mut R) -> Result<ConfigHashPreimage, ReadError>where R: Reader<'_r>,

fn read_xdr_in_place<R, '__xdrs_s>( r: &mut R, __xdrs_slot: Slot<'__xdrs_s, ConfigHashPreimage>, ) -> Result<Init<'__xdrs_s, ConfigHashPreimage>, ReadError>where R: Reader<'_r>,

impl<'_r> ReadXDR<'_r> for ConfigParam

fn read_xdr<R>(r: &mut R) -> Result<ConfigParam, ReadError>where R: Reader<'_r>,

impl<'_r> ReadXDR<'_r> for ConfigParamID

fn read_xdr<R>(r: &mut R) -> Result<ConfigParamID, ReadError>where R: Reader<'_r>,

fn read_xdr_in_place<R, '__xdrs_s>( r: &mut R, __xdrs_slot: Slot<'__xdrs_s, ConfigParamID>, ) -> Result<Init<'__xdrs_s, ConfigParamID>, ReadError>where R: Reader<'_r>,

impl<'_r> ReadXDR<'_r> for ConsumeUniquifierArgs

fn read_xdr<R>(r: &mut R) -> Result<ConsumeUniquifierArgs, ReadError>where R: Reader<'_r>,

fn read_xdr_in_place<R, '__xdrs_s>( r: &mut R, __xdrs_slot: Slot<'__xdrs_s, ConsumeUniquifierArgs>, ) -> Result<Init<'__xdrs_s, ConsumeUniquifierArgs>, ReadError>where R: Reader<'_r>,

impl<'_r> ReadXDR<'_r> for ContractArrayType

fn read_xdr<R>(r: &mut R) -> Result<ContractArrayType, ReadError>where R: Reader<'_r>,

fn read_xdr_in_place<R, '__xdrs_s>( r: &mut R, __xdrs_slot: Slot<'__xdrs_s, ContractArrayType>, ) -> Result<Init<'__xdrs_s, ContractArrayType>, ReadError>where R: Reader<'_r>,

impl<'_r> ReadXDR<'_r> for ContractEnumDef

fn read_xdr<R>(r: &mut R) -> Result<ContractEnumDef, ReadError>where R: Reader<'_r>,

fn read_xdr_in_place<R, '__xdrs_s>( r: &mut R, __xdrs_slot: Slot<'__xdrs_s, ContractEnumDef>, ) -> Result<Init<'__xdrs_s, ContractEnumDef>, ReadError>where R: Reader<'_r>,

impl<'_r> ReadXDR<'_r> for ContractEnumVariant

fn read_xdr<R>(r: &mut R) -> Result<ContractEnumVariant, ReadError>where R: Reader<'_r>,

fn read_xdr_in_place<R, '__xdrs_s>( r: &mut R, __xdrs_slot: Slot<'__xdrs_s, ContractEnumVariant>, ) -> Result<Init<'__xdrs_s, ContractEnumVariant>, ReadError>where R: Reader<'_r>,

impl<'_r> ReadXDR<'_r> for ContractEventDef

fn read_xdr<R>(r: &mut R) -> Result<ContractEventDef, ReadError>where R: Reader<'_r>,

fn read_xdr_in_place<R, '__xdrs_s>( r: &mut R, __xdrs_slot: Slot<'__xdrs_s, ContractEventDef>, ) -> Result<Init<'__xdrs_s, ContractEventDef>, ReadError>where R: Reader<'_r>,

impl<'_r> ReadXDR<'_r> for ContractExceptionType

fn read_xdr<R>(r: &mut R) -> Result<ContractExceptionType, ReadError>where R: Reader<'_r>,

fn read_xdr_in_place<R, '__xdrs_s>( r: &mut R, __xdrs_slot: Slot<'__xdrs_s, ContractExceptionType>, ) -> Result<Init<'__xdrs_s, ContractExceptionType>, ReadError>where R: Reader<'_r>,

impl<'_r> ReadXDR<'_r> for ContractField

fn read_xdr<R>(r: &mut R) -> Result<ContractField, ReadError>where R: Reader<'_r>,

fn read_xdr_in_place<R, '__xdrs_s>( r: &mut R, __xdrs_slot: Slot<'__xdrs_s, ContractField>, ) -> Result<Init<'__xdrs_s, ContractField>, ReadError>where R: Reader<'_r>,

impl<'_r> ReadXDR<'_r> for ContractMethodEffect

fn read_xdr<R>(r: &mut R) -> Result<ContractMethodEffect, ReadError>where R: Reader<'_r>,

fn read_xdr_in_place<R, '__xdrs_s>( r: &mut R, __xdrs_slot: Slot<'__xdrs_s, ContractMethodEffect>, ) -> Result<Init<'__xdrs_s, ContractMethodEffect>, ReadError>where R: Reader<'_r>,

impl<'_r> ReadXDR<'_r> for ContractRejectCode

fn read_xdr<R>(r: &mut R) -> Result<ContractRejectCode, ReadError>where R: Reader<'_r>,

fn read_xdr_in_place<R, '__xdrs_s>( r: &mut R, __xdrs_slot: Slot<'__xdrs_s, ContractRejectCode>, ) -> Result<Init<'__xdrs_s, ContractRejectCode>, ReadError>where R: Reader<'_r>,

impl<'_r> ReadXDR<'_r> for ContractRejectDiagnostic

fn read_xdr<R>(r: &mut R) -> Result<ContractRejectDiagnostic, ReadError>where R: Reader<'_r>,

fn read_xdr_in_place<R, '__xdrs_s>( r: &mut R, __xdrs_slot: Slot<'__xdrs_s, ContractRejectDiagnostic>, ) -> Result<Init<'__xdrs_s, ContractRejectDiagnostic>, ReadError>where R: Reader<'_r>,

impl<'_r> ReadXDR<'_r> for ContractSignedTokenPreimage

fn read_xdr<R>(r: &mut R) -> Result<ContractSignedTokenPreimage, ReadError>where R: Reader<'_r>,

fn read_xdr_in_place<R, '__xdrs_s>( r: &mut R, __xdrs_slot: Slot<'__xdrs_s, ContractSignedTokenPreimage>, ) -> Result<Init<'__xdrs_s, ContractSignedTokenPreimage>, ReadError>where R: Reader<'_r>,

impl<'_r> ReadXDR<'_r> for ContractSpec

fn read_xdr<R>(r: &mut R) -> Result<ContractSpec, ReadError>where R: Reader<'_r>,

fn read_xdr_in_place<R, '__xdrs_s>( r: &mut R, __xdrs_slot: Slot<'__xdrs_s, ContractSpec>, ) -> Result<Init<'__xdrs_s, ContractSpec>, ReadError>where R: Reader<'_r>,

impl<'_r> ReadXDR<'_r> for ContractSpecId

fn read_xdr<R>(r: &mut R) -> Result<ContractSpecId, ReadError>where R: Reader<'_r>,

fn read_xdr_in_place<R, '__xdrs_s>( r: &mut R, __xdrs_slot: Slot<'__xdrs_s, ContractSpecId>, ) -> Result<Init<'__xdrs_s, ContractSpecId>, ReadError>where R: Reader<'_r>,

impl<'_r> ReadXDR<'_r> for ContractSpecInterface

fn read_xdr<R>(r: &mut R) -> Result<ContractSpecInterface, ReadError>where R: Reader<'_r>,

fn read_xdr_in_place<R, '__xdrs_s>( r: &mut R, __xdrs_slot: Slot<'__xdrs_s, ContractSpecInterface>, ) -> Result<Init<'__xdrs_s, ContractSpecInterface>, ReadError>where R: Reader<'_r>,

impl<'_r> ReadXDR<'_r> for ContractSpecMethod

fn read_xdr<R>(r: &mut R) -> Result<ContractSpecMethod, ReadError>where R: Reader<'_r>,

Trait ReadXDR

fn read_xdr<R>(r: &mut R) -> Result<Self, ReadError>
where R: Reader<'r>,

fn read_xdr_in_place<'s, R>( r: &mut R, slot: Slot<'s, Self>, ) -> Result<Init<'s, Self>, ReadError>
where R: Reader<'r>,

fn read_xdr<R>(r: &mut R) -> Result<AddressAuthData, ReadError>
where R: Reader<'_r>,

fn read_xdr_in_place<R, '__xdrs_s>( r: &mut R, __xdrs_slot: Slot<'__xdrs_s, AddressAuthData>, ) -> Result<Init<'__xdrs_s, AddressAuthData>, ReadError>
where R: Reader<'_r>,

fn read_xdr<R>(r: &mut R) -> Result<ApprovalEvent, ReadError>
where R: Reader<'_r>,

fn read_xdr_in_place<R, '__xdrs_s>( r: &mut R, __xdrs_slot: Slot<'__xdrs_s, ApprovalEvent>, ) -> Result<Init<'__xdrs_s, ApprovalEvent>, ReadError>
where R: Reader<'_r>,

fn read_xdr<R>(r: &mut R) -> Result<AuthClaim_source_address_claim, ReadError>
where R: Reader<'_r>,

fn read_xdr_in_place<R, '__xdrs_s>( r: &mut R, __xdrs_slot: Slot<'__xdrs_s, AuthClaim_source_address_claim>, ) -> Result<Init<'__xdrs_s, AuthClaim_source_address_claim>, ReadError>
where R: Reader<'_r>,

fn read_xdr<R>(r: &mut R) -> Result<AuthDataChangeArgs, ReadError>
where R: Reader<'_r>,

fn read_xdr_in_place<R, '__xdrs_s>( r: &mut R, __xdrs_slot: Slot<'__xdrs_s, AuthDataChangeArgs>, ) -> Result<Init<'__xdrs_s, AuthDataChangeArgs>, ReadError>
where R: Reader<'_r>,

fn read_xdr<R>(r: &mut R) -> Result<AuthDataChangeSigner, ReadError>
where R: Reader<'_r>,

fn read_xdr_in_place<R, '__xdrs_s>( r: &mut R, __xdrs_slot: Slot<'__xdrs_s, AuthDataChangeSigner>, ) -> Result<Init<'__xdrs_s, AuthDataChangeSigner>, ReadError>
where R: Reader<'_r>,

fn read_xdr<R>(r: &mut R) -> Result<AuthVerifyErrorCode, ReadError>
where R: Reader<'_r>,

fn read_xdr_in_place<R, '__xdrs_s>( r: &mut R, __xdrs_slot: Slot<'__xdrs_s, AuthVerifyErrorCode>, ) -> Result<Init<'__xdrs_s, AuthVerifyErrorCode>, ReadError>
where R: Reader<'_r>,

fn read_xdr<R>(r: &mut R) -> Result<ConfigHashPreimage, ReadError>
where R: Reader<'_r>,

fn read_xdr_in_place<R, '__xdrs_s>( r: &mut R, __xdrs_slot: Slot<'__xdrs_s, ConfigHashPreimage>, ) -> Result<Init<'__xdrs_s, ConfigHashPreimage>, ReadError>
where R: Reader<'_r>,

fn read_xdr<R>(r: &mut R) -> Result<ConfigParam, ReadError>
where R: Reader<'_r>,

fn read_xdr<R>(r: &mut R) -> Result<ConfigParamID, ReadError>
where R: Reader<'_r>,

fn read_xdr_in_place<R, '__xdrs_s>( r: &mut R, __xdrs_slot: Slot<'__xdrs_s, ConfigParamID>, ) -> Result<Init<'__xdrs_s, ConfigParamID>, ReadError>
where R: Reader<'_r>,

fn read_xdr<R>(r: &mut R) -> Result<ConsumeUniquifierArgs, ReadError>
where R: Reader<'_r>,

fn read_xdr_in_place<R, '__xdrs_s>( r: &mut R, __xdrs_slot: Slot<'__xdrs_s, ConsumeUniquifierArgs>, ) -> Result<Init<'__xdrs_s, ConsumeUniquifierArgs>, ReadError>
where R: Reader<'_r>,

fn read_xdr<R>(r: &mut R) -> Result<ContractArrayType, ReadError>
where R: Reader<'_r>,

fn read_xdr_in_place<R, '__xdrs_s>( r: &mut R, __xdrs_slot: Slot<'__xdrs_s, ContractArrayType>, ) -> Result<Init<'__xdrs_s, ContractArrayType>, ReadError>
where R: Reader<'_r>,

fn read_xdr<R>(r: &mut R) -> Result<ContractEnumDef, ReadError>
where R: Reader<'_r>,

fn read_xdr_in_place<R, '__xdrs_s>( r: &mut R, __xdrs_slot: Slot<'__xdrs_s, ContractEnumDef>, ) -> Result<Init<'__xdrs_s, ContractEnumDef>, ReadError>
where R: Reader<'_r>,

fn read_xdr<R>(r: &mut R) -> Result<ContractEnumVariant, ReadError>
where R: Reader<'_r>,

fn read_xdr_in_place<R, '__xdrs_s>( r: &mut R, __xdrs_slot: Slot<'__xdrs_s, ContractEnumVariant>, ) -> Result<Init<'__xdrs_s, ContractEnumVariant>, ReadError>
where R: Reader<'_r>,

fn read_xdr<R>(r: &mut R) -> Result<ContractEventDef, ReadError>
where R: Reader<'_r>,

fn read_xdr_in_place<R, '__xdrs_s>( r: &mut R, __xdrs_slot: Slot<'__xdrs_s, ContractEventDef>, ) -> Result<Init<'__xdrs_s, ContractEventDef>, ReadError>
where R: Reader<'_r>,

fn read_xdr<R>(r: &mut R) -> Result<ContractExceptionType, ReadError>
where R: Reader<'_r>,

fn read_xdr_in_place<R, '__xdrs_s>( r: &mut R, __xdrs_slot: Slot<'__xdrs_s, ContractExceptionType>, ) -> Result<Init<'__xdrs_s, ContractExceptionType>, ReadError>
where R: Reader<'_r>,

fn read_xdr<R>(r: &mut R) -> Result<ContractField, ReadError>
where R: Reader<'_r>,

fn read_xdr_in_place<R, '__xdrs_s>( r: &mut R, __xdrs_slot: Slot<'__xdrs_s, ContractField>, ) -> Result<Init<'__xdrs_s, ContractField>, ReadError>
where R: Reader<'_r>,

fn read_xdr<R>(r: &mut R) -> Result<ContractMethodEffect, ReadError>
where R: Reader<'_r>,

fn read_xdr_in_place<R, '__xdrs_s>( r: &mut R, __xdrs_slot: Slot<'__xdrs_s, ContractMethodEffect>, ) -> Result<Init<'__xdrs_s, ContractMethodEffect>, ReadError>
where R: Reader<'_r>,

fn read_xdr<R>(r: &mut R) -> Result<ContractRejectCode, ReadError>
where R: Reader<'_r>,

fn read_xdr_in_place<R, '__xdrs_s>( r: &mut R, __xdrs_slot: Slot<'__xdrs_s, ContractRejectCode>, ) -> Result<Init<'__xdrs_s, ContractRejectCode>, ReadError>
where R: Reader<'_r>,

fn read_xdr<R>(r: &mut R) -> Result<ContractRejectDiagnostic, ReadError>
where R: Reader<'_r>,

fn read_xdr_in_place<R, '__xdrs_s>( r: &mut R, __xdrs_slot: Slot<'__xdrs_s, ContractRejectDiagnostic>, ) -> Result<Init<'__xdrs_s, ContractRejectDiagnostic>, ReadError>
where R: Reader<'_r>,

fn read_xdr<R>(r: &mut R) -> Result<ContractSignedTokenPreimage, ReadError>
where R: Reader<'_r>,

fn read_xdr_in_place<R, '__xdrs_s>( r: &mut R, __xdrs_slot: Slot<'__xdrs_s, ContractSignedTokenPreimage>, ) -> Result<Init<'__xdrs_s, ContractSignedTokenPreimage>, ReadError>
where R: Reader<'_r>,

fn read_xdr<R>(r: &mut R) -> Result<ContractSpec, ReadError>
where R: Reader<'_r>,

fn read_xdr_in_place<R, '__xdrs_s>( r: &mut R, __xdrs_slot: Slot<'__xdrs_s, ContractSpec>, ) -> Result<Init<'__xdrs_s, ContractSpec>, ReadError>
where R: Reader<'_r>,

fn read_xdr<R>(r: &mut R) -> Result<ContractSpecId, ReadError>
where R: Reader<'_r>,

fn read_xdr_in_place<R, '__xdrs_s>( r: &mut R, __xdrs_slot: Slot<'__xdrs_s, ContractSpecId>, ) -> Result<Init<'__xdrs_s, ContractSpecId>, ReadError>
where R: Reader<'_r>,

fn read_xdr<R>(r: &mut R) -> Result<ContractSpecInterface, ReadError>
where R: Reader<'_r>,

fn read_xdr_in_place<R, '__xdrs_s>( r: &mut R, __xdrs_slot: Slot<'__xdrs_s, ContractSpecInterface>, ) -> Result<Init<'__xdrs_s, ContractSpecInterface>, ReadError>
where R: Reader<'_r>,

fn read_xdr<R>(r: &mut R) -> Result<ContractSpecMethod, ReadError>
where R: Reader<'_r>,

fn read_xdr_in_place<R, '__xdrs_s>( r: &mut R, __xdrs_slot: Slot<'__xdrs_s, ContractSpecMethod>, ) -> Result<Init<'__xdrs_s, ContractSpecMethod>, ReadError>
where R: Reader<'_r>,

fn read_xdr<R>(r: &mut R) -> Result<ContractStructDef, ReadError>
where R: Reader<'_r>,

fn read_xdr_in_place<R, '__xdrs_s>( r: &mut R, __xdrs_slot: Slot<'__xdrs_s, ContractStructDef>, ) -> Result<Init<'__xdrs_s, ContractStructDef>, ReadError>
where R: Reader<'_r>,

fn read_xdr<R>(r: &mut R) -> Result<ContractType, ReadError>
where R: Reader<'_r>,

fn read_xdr<R>(r: &mut R) -> Result<ContractTypeDef, ReadError>
where R: Reader<'_r>,

fn read_xdr<R>(r: &mut R) -> Result<ContractTypeDefKind, ReadError>
where R: Reader<'_r>,

fn read_xdr_in_place<R, '__xdrs_s>( r: &mut R, __xdrs_slot: Slot<'__xdrs_s, ContractTypeDefKind>, ) -> Result<Init<'__xdrs_s, ContractTypeDefKind>, ReadError>
where R: Reader<'_r>,

fn read_xdr<R>(r: &mut R) -> Result<ContractTypeKind, ReadError>
where R: Reader<'_r>,

fn read_xdr_in_place<R, '__xdrs_s>( r: &mut R, __xdrs_slot: Slot<'__xdrs_s, ContractTypeKind>, ) -> Result<Init<'__xdrs_s, ContractTypeKind>, ReadError>
where R: Reader<'_r>,

fn read_xdr<R>(r: &mut R) -> Result<ContractUnionCase, ReadError>
where R: Reader<'_r>,

fn read_xdr_in_place<R, '__xdrs_s>( r: &mut R, __xdrs_slot: Slot<'__xdrs_s, ContractUnionCase>, ) -> Result<Init<'__xdrs_s, ContractUnionCase>, ReadError>
where R: Reader<'_r>,

fn read_xdr<R>(r: &mut R) -> Result<ContractUnionCaseKind, ReadError>
where R: Reader<'_r>,

fn read_xdr_in_place<R, '__xdrs_s>( r: &mut R, __xdrs_slot: Slot<'__xdrs_s, ContractUnionCaseKind>, ) -> Result<Init<'__xdrs_s, ContractUnionCaseKind>, ReadError>
where R: Reader<'_r>,

fn read_xdr<R>(r: &mut R) -> Result<ContractUnionCaseType, ReadError>
where R: Reader<'_r>,

fn read_xdr<R>(r: &mut R) -> Result<ContractUnionDef, ReadError>
where R: Reader<'_r>,

fn read_xdr_in_place<R, '__xdrs_s>( r: &mut R, __xdrs_slot: Slot<'__xdrs_s, ContractUnionDef>, ) -> Result<Init<'__xdrs_s, ContractUnionDef>, ReadError>
where R: Reader<'_r>,

fn read_xdr<R>(r: &mut R) -> Result<ContractVectorType, ReadError>
where R: Reader<'_r>,

fn read_xdr_in_place<R, '__xdrs_s>( r: &mut R, __xdrs_slot: Slot<'__xdrs_s, ContractVectorType>, ) -> Result<Init<'__xdrs_s, ContractVectorType>, ReadError>
where R: Reader<'_r>,

fn read_xdr<R>(r: &mut R) -> Result<DbDiagnosticLevel, ReadError>
where R: Reader<'_r>,

fn read_xdr_in_place<R, '__xdrs_s>( r: &mut R, __xdrs_slot: Slot<'__xdrs_s, DbDiagnosticLevel>, ) -> Result<Init<'__xdrs_s, DbDiagnosticLevel>, ReadError>
where R: Reader<'_r>,

fn read_xdr<R>(r: &mut R) -> Result<DomainSeparator, ReadError>
where R: Reader<'_r>,

fn read_xdr_in_place<R, '__xdrs_s>( r: &mut R, __xdrs_slot: Slot<'__xdrs_s, DomainSeparator>, ) -> Result<Init<'__xdrs_s, DomainSeparator>, ReadError>
where R: Reader<'_r>,

fn read_xdr<R>(r: &mut R) -> Result<ExpectedViewResult, ReadError>
where R: Reader<'_r>,

fn read_xdr<R>(r: &mut R) -> Result<FlaggedStorageDelta, ReadError>
where R: Reader<'_r>,

fn read_xdr_in_place<R, '__xdrs_s>( r: &mut R, __xdrs_slot: Slot<'__xdrs_s, FlaggedStorageDelta>, ) -> Result<Init<'__xdrs_s, FlaggedStorageDelta>, ReadError>
where R: Reader<'_r>,

fn read_xdr<R>( r: &mut R, ) -> Result<HogexecPrecompiledNativeContracts, ReadError>
where R: Reader<'_r>,

fn read_xdr_in_place<R, '__xdrs_s>( r: &mut R, __xdrs_slot: Slot<'__xdrs_s, HogexecPrecompiledNativeContracts>, ) -> Result<Init<'__xdrs_s, HogexecPrecompiledNativeContracts>, ReadError>
where R: Reader<'_r>,

fn read_xdr<R>(r: &mut R) -> Result<HostFunctionStatusXdr, ReadError>
where R: Reader<'_r>,

fn read_xdr<R>(r: &mut R) -> Result<InvocationFrameTrace, ReadError>
where R: Reader<'_r>,

fn read_xdr_in_place<R, '__xdrs_s>( r: &mut R, __xdrs_slot: Slot<'__xdrs_s, InvocationFrameTrace>, ) -> Result<Init<'__xdrs_s, InvocationFrameTrace>, ReadError>
where R: Reader<'_r>,

fn read_xdr<R>(r: &mut R) -> Result<NetworkConfig, ReadError>
where R: Reader<'_r>,