Trait GraphCodec 

pub trait GraphCodec<B: WireFormatBackend>: Sized {
    type Error;

    // Required methods
    fn encode(self, codec: &B::Codec) -> Result<B::Compact, Self::Error>;
    fn decode(
        response: &B::Compact,
        codec: &B::Codec,
    ) -> Result<Self, Self::Error>;
}

An entry trait that handles the values of a fan-in/fanout entry

Required Associated Types

type Error

The codec error

Required Methods

fn encode(self, codec: &B::Codec) -> Result<B::Compact, Self::Error>

Encode the input into a Compact

fn decode(response: &B::Compact, codec: &B::Codec) -> Result<Self, Self::Error>

Decode the previous input

Dyn Compatibility

This trait is not dyn compatible.

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

Implementations on Foreign Types

impl<B, Err, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> GraphCodec<B> for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)

where B: Backend + WireFormatBackend, B::Codec: Codec<T1, Compact = B::Compact, Error = Err> + Codec<Vec<B::Compact>, Compact = B::Compact, Error = Err> + Codec<T2, Compact = B::Compact, Error = Err> + Codec<T3, Compact = B::Compact, Error = Err> + Codec<T4, Compact = B::Compact, Error = Err> + Codec<T5, Compact = B::Compact, Error = Err> + Codec<T6, Compact = B::Compact, Error = Err> + Codec<T7, Compact = B::Compact, Error = Err> + Codec<T8, Compact = B::Compact, Error = Err> + Codec<T9, Compact = B::Compact, Error = Err> + Codec<T10, Compact = B::Compact, Error = Err> + Codec<T11, Compact = B::Compact, Error = Err> + Codec<T12, Compact = B::Compact, Error = Err>, <B::Codec as Codec<T2>>::Error: Into<<B::Codec as Codec<T1>>::Error>, <B::Codec as Codec<T3>>::Error: Into<<B::Codec as Codec<T1>>::Error>, <B::Codec as Codec<T4>>::Error: Into<<B::Codec as Codec<T1>>::Error>, <B::Codec as Codec<T5>>::Error: Into<<B::Codec as Codec<T1>>::Error>, <B::Codec as Codec<T6>>::Error: Into<<B::Codec as Codec<T1>>::Error>, <B::Codec as Codec<T7>>::Error: Into<<B::Codec as Codec<T1>>::Error>, <B::Codec as Codec<T8>>::Error: Into<<B::Codec as Codec<T1>>::Error>, <B::Codec as Codec<T9>>::Error: Into<<B::Codec as Codec<T1>>::Error>, <B::Codec as Codec<T10>>::Error: Into<<B::Codec as Codec<T1>>::Error>, <B::Codec as Codec<T11>>::Error: Into<<B::Codec as Codec<T1>>::Error>, <B::Codec as Codec<T12>>::Error: Into<<B::Codec as Codec<T1>>::Error>,

type Error = <<B as WireFormatBackend>::Codec as Codec<T1>>::Error

fn encode(self, codec: &B::Codec) -> Result<B::Compact, Self::Error>

fn decode(response: &B::Compact, codec: &B::Codec) -> Result<Self, Err>

impl<B, Err, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> GraphCodec<B> for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

where B: Backend + WireFormatBackend, B::Codec: Codec<T1, Compact = B::Compact, Error = Err> + Codec<Vec<B::Compact>, Compact = B::Compact, Error = Err> + Codec<T2, Compact = B::Compact, Error = Err> + Codec<T3, Compact = B::Compact, Error = Err> + Codec<T4, Compact = B::Compact, Error = Err> + Codec<T5, Compact = B::Compact, Error = Err> + Codec<T6, Compact = B::Compact, Error = Err> + Codec<T7, Compact = B::Compact, Error = Err> + Codec<T8, Compact = B::Compact, Error = Err> + Codec<T9, Compact = B::Compact, Error = Err> + Codec<T10, Compact = B::Compact, Error = Err> + Codec<T11, Compact = B::Compact, Error = Err>, <B::Codec as Codec<T2>>::Error: Into<<B::Codec as Codec<T1>>::Error>, <B::Codec as Codec<T3>>::Error: Into<<B::Codec as Codec<T1>>::Error>, <B::Codec as Codec<T4>>::Error: Into<<B::Codec as Codec<T1>>::Error>, <B::Codec as Codec<T5>>::Error: Into<<B::Codec as Codec<T1>>::Error>, <B::Codec as Codec<T6>>::Error: Into<<B::Codec as Codec<T1>>::Error>, <B::Codec as Codec<T7>>::Error: Into<<B::Codec as Codec<T1>>::Error>, <B::Codec as Codec<T8>>::Error: Into<<B::Codec as Codec<T1>>::Error>, <B::Codec as Codec<T9>>::Error: Into<<B::Codec as Codec<T1>>::Error>, <B::Codec as Codec<T10>>::Error: Into<<B::Codec as Codec<T1>>::Error>, <B::Codec as Codec<T11>>::Error: Into<<B::Codec as Codec<T1>>::Error>,

type Error = <<B as WireFormatBackend>::Codec as Codec<T1>>::Error

fn encode(self, codec: &B::Codec) -> Result<B::Compact, Self::Error>

fn decode(response: &B::Compact, codec: &B::Codec) -> Result<Self, Err>

impl<B, Err, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> GraphCodec<B> for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

where B: Backend + WireFormatBackend, B::Codec: Codec<T1, Compact = B::Compact, Error = Err> + Codec<Vec<B::Compact>, Compact = B::Compact, Error = Err> + Codec<T2, Compact = B::Compact, Error = Err> + Codec<T3, Compact = B::Compact, Error = Err> + Codec<T4, Compact = B::Compact, Error = Err> + Codec<T5, Compact = B::Compact, Error = Err> + Codec<T6, Compact = B::Compact, Error = Err> + Codec<T7, Compact = B::Compact, Error = Err> + Codec<T8, Compact = B::Compact, Error = Err> + Codec<T9, Compact = B::Compact, Error = Err> + Codec<T10, Compact = B::Compact, Error = Err>, <B::Codec as Codec<T2>>::Error: Into<<B::Codec as Codec<T1>>::Error>, <B::Codec as Codec<T3>>::Error: Into<<B::Codec as Codec<T1>>::Error>, <B::Codec as Codec<T4>>::Error: Into<<B::Codec as Codec<T1>>::Error>, <B::Codec as Codec<T5>>::Error: Into<<B::Codec as Codec<T1>>::Error>, <B::Codec as Codec<T6>>::Error: Into<<B::Codec as Codec<T1>>::Error>, <B::Codec as Codec<T7>>::Error: Into<<B::Codec as Codec<T1>>::Error>, <B::Codec as Codec<T8>>::Error: Into<<B::Codec as Codec<T1>>::Error>, <B::Codec as Codec<T9>>::Error: Into<<B::Codec as Codec<T1>>::Error>, <B::Codec as Codec<T10>>::Error: Into<<B::Codec as Codec<T1>>::Error>,

type Error = <<B as WireFormatBackend>::Codec as Codec<T1>>::Error

fn encode(self, codec: &B::Codec) -> Result<B::Compact, Self::Error>

fn decode(response: &B::Compact, codec: &B::Codec) -> Result<Self, Err>

impl<B, Err, T1, T2, T3, T4, T5, T6, T7, T8, T9> GraphCodec<B> for (T1, T2, T3, T4, T5, T6, T7, T8, T9)

where B: Backend + WireFormatBackend, B::Codec: Codec<T1, Compact = B::Compact, Error = Err> + Codec<Vec<B::Compact>, Compact = B::Compact, Error = Err> + Codec<T2, Compact = B::Compact, Error = Err> + Codec<T3, Compact = B::Compact, Error = Err> + Codec<T4, Compact = B::Compact, Error = Err> + Codec<T5, Compact = B::Compact, Error = Err> + Codec<T6, Compact = B::Compact, Error = Err> + Codec<T7, Compact = B::Compact, Error = Err> + Codec<T8, Compact = B::Compact, Error = Err> + Codec<T9, Compact = B::Compact, Error = Err>, <B::Codec as Codec<T2>>::Error: Into<<B::Codec as Codec<T1>>::Error>, <B::Codec as Codec<T3>>::Error: Into<<B::Codec as Codec<T1>>::Error>, <B::Codec as Codec<T4>>::Error: Into<<B::Codec as Codec<T1>>::Error>, <B::Codec as Codec<T5>>::Error: Into<<B::Codec as Codec<T1>>::Error>, <B::Codec as Codec<T6>>::Error: Into<<B::Codec as Codec<T1>>::Error>, <B::Codec as Codec<T7>>::Error: Into<<B::Codec as Codec<T1>>::Error>, <B::Codec as Codec<T8>>::Error: Into<<B::Codec as Codec<T1>>::Error>, <B::Codec as Codec<T9>>::Error: Into<<B::Codec as Codec<T1>>::Error>,

type Error = <<B as WireFormatBackend>::Codec as Codec<T1>>::Error

fn encode(self, codec: &B::Codec) -> Result<B::Compact, Self::Error>

fn decode(response: &B::Compact, codec: &B::Codec) -> Result<Self, Err>

impl<B, Err, T1, T2, T3, T4, T5, T6, T7, T8> GraphCodec<B> for (T1, T2, T3, T4, T5, T6, T7, T8)

where B: Backend + WireFormatBackend, B::Codec: Codec<T1, Compact = B::Compact, Error = Err> + Codec<Vec<B::Compact>, Compact = B::Compact, Error = Err> + Codec<T2, Compact = B::Compact, Error = Err> + Codec<T3, Compact = B::Compact, Error = Err> + Codec<T4, Compact = B::Compact, Error = Err> + Codec<T5, Compact = B::Compact, Error = Err> + Codec<T6, Compact = B::Compact, Error = Err> + Codec<T7, Compact = B::Compact, Error = Err> + Codec<T8, Compact = B::Compact, Error = Err>, <B::Codec as Codec<T2>>::Error: Into<<B::Codec as Codec<T1>>::Error>, <B::Codec as Codec<T3>>::Error: Into<<B::Codec as Codec<T1>>::Error>, <B::Codec as Codec<T4>>::Error: Into<<B::Codec as Codec<T1>>::Error>, <B::Codec as Codec<T5>>::Error: Into<<B::Codec as Codec<T1>>::Error>, <B::Codec as Codec<T6>>::Error: Into<<B::Codec as Codec<T1>>::Error>, <B::Codec as Codec<T7>>::Error: Into<<B::Codec as Codec<T1>>::Error>, <B::Codec as Codec<T8>>::Error: Into<<B::Codec as Codec<T1>>::Error>,

type Error = <<B as WireFormatBackend>::Codec as Codec<T1>>::Error

fn encode(self, codec: &B::Codec) -> Result<B::Compact, Self::Error>

fn decode(response: &B::Compact, codec: &B::Codec) -> Result<Self, Err>

impl<B, Err, T1, T2, T3, T4, T5, T6, T7> GraphCodec<B> for (T1, T2, T3, T4, T5, T6, T7)

where B: Backend + WireFormatBackend, B::Codec: Codec<T1, Compact = B::Compact, Error = Err> + Codec<Vec<B::Compact>, Compact = B::Compact, Error = Err> + Codec<T2, Compact = B::Compact, Error = Err> + Codec<T3, Compact = B::Compact, Error = Err> + Codec<T4, Compact = B::Compact, Error = Err> + Codec<T5, Compact = B::Compact, Error = Err> + Codec<T6, Compact = B::Compact, Error = Err> + Codec<T7, Compact = B::Compact, Error = Err>, <B::Codec as Codec<T2>>::Error: Into<<B::Codec as Codec<T1>>::Error>, <B::Codec as Codec<T3>>::Error: Into<<B::Codec as Codec<T1>>::Error>, <B::Codec as Codec<T4>>::Error: Into<<B::Codec as Codec<T1>>::Error>, <B::Codec as Codec<T5>>::Error: Into<<B::Codec as Codec<T1>>::Error>, <B::Codec as Codec<T6>>::Error: Into<<B::Codec as Codec<T1>>::Error>, <B::Codec as Codec<T7>>::Error: Into<<B::Codec as Codec<T1>>::Error>,

type Error = <<B as WireFormatBackend>::Codec as Codec<T1>>::Error

fn encode(self, codec: &B::Codec) -> Result<B::Compact, Self::Error>

fn decode(response: &B::Compact, codec: &B::Codec) -> Result<Self, Err>

impl<B, Err, T1, T2, T3, T4, T5, T6> GraphCodec<B> for (T1, T2, T3, T4, T5, T6)

where B: Backend + WireFormatBackend, B::Codec: Codec<T1, Compact = B::Compact, Error = Err> + Codec<Vec<B::Compact>, Compact = B::Compact, Error = Err> + Codec<T2, Compact = B::Compact, Error = Err> + Codec<T3, Compact = B::Compact, Error = Err> + Codec<T4, Compact = B::Compact, Error = Err> + Codec<T5, Compact = B::Compact, Error = Err> + Codec<T6, Compact = B::Compact, Error = Err>, <B::Codec as Codec<T2>>::Error: Into<<B::Codec as Codec<T1>>::Error>, <B::Codec as Codec<T3>>::Error: Into<<B::Codec as Codec<T1>>::Error>, <B::Codec as Codec<T4>>::Error: Into<<B::Codec as Codec<T1>>::Error>, <B::Codec as Codec<T5>>::Error: Into<<B::Codec as Codec<T1>>::Error>, <B::Codec as Codec<T6>>::Error: Into<<B::Codec as Codec<T1>>::Error>,

type Error = <<B as WireFormatBackend>::Codec as Codec<T1>>::Error

fn encode(self, codec: &B::Codec) -> Result<B::Compact, Self::Error>

fn decode(response: &B::Compact, codec: &B::Codec) -> Result<Self, Err>

impl<B, Err, T1, T2, T3, T4, T5> GraphCodec<B> for (T1, T2, T3, T4, T5)

where B: Backend + WireFormatBackend, B::Codec: Codec<T1, Compact = B::Compact, Error = Err> + Codec<Vec<B::Compact>, Compact = B::Compact, Error = Err> + Codec<T2, Compact = B::Compact, Error = Err> + Codec<T3, Compact = B::Compact, Error = Err> + Codec<T4, Compact = B::Compact, Error = Err> + Codec<T5, Compact = B::Compact, Error = Err>, <B::Codec as Codec<T2>>::Error: Into<<B::Codec as Codec<T1>>::Error>, <B::Codec as Codec<T3>>::Error: Into<<B::Codec as Codec<T1>>::Error>, <B::Codec as Codec<T4>>::Error: Into<<B::Codec as Codec<T1>>::Error>, <B::Codec as Codec<T5>>::Error: Into<<B::Codec as Codec<T1>>::Error>,

type Error = <<B as WireFormatBackend>::Codec as Codec<T1>>::Error

fn encode(self, codec: &B::Codec) -> Result<B::Compact, Self::Error>

fn decode(response: &B::Compact, codec: &B::Codec) -> Result<Self, Err>

impl<B, Err, T1, T2, T3, T4> GraphCodec<B> for (T1, T2, T3, T4)

where B: Backend + WireFormatBackend, B::Codec: Codec<T1, Compact = B::Compact, Error = Err> + Codec<Vec<B::Compact>, Compact = B::Compact, Error = Err> + Codec<T2, Compact = B::Compact, Error = Err> + Codec<T3, Compact = B::Compact, Error = Err> + Codec<T4, Compact = B::Compact, Error = Err>, <B::Codec as Codec<T2>>::Error: Into<<B::Codec as Codec<T1>>::Error>, <B::Codec as Codec<T3>>::Error: Into<<B::Codec as Codec<T1>>::Error>, <B::Codec as Codec<T4>>::Error: Into<<B::Codec as Codec<T1>>::Error>,

type Error = <<B as WireFormatBackend>::Codec as Codec<T1>>::Error

fn encode(self, codec: &B::Codec) -> Result<B::Compact, Self::Error>

fn decode(response: &B::Compact, codec: &B::Codec) -> Result<Self, Err>

impl<B, Err, T1, T2, T3> GraphCodec<B> for (T1, T2, T3)

where B: Backend + WireFormatBackend, B::Codec: Codec<T1, Compact = B::Compact, Error = Err> + Codec<Vec<B::Compact>, Compact = B::Compact, Error = Err> + Codec<T2, Compact = B::Compact, Error = Err> + Codec<T3, Compact = B::Compact, Error = Err>, <B::Codec as Codec<T2>>::Error: Into<<B::Codec as Codec<T1>>::Error>, <B::Codec as Codec<T3>>::Error: Into<<B::Codec as Codec<T1>>::Error>,

type Error = <<B as WireFormatBackend>::Codec as Codec<T1>>::Error

fn encode(self, codec: &B::Codec) -> Result<B::Compact, Self::Error>

fn decode(response: &B::Compact, codec: &B::Codec) -> Result<Self, Err>

impl<B, Err, T1, T2> GraphCodec<B> for (T1, T2)

where B: Backend + WireFormatBackend, B::Codec: Codec<T1, Compact = B::Compact, Error = Err> + Codec<Vec<B::Compact>, Compact = B::Compact, Error = Err> + Codec<T2, Compact = B::Compact, Error = Err>, <B::Codec as Codec<T2>>::Error: Into<<B::Codec as Codec<T1>>::Error>,

type Error = <<B as WireFormatBackend>::Codec as Codec<T1>>::Error

fn encode(self, codec: &B::Codec) -> Result<B::Compact, Self::Error>

fn decode(response: &B::Compact, codec: &B::Codec) -> Result<Self, Err>

impl<B, Err, T1> GraphCodec<B> for (T1,)

where B: Backend + WireFormatBackend, B::Codec: Codec<(T1,), Compact = B::Compact, Error = Err> + Codec<Vec<B::Compact>, Compact = B::Compact, Error = Err>,

type Error = Err

fn encode(self, codec: &B::Codec) -> Result<B::Compact, Self::Error>

fn decode(response: &B::Compact, codec: &B::Codec) -> Result<Self, Err>

impl<B, Err> GraphCodec<B> for &'static str

where B: Backend + WireFormatBackend, B::Codec: Codec<&'static str, Compact = B::Compact, Error = Err>,

type Error = Err

fn encode(self, codec: &B::Codec) -> Result<B::Compact, Self::Error>

fn decode(response: &B::Compact, codec: &B::Codec) -> Result<Self, Self::Error>

impl<B, Err> GraphCodec<B> for ()

where B: Backend + WireFormatBackend, B::Codec: Codec<(), Compact = B::Compact, Error = Err>,

type Error = Err

fn encode(self, codec: &B::Codec) -> Result<B::Compact, Self::Error>

fn decode(response: &B::Compact, codec: &B::Codec) -> Result<Self, Self::Error>

impl<B, Err> GraphCodec<B> for String

where B: Backend + WireFormatBackend, B::Codec: Codec<String, Compact = B::Compact, Error = Err>,

type Error = Err

fn encode(self, codec: &B::Codec) -> Result<B::Compact, Self::Error>

fn decode(response: &B::Compact, codec: &B::Codec) -> Result<Self, Self::Error>

impl<B, Err> GraphCodec<B> for bool

where B: Backend + WireFormatBackend, B::Codec: Codec<bool, Compact = B::Compact, Error = Err>,

type Error = Err

fn encode(self, codec: &B::Codec) -> Result<B::Compact, Self::Error>

fn decode(response: &B::Compact, codec: &B::Codec) -> Result<Self, Self::Error>

impl<B, Err> GraphCodec<B> for char

where B: Backend + WireFormatBackend, B::Codec: Codec<char, Compact = B::Compact, Error = Err>,

type Error = Err

fn encode(self, codec: &B::Codec) -> Result<B::Compact, Self::Error>

fn decode(response: &B::Compact, codec: &B::Codec) -> Result<Self, Self::Error>

impl<B, Err> GraphCodec<B> for f32

where B: Backend + WireFormatBackend, B::Codec: Codec<f32, Compact = B::Compact, Error = Err>,

type Error = Err

fn encode(self, codec: &B::Codec) -> Result<B::Compact, Self::Error>

fn decode(response: &B::Compact, codec: &B::Codec) -> Result<Self, Self::Error>

impl<B, Err> GraphCodec<B> for f64

where B: Backend + WireFormatBackend, B::Codec: Codec<f64, Compact = B::Compact, Error = Err>,

type Error = Err

fn encode(self, codec: &B::Codec) -> Result<B::Compact, Self::Error>

fn decode(response: &B::Compact, codec: &B::Codec) -> Result<Self, Self::Error>

impl<B, Err> GraphCodec<B> for i8

where B: Backend + WireFormatBackend, B::Codec: Codec<i8, Compact = B::Compact, Error = Err>,

type Error = Err

fn encode(self, codec: &B::Codec) -> Result<B::Compact, Self::Error>

fn decode(response: &B::Compact, codec: &B::Codec) -> Result<Self, Self::Error>

impl<B, Err> GraphCodec<B> for i16

where B: Backend + WireFormatBackend, B::Codec: Codec<i16, Compact = B::Compact, Error = Err>,

type Error = Err

fn encode(self, codec: &B::Codec) -> Result<B::Compact, Self::Error>

fn decode(response: &B::Compact, codec: &B::Codec) -> Result<Self, Self::Error>

impl<B, Err> GraphCodec<B> for i32

where B: Backend + WireFormatBackend, B::Codec: Codec<i32, Compact = B::Compact, Error = Err>,

type Error = Err

fn encode(self, codec: &B::Codec) -> Result<B::Compact, Self::Error>

fn decode(response: &B::Compact, codec: &B::Codec) -> Result<Self, Self::Error>

impl<B, Err> GraphCodec<B> for i64

where B: Backend + WireFormatBackend, B::Codec: Codec<i64, Compact = B::Compact, Error = Err>,

type Error = Err

fn encode(self, codec: &B::Codec) -> Result<B::Compact, Self::Error>

fn decode(response: &B::Compact, codec: &B::Codec) -> Result<Self, Self::Error>

impl<B, Err> GraphCodec<B> for i128

where B: Backend + WireFormatBackend, B::Codec: Codec<i128, Compact = B::Compact, Error = Err>,

type Error = Err

fn encode(self, codec: &B::Codec) -> Result<B::Compact, Self::Error>

fn decode(response: &B::Compact, codec: &B::Codec) -> Result<Self, Self::Error>

impl<B, Err> GraphCodec<B> for isize

where B: Backend + WireFormatBackend, B::Codec: Codec<isize, Compact = B::Compact, Error = Err>,

type Error = Err

fn encode(self, codec: &B::Codec) -> Result<B::Compact, Self::Error>

fn decode(response: &B::Compact, codec: &B::Codec) -> Result<Self, Self::Error>

impl<B, Err> GraphCodec<B> for u8

where B: Backend + WireFormatBackend, B::Codec: Codec<u8, Compact = B::Compact, Error = Err>,

type Error = Err

fn encode(self, codec: &B::Codec) -> Result<B::Compact, Self::Error>

fn decode(response: &B::Compact, codec: &B::Codec) -> Result<Self, Self::Error>

impl<B, Err> GraphCodec<B> for u16

where B: Backend + WireFormatBackend, B::Codec: Codec<u16, Compact = B::Compact, Error = Err>,

type Error = Err

fn encode(self, codec: &B::Codec) -> Result<B::Compact, Self::Error>

fn decode(response: &B::Compact, codec: &B::Codec) -> Result<Self, Self::Error>

impl<B, Err> GraphCodec<B> for u32

where B: Backend + WireFormatBackend, B::Codec: Codec<u32, Compact = B::Compact, Error = Err>,

type Error = Err

fn encode(self, codec: &B::Codec) -> Result<B::Compact, Self::Error>

fn decode(response: &B::Compact, codec: &B::Codec) -> Result<Self, Self::Error>

impl<B, Err> GraphCodec<B> for u64

where B: Backend + WireFormatBackend, B::Codec: Codec<u64, Compact = B::Compact, Error = Err>,

type Error = Err

fn encode(self, codec: &B::Codec) -> Result<B::Compact, Self::Error>

fn decode(response: &B::Compact, codec: &B::Codec) -> Result<Self, Self::Error>

impl<B, Err> GraphCodec<B> for u128

where B: Backend + WireFormatBackend, B::Codec: Codec<u128, Compact = B::Compact, Error = Err>,

type Error = Err

fn encode(self, codec: &B::Codec) -> Result<B::Compact, Self::Error>

fn decode(response: &B::Compact, codec: &B::Codec) -> Result<Self, Self::Error>

impl<B, Err> GraphCodec<B> for usize

where B: Backend + WireFormatBackend, B::Codec: Codec<usize, Compact = B::Compact, Error = Err>,

type Error = Err

fn encode(self, codec: &B::Codec) -> Result<B::Compact, Self::Error>

fn decode(response: &B::Compact, codec: &B::Codec) -> Result<Self, Self::Error>

impl<B, T, E, Err> GraphCodec<B> for Result<T, E>

where B: Backend + WireFormatBackend, B::Codec: Codec<Self, Compact = B::Compact, Error = Err>,

type Error = Err

fn encode(self, codec: &B::Codec) -> Result<B::Compact, Self::Error>

fn decode(response: &B::Compact, codec: &B::Codec) -> Result<Self, Self::Error>

impl<B, T, Err> GraphCodec<B> for Option<T>

where B: Backend + WireFormatBackend, B::Codec: Codec<Self, Compact = B::Compact, Error = Err>,

type Error = Err

fn encode(self, codec: &B::Codec) -> Result<B::Compact, Self::Error>

fn decode(response: &B::Compact, codec: &B::Codec) -> Result<Self, Self::Error>

impl<B, T, Err> GraphCodec<B> for Vec<T>

where B: Backend + WireFormatBackend, B::Codec: Codec<T, Compact = B::Compact, Error = Err> + Codec<Vec<B::Compact>, Compact = B::Compact, Error = Err> + Codec<Self, Compact = B::Compact, Error = Err>,

type Error = Err

fn encode( self, codec: &B::Codec, ) -> Result<B::Compact, <B::Codec as Codec<Self>>::Error>

fn decode(response: &B::Compact, codec: &B::Codec) -> Result<Self, Err>

Implementors