Trait snarkvm_console_types_string::FromBytes

pub trait FromBytes {
    fn read_le<R>(reader: R) -> Result<Self, Error>
    where
        R: Read;

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

Required Methods

fn read_le<R>(reader: R) -> Result<Self, Error> where
    R: Read, 

Reads Self from reader as little-endian bytes.

Provided Methods

fn from_bytes_le(bytes: &[u8]) -> Result<Self, Error>

Returns Self from a byte array in little-endian order.

Implementations on Foreign Types

impl<P> FromBytes for Affine<P> where
    P: ShortWeierstrassParameters, 

fn read_le<R>(reader: R) -> Result<Affine<P>, Error> where
    R: Read, 

impl<P> FromBytes for Projective<P> where
    P: ShortWeierstrassParameters, 

fn read_le<R>(reader: R) -> Result<Projective<P>, Error> where
    R: Read, 

impl<P> FromBytes for G1Prepared<P> where
    P: Bls12Parameters, 

fn read_le<R>(reader: R) -> Result<G1Prepared<P>, Error> where
    R: Read, 

impl<P> FromBytes for G2Prepared<P> where
    P: Bls12Parameters, 

fn read_le<R>(reader: R) -> Result<G2Prepared<P>, Error> where
    R: Read, 

impl<P> FromBytes for Projective<P> where
    P: TwistedEdwardsParameters, 

fn read_le<R>(reader: R) -> Result<Projective<P>, Error> where
    R: Read, 

impl<P> FromBytes for Affine<P> where
    P: TwistedEdwardsParameters, 

fn read_le<R>(reader: R) -> Result<Affine<P>, Error> where
    R: Read, 

impl<P> FromBytes for Fp6<P> where
    P: Fp6Parameters, 

fn read_le<R>(reader: R) -> Result<Fp6<P>, Error> where
    R: Read, 

impl<P> FromBytes for Fp384<P> where
    P: Fp384Parameters, 

fn read_le<R>(reader: R) -> Result<Fp384<P>, Error> where
    R: Read, 

impl<P> FromBytes for Fp256<P> where
    P: Fp256Parameters, 

fn read_le<R>(reader: R) -> Result<Fp256<P>, Error> where
    R: Read, 

impl<P> FromBytes for Fp2<P> where
    P: Fp2Parameters, 

fn read_le<R>(reader: R) -> Result<Fp2<P>, Error> where
    R: Read, 

impl<P> FromBytes for Fp12<P> where
    P: Fp12Parameters, 

fn read_le<R>(reader: R) -> Result<Fp12<P>, Error> where
    R: Read, 

impl FromBytes for u8

fn read_le<R>(reader: R) -> Result<u8, Error> where
    R: Read, 

impl FromBytes for u16

fn read_le<R>(reader: R) -> Result<u16, Error> where
    R: Read, 

impl<const N: usize> FromBytes for [u8; N]

fn read_le<R>(reader: R) -> Result<[u8; N], Error> where
    R: Read, 

impl FromBytes for u64

fn read_le<R>(reader: R) -> Result<u64, Error> where
    R: Read, 

impl<L, R> FromBytes for (L, R) where
    L: FromBytes,
    R: FromBytes, 

fn read_le<Reader>(reader: Reader) -> Result<(L, R), Error> where
    Reader: Read, 

impl<const N: usize> FromBytes for [u16; N]

fn read_le<R>(reader: R) -> Result<[u16; N], Error> where
    R: Read, 

impl FromBytes for i32

fn read_le<R>(reader: R) -> Result<i32, Error> where
    R: Read, 

impl FromBytes for i128

fn read_le<R>(reader: R) -> Result<i128, Error> where
    R: Read, 

impl FromBytes for bool

fn read_le<R>(reader: R) -> Result<bool, Error> where
    R: Read, 

impl FromBytes for i64

fn read_le<R>(reader: R) -> Result<i64, Error> where
    R: Read, 

impl FromBytes for u128

fn read_le<R>(reader: R) -> Result<u128, Error> where
    R: Read, 

impl FromBytes for i8

fn read_le<R>(reader: R) -> Result<i8, Error> where
    R: Read, 

impl FromBytes for ()

fn read_le<R>(_bytes: R) -> Result<(), Error> where
    R: Read, 

impl<const N: usize> FromBytes for [u64; N]

fn read_le<R>(reader: R) -> Result<[u64; N], Error> where
    R: Read, 

impl FromBytes for u32

fn read_le<R>(reader: R) -> Result<u32, Error> where
    R: Read, 

impl FromBytes for i16

fn read_le<R>(reader: R) -> Result<i16, Error> where
    R: Read, 

impl<const N: usize> FromBytes for [u32; N]

fn read_le<R>(reader: R) -> Result<[u32; N], Error> where
    R: Read, 

Implementors

impl FromBytes for BigInteger256

impl FromBytes for BigInteger384

impl<E> FromBytes for Boolean<E> where
    E: Environment, 

impl<E> FromBytes for Field<E> where
    E: Environment, 

impl<E, I> FromBytes for Integer<E, I> where
    E: Environment,
    I: IntegerType, 

impl<E: Environment> FromBytes for StringType<E>