Trait switchboard_aggregator::AnchorDeserialize

pub trait AnchorDeserialize {
    fn deserialize(buf: &mut &[u8]) -> Result<Self, Error>;

    fn try_from_slice(v: &[u8]) -> Result<Self, Error> { ... }
}

A data-structure that can be de-serialized from binary format by NBOR.

Required methods

fn deserialize(buf: &mut &[u8]) -> Result<Self, Error>

Deserializes this instance from a given slice of bytes. Updates the buffer to point at the remaining bytes.

Provided methods

fn try_from_slice(v: &[u8]) -> Result<Self, Error>

Deserialize this instance from a slice of bytes.

Implementations on Foreign Types

impl BorshDeserialize for StakeState

pub fn deserialize(buf: &mut &[u8]) -> Result<StakeState, Error>

impl BorshDeserialize for Hash

pub fn deserialize(buf: &mut &[u8]) -> Result<Hash, Error>

impl BorshDeserialize for Stake where
    Delegation: BorshDeserialize,
    u64: BorshDeserialize, 

pub fn deserialize(buf: &mut &[u8]) -> Result<Stake, Error>

impl BorshDeserialize for Secp256k1Pubkey

pub fn deserialize(buf: &mut &[u8]) -> Result<Secp256k1Pubkey, Error>

impl BorshDeserialize for Lockup where
    i64: BorshDeserialize,
    u64: BorshDeserialize,
    Pubkey: BorshDeserialize, 

pub fn deserialize(buf: &mut &[u8]) -> Result<Lockup, Error>

impl BorshDeserialize for Meta where
    u64: BorshDeserialize,
    Authorized: BorshDeserialize,
    Lockup: BorshDeserialize, 

pub fn deserialize(buf: &mut &[u8]) -> Result<Meta, Error>

impl BorshDeserialize for Authorized where
    Pubkey: BorshDeserialize, 

pub fn deserialize(buf: &mut &[u8]) -> Result<Authorized, Error>

impl BorshDeserialize for Hash

pub fn deserialize(buf: &mut &[u8]) -> Result<Hash, Error>

impl BorshDeserialize for Delegation where
    Pubkey: BorshDeserialize,
    u64: BorshDeserialize,
    f64: BorshDeserialize, 

pub fn deserialize(buf: &mut &[u8]) -> Result<Delegation, Error>

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> BorshDeserialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) where
    T0: BorshDeserialize,
    T1: BorshDeserialize,
    T2: BorshDeserialize,
    T3: BorshDeserialize,
    T4: BorshDeserialize,
    T5: BorshDeserialize,
    T6: BorshDeserialize,
    T7: BorshDeserialize,
    T8: BorshDeserialize,
    T9: BorshDeserialize,
    T10: BorshDeserialize, 

pub fn deserialize(
    buf: &mut &[u8]
) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), Error>

impl<T> BorshDeserialize for Option<T> where
    T: BorshDeserialize, 

pub fn deserialize(buf: &mut &[u8]) -> Result<Option<T>, Error>

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> BorshDeserialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) where
    T0: BorshDeserialize,
    T1: BorshDeserialize,
    T2: BorshDeserialize,
    T3: BorshDeserialize,
    T4: BorshDeserialize,
    T5: BorshDeserialize,
    T6: BorshDeserialize,
    T7: BorshDeserialize,
    T8: BorshDeserialize,
    T9: BorshDeserialize,
    T10: BorshDeserialize,
    T11: BorshDeserialize, 

pub fn deserialize(
    buf: &mut &[u8]
) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), Error>

impl<T0, T1, T2, T3, T4, T5, T6> BorshDeserialize for (T0, T1, T2, T3, T4, T5, T6) where
    T0: BorshDeserialize,
    T1: BorshDeserialize,
    T2: BorshDeserialize,
    T3: BorshDeserialize,
    T4: BorshDeserialize,
    T5: BorshDeserialize,
    T6: BorshDeserialize, 

pub fn deserialize(
    buf: &mut &[u8]
) -> Result<(T0, T1, T2, T3, T4, T5, T6), Error>

impl<T0, T1, T2, T3, T4, T5> BorshDeserialize for (T0, T1, T2, T3, T4, T5) where
    T0: BorshDeserialize,
    T1: BorshDeserialize,
    T2: BorshDeserialize,
    T3: BorshDeserialize,
    T4: BorshDeserialize,
    T5: BorshDeserialize, 

pub fn deserialize(buf: &mut &[u8]) -> Result<(T0, T1, T2, T3, T4, T5), Error>

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> BorshDeserialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) where
    T0: BorshDeserialize,
    T1: BorshDeserialize,
    T2: BorshDeserialize,
    T3: BorshDeserialize,
    T4: BorshDeserialize,
    T5: BorshDeserialize,
    T6: BorshDeserialize,
    T7: BorshDeserialize,
    T8: BorshDeserialize,
    T9: BorshDeserialize, 

pub fn deserialize(
    buf: &mut &[u8]
) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9), Error>

impl<T> BorshDeserialize for PhantomData<T> where
    T: ?Sized, 

pub fn deserialize(&mut &[u8]) -> Result<PhantomData<T>, Error>

impl BorshDeserialize for u32

pub fn deserialize(buf: &mut &[u8]) -> Result<u32, Error>

impl BorshDeserialize for Ipv6Addr

pub fn deserialize(buf: &mut &[u8]) -> Result<Ipv6Addr, Error>

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> BorshDeserialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) where
    T0: BorshDeserialize,
    T1: BorshDeserialize,
    T2: BorshDeserialize,
    T3: BorshDeserialize,
    T4: BorshDeserialize,
    T5: BorshDeserialize,
    T6: BorshDeserialize,
    T7: BorshDeserialize,
    T8: BorshDeserialize,
    T9: BorshDeserialize,
    T10: BorshDeserialize,
    T11: BorshDeserialize,
    T12: BorshDeserialize,
    T13: BorshDeserialize, 

pub fn deserialize(
    buf: &mut &[u8]
) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), Error>

impl<T0, T1, T2, T3, T4, T5, T6, T7> BorshDeserialize for (T0, T1, T2, T3, T4, T5, T6, T7) where
    T0: BorshDeserialize,
    T1: BorshDeserialize,
    T2: BorshDeserialize,
    T3: BorshDeserialize,
    T4: BorshDeserialize,
    T5: BorshDeserialize,
    T6: BorshDeserialize,
    T7: BorshDeserialize, 

pub fn deserialize(
    buf: &mut &[u8]
) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7), Error>

impl BorshDeserialize for u8

pub fn deserialize(buf: &mut &[u8]) -> Result<u8, Error>

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> BorshDeserialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8) where
    T0: BorshDeserialize,
    T1: BorshDeserialize,
    T2: BorshDeserialize,
    T3: BorshDeserialize,
    T4: BorshDeserialize,
    T5: BorshDeserialize,
    T6: BorshDeserialize,
    T7: BorshDeserialize,
    T8: BorshDeserialize, 

pub fn deserialize(
    buf: &mut &[u8]
) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8), Error>

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> BorshDeserialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) where
    T0: BorshDeserialize,
    T1: BorshDeserialize,
    T2: BorshDeserialize,
    T3: BorshDeserialize,
    T4: BorshDeserialize,
    T5: BorshDeserialize,
    T6: BorshDeserialize,
    T7: BorshDeserialize,
    T8: BorshDeserialize,
    T9: BorshDeserialize,
    T10: BorshDeserialize,
    T11: BorshDeserialize,
    T12: BorshDeserialize,
    T13: BorshDeserialize,
    T14: BorshDeserialize, 

pub fn deserialize(
    buf: &mut &[u8]
) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), Error>

impl BorshDeserialize for u128

pub fn deserialize(buf: &mut &[u8]) -> Result<u128, Error>

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> BorshDeserialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) where
    T0: BorshDeserialize,
    T1: BorshDeserialize,
    T2: BorshDeserialize,
    T3: BorshDeserialize,
    T4: BorshDeserialize,
    T5: BorshDeserialize,
    T6: BorshDeserialize,
    T7: BorshDeserialize,
    T8: BorshDeserialize,
    T9: BorshDeserialize,
    T10: BorshDeserialize,
    T11: BorshDeserialize,
    T12: BorshDeserialize,
    T13: BorshDeserialize,
    T14: BorshDeserialize,
    T15: BorshDeserialize,
    T16: BorshDeserialize, 

pub fn deserialize(
    buf: &mut &[u8]
) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), Error>

impl BorshDeserialize for usize

pub fn deserialize(buf: &mut &[u8]) -> Result<usize, Error>

impl BorshDeserialize for SocketAddr

pub fn deserialize(buf: &mut &[u8]) -> Result<SocketAddr, Error>

impl BorshDeserialize for i32

pub fn deserialize(buf: &mut &[u8]) -> Result<i32, Error>

impl BorshDeserialize for f32

pub fn deserialize(buf: &mut &[u8]) -> Result<f32, Error>

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> BorshDeserialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) where
    T0: BorshDeserialize,
    T1: BorshDeserialize,
    T2: BorshDeserialize,
    T3: BorshDeserialize,
    T4: BorshDeserialize,
    T5: BorshDeserialize,
    T6: BorshDeserialize,
    T7: BorshDeserialize,
    T8: BorshDeserialize,
    T9: BorshDeserialize,
    T10: BorshDeserialize,
    T11: BorshDeserialize,
    T12: BorshDeserialize,
    T13: BorshDeserialize,
    T14: BorshDeserialize,
    T15: BorshDeserialize, 

pub fn deserialize(
    buf: &mut &[u8]
) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), Error>

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> BorshDeserialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) where
    T0: BorshDeserialize,
    T1: BorshDeserialize,
    T2: BorshDeserialize,
    T3: BorshDeserialize,
    T4: BorshDeserialize,
    T5: BorshDeserialize,
    T6: BorshDeserialize,
    T7: BorshDeserialize,
    T8: BorshDeserialize,
    T9: BorshDeserialize,
    T10: BorshDeserialize,
    T11: BorshDeserialize,
    T12: BorshDeserialize,
    T13: BorshDeserialize,
    T14: BorshDeserialize,
    T15: BorshDeserialize,
    T16: BorshDeserialize,
    T17: BorshDeserialize,
    T18: BorshDeserialize,
    T19: BorshDeserialize, 

pub fn deserialize(
    buf: &mut &[u8]
) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19), Error>

impl<T0, T1> BorshDeserialize for (T0, T1) where
    T0: BorshDeserialize,
    T1: BorshDeserialize, 

pub fn deserialize(buf: &mut &[u8]) -> Result<(T0, T1), Error>

impl<T0, T1, T2, T3, T4> BorshDeserialize for (T0, T1, T2, T3, T4) where
    T0: BorshDeserialize,
    T1: BorshDeserialize,
    T2: BorshDeserialize,
    T3: BorshDeserialize,
    T4: BorshDeserialize, 

pub fn deserialize(buf: &mut &[u8]) -> Result<(T0, T1, T2, T3, T4), Error>

impl<T0, T1, T2> BorshDeserialize for (T0, T1, T2) where
    T0: BorshDeserialize,
    T1: BorshDeserialize,
    T2: BorshDeserialize, 

pub fn deserialize(buf: &mut &[u8]) -> Result<(T0, T1, T2), Error>

impl BorshDeserialize for f64

pub fn deserialize(buf: &mut &[u8]) -> Result<f64, Error>

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> BorshDeserialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) where
    T0: BorshDeserialize,
    T1: BorshDeserialize,
    T2: BorshDeserialize,
    T3: BorshDeserialize,
    T4: BorshDeserialize,
    T5: BorshDeserialize,
    T6: BorshDeserialize,
    T7: BorshDeserialize,
    T8: BorshDeserialize,
    T9: BorshDeserialize,
    T10: BorshDeserialize,
    T11: BorshDeserialize,
    T12: BorshDeserialize,
    T13: BorshDeserialize,
    T14: BorshDeserialize,
    T15: BorshDeserialize,
    T16: BorshDeserialize,
    T17: BorshDeserialize, 

pub fn deserialize(
    buf: &mut &[u8]
) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17), Error>

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> BorshDeserialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) where
    T0: BorshDeserialize,
    T1: BorshDeserialize,
    T2: BorshDeserialize,
    T3: BorshDeserialize,
    T4: BorshDeserialize,
    T5: BorshDeserialize,
    T6: BorshDeserialize,
    T7: BorshDeserialize,
    T8: BorshDeserialize,
    T9: BorshDeserialize,
    T10: BorshDeserialize,
    T11: BorshDeserialize,
    T12: BorshDeserialize, 

pub fn deserialize(
    buf: &mut &[u8]
) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), Error>

impl BorshDeserialize for ()

pub fn deserialize(_buf: &mut &[u8]) -> Result<(), Error>

impl BorshDeserialize for u16

pub fn deserialize(buf: &mut &[u8]) -> Result<u16, Error>

impl BorshDeserialize for bool

pub fn deserialize(buf: &mut &[u8]) -> Result<bool, Error>

impl<T0, T1, T2, T3> BorshDeserialize for (T0, T1, T2, T3) where
    T0: BorshDeserialize,
    T1: BorshDeserialize,
    T2: BorshDeserialize,
    T3: BorshDeserialize, 

pub fn deserialize(buf: &mut &[u8]) -> Result<(T0, T1, T2, T3), Error>

impl BorshDeserialize for i8

pub fn deserialize(buf: &mut &[u8]) -> Result<i8, Error>

impl<T, E> BorshDeserialize for Result<T, E> where
    T: BorshDeserialize,
    E: BorshDeserialize, 

pub fn deserialize(buf: &mut &[u8]) -> Result<Result<T, E>, Error>

impl BorshDeserialize for i16

pub fn deserialize(buf: &mut &[u8]) -> Result<i16, Error>

impl BorshDeserialize for SocketAddrV6

pub fn deserialize(buf: &mut &[u8]) -> Result<SocketAddrV6, Error>

impl BorshDeserialize for i128

pub fn deserialize(buf: &mut &[u8]) -> Result<i128, Error>

impl BorshDeserialize for u64

pub fn deserialize(buf: &mut &[u8]) -> Result<u64, Error>

impl BorshDeserialize for i64

pub fn deserialize(buf: &mut &[u8]) -> Result<i64, Error>

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> BorshDeserialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) where
    T0: BorshDeserialize,
    T1: BorshDeserialize,
    T2: BorshDeserialize,
    T3: BorshDeserialize,
    T4: BorshDeserialize,
    T5: BorshDeserialize,
    T6: BorshDeserialize,
    T7: BorshDeserialize,
    T8: BorshDeserialize,
    T9: BorshDeserialize,
    T10: BorshDeserialize,
    T11: BorshDeserialize,
    T12: BorshDeserialize,
    T13: BorshDeserialize,
    T14: BorshDeserialize,
    T15: BorshDeserialize,
    T16: BorshDeserialize,
    T17: BorshDeserialize,
    T18: BorshDeserialize, 

pub fn deserialize(
    buf: &mut &[u8]
) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18), Error>

impl<T, const N: usize> BorshDeserialize for [T; N] where
    T: BorshDeserialize + Default + Copy, 

pub fn deserialize(buf: &mut &[u8]) -> Result<[T; N], Error>

impl BorshDeserialize for SocketAddrV4

pub fn deserialize(buf: &mut &[u8]) -> Result<SocketAddrV4, Error>

impl BorshDeserialize for Ipv4Addr

pub fn deserialize(buf: &mut &[u8]) -> Result<Ipv4Addr, Error>

Implementors

impl BorshDeserialize for Definition where
    u32: BorshDeserialize,
    String: BorshDeserialize,
    Vec<String, Global>: BorshDeserialize,
    Vec<(String, String), Global>: BorshDeserialize,
    Fields: BorshDeserialize, 

impl BorshDeserialize for Fields where
    Vec<(String, String), Global>: BorshDeserialize,
    Vec<String, Global>: BorshDeserialize, 

impl BorshDeserialize for String

impl BorshDeserialize for BorshSchemaContainer where
    String: BorshDeserialize,
    HashMap<String, Definition, RandomState>: BorshDeserialize, 

impl BorshDeserialize for Pubkey

impl BorshDeserialize for AggregatorAccountData where
    [u8; 32]: BorshDeserialize,
    [u8; 128]: BorshDeserialize,
    Pubkey: BorshDeserialize,
    Pubkey: BorshDeserialize,
    u32: BorshDeserialize,
    u32: BorshDeserialize,
    u32: BorshDeserialize,
    u32: BorshDeserialize,
    i64: BorshDeserialize,
    SwitchboardDecimal: BorshDeserialize,
    i64: BorshDeserialize,
    i64: BorshDeserialize,
    u64: BorshDeserialize,
    i64: BorshDeserialize,
    bool: BorshDeserialize,
    [u8; 32]: BorshDeserialize,
    AggregatorRound: BorshDeserialize,
    AggregatorRound: BorshDeserialize,
    [Pubkey; 16]: BorshDeserialize,
    [Hash; 16]: BorshDeserialize,
    u32: BorshDeserialize,
    [u8; 32]: BorshDeserialize,
    Pubkey: BorshDeserialize,
    [u8; 224]: BorshDeserialize, 

impl BorshDeserialize for AggregatorRound where
    u32: BorshDeserialize,
    u32: BorshDeserialize,
    bool: BorshDeserialize,
    u64: BorshDeserialize,
    i64: BorshDeserialize,
    SwitchboardDecimal: BorshDeserialize,
    SwitchboardDecimal: BorshDeserialize,
    SwitchboardDecimal: BorshDeserialize,
    SwitchboardDecimal: BorshDeserialize,
    [Pubkey; 16]: BorshDeserialize,
    [SwitchboardDecimal; 16]: BorshDeserialize,
    [i64; 16]: BorshDeserialize,
    [bool; 16]: BorshDeserialize,
    [bool; 16]: BorshDeserialize, 

impl BorshDeserialize for switchboard_aggregator::structs::common::Hash where
    [u8; 32]: BorshDeserialize, 

impl BorshDeserialize for SwitchboardDecimal where
    i128: BorshDeserialize,
    u32: BorshDeserialize, 

impl<'_, T> BorshDeserialize for Cow<'_, T> where
    T: ToOwned + ?Sized,
    <T as ToOwned>::Owned: BorshDeserialize, 

impl<K, V> BorshDeserialize for BTreeMap<K, V> where
    K: BorshDeserialize + Ord + Hash,
    V: BorshDeserialize, 

impl<K, V, H> BorshDeserialize for HashMap<K, V, H> where
    K: BorshDeserialize + Eq + Hash,
    V: BorshDeserialize,
    H: BuildHasher + Default, 

impl<T> BorshDeserialize for BTreeSet<T> where
    T: BorshDeserialize + Ord, 

impl<T> BorshDeserialize for BinaryHeap<T> where
    T: BorshDeserialize + Ord, 

impl<T> BorshDeserialize for LinkedList<T> where
    T: BorshDeserialize, 

impl<T> BorshDeserialize for VecDeque<T, Global> where
    T: BorshDeserialize, 

impl<T> BorshDeserialize for Vec<T, Global> where
    T: BorshDeserialize, 

impl<T, H> BorshDeserialize for HashSet<T, H> where
    T: BorshDeserialize + Eq + Hash,
    H: BuildHasher + Default, 

impl<T, U> BorshDeserialize for Box<T, Global> where
    U: Into<Box<T, Global>> + Borrow<T>,
    T: ToOwned<Owned = U> + ?Sized,
    <T as ToOwned>::Owned: BorshDeserialize,