Struct sbp::Le

pub struct Le;

A parser for parsing unsigned and signed integers, stored in little-endian.

Note that this type is frequently used in the sbp macro, in that case it's an intermediate type, since there normally is no type argument here.

Trait Implementations

impl<'a> Parser<'a, u8> for Le

type Error = BasicOutOfSpaceError

The error that the parsing can result in.

type Meta = ()

An arbitrary additional value provided, this will usually be (). When const generics comes, this probably won't be required.

fn parse(_: Self::Meta, bytes: &'a [u8]) -> Result<(u8, usize), Self::Error>

Parse bytes. The bytes may or may not have an adequately size for successful parsing, this should be taken into account when implementing a parser.

impl<'a> Parser<'a, u16> for Le

type Error = BasicOutOfSpaceError

The error that the parsing can result in.

type Meta = ()

An arbitrary additional value provided, this will usually be (). When const generics comes, this probably won't be required.

fn parse(_: Self::Meta, bytes: &'a [u8]) -> Result<(u16, usize), Self::Error>

Parse bytes. The bytes may or may not have an adequately size for successful parsing, this should be taken into account when implementing a parser.

impl<'a> Parser<'a, u32> for Le

type Error = BasicOutOfSpaceError

The error that the parsing can result in.

type Meta = ()

An arbitrary additional value provided, this will usually be (). When const generics comes, this probably won't be required.

fn parse(_: Self::Meta, bytes: &'a [u8]) -> Result<(u32, usize), Self::Error>

Parse bytes. The bytes may or may not have an adequately size for successful parsing, this should be taken into account when implementing a parser.

impl<'a> Parser<'a, u64> for Le

type Error = BasicOutOfSpaceError

The error that the parsing can result in.

type Meta = ()

An arbitrary additional value provided, this will usually be (). When const generics comes, this probably won't be required.

fn parse(_: Self::Meta, bytes: &'a [u8]) -> Result<(u64, usize), Self::Error>

Parse bytes. The bytes may or may not have an adequately size for successful parsing, this should be taken into account when implementing a parser.

impl<'a> Parser<'a, u128> for Le

type Error = BasicOutOfSpaceError

The error that the parsing can result in.

type Meta = ()

An arbitrary additional value provided, this will usually be (). When const generics comes, this probably won't be required.

fn parse(_: Self::Meta, bytes: &'a [u8]) -> Result<(u128, usize), Self::Error>

Parse bytes. The bytes may or may not have an adequately size for successful parsing, this should be taken into account when implementing a parser.

impl<'a> Parser<'a, i8> for Le

type Error = BasicOutOfSpaceError

The error that the parsing can result in.

type Meta = ()

An arbitrary additional value provided, this will usually be (). When const generics comes, this probably won't be required.

fn parse(_: Self::Meta, bytes: &'a [u8]) -> Result<(i8, usize), Self::Error>

Parse bytes. The bytes may or may not have an adequately size for successful parsing, this should be taken into account when implementing a parser.

impl<'a> Parser<'a, i16> for Le

type Error = BasicOutOfSpaceError

The error that the parsing can result in.

type Meta = ()

An arbitrary additional value provided, this will usually be (). When const generics comes, this probably won't be required.

fn parse(_: Self::Meta, bytes: &'a [u8]) -> Result<(i16, usize), Self::Error>

Parse bytes. The bytes may or may not have an adequately size for successful parsing, this should be taken into account when implementing a parser.

impl<'a> Parser<'a, i32> for Le

type Error = BasicOutOfSpaceError

The error that the parsing can result in.

type Meta = ()

An arbitrary additional value provided, this will usually be (). When const generics comes, this probably won't be required.

fn parse(_: Self::Meta, bytes: &'a [u8]) -> Result<(i32, usize), Self::Error>

Parse bytes. The bytes may or may not have an adequately size for successful parsing, this should be taken into account when implementing a parser.

impl<'a> Parser<'a, i64> for Le

type Error = BasicOutOfSpaceError

The error that the parsing can result in.

type Meta = ()

An arbitrary additional value provided, this will usually be (). When const generics comes, this probably won't be required.

fn parse(_: Self::Meta, bytes: &'a [u8]) -> Result<(i64, usize), Self::Error>

Parse bytes. The bytes may or may not have an adequately size for successful parsing, this should be taken into account when implementing a parser.

impl<'a> Parser<'a, i128> for Le

type Error = BasicOutOfSpaceError

The error that the parsing can result in.

type Meta = ()

An arbitrary additional value provided, this will usually be (). When const generics comes, this probably won't be required.

fn parse(_: Self::Meta, bytes: &'a [u8]) -> Result<(i128, usize), Self::Error>

Parse bytes. The bytes may or may not have an adequately size for successful parsing, this should be taken into account when implementing a parser.

impl<'a> Serializer<'a, u8> for Le

type Error = BasicOutOfSpaceError

The error that may occur when serializing.

type Meta = ()

An extra value provided, currently only meant and used for Take.

fn serialize(
    data: &u8,
    _: Self::Meta,
    bytes: &'a mut [u8]
) -> Result<usize, Self::Error>

Serialize a type into raw bytes.

impl<'a> Serializer<'a, u16> for Le

type Error = BasicOutOfSpaceError

The error that may occur when serializing.

type Meta = ()

An extra value provided, currently only meant and used for Take.

fn serialize(
    data: &u16,
    _: Self::Meta,
    bytes: &'a mut [u8]
) -> Result<usize, Self::Error>

Serialize a type into raw bytes.

impl<'a> Serializer<'a, u32> for Le

type Error = BasicOutOfSpaceError

The error that may occur when serializing.

type Meta = ()

An extra value provided, currently only meant and used for Take.

fn serialize(
    data: &u32,
    _: Self::Meta,
    bytes: &'a mut [u8]
) -> Result<usize, Self::Error>

Serialize a type into raw bytes.

impl<'a> Serializer<'a, u64> for Le

type Error = BasicOutOfSpaceError

The error that may occur when serializing.

type Meta = ()

An extra value provided, currently only meant and used for Take.

fn serialize(
    data: &u64,
    _: Self::Meta,
    bytes: &'a mut [u8]
) -> Result<usize, Self::Error>

Serialize a type into raw bytes.

impl<'a> Serializer<'a, u128> for Le

type Error = BasicOutOfSpaceError

The error that may occur when serializing.

type Meta = ()

An extra value provided, currently only meant and used for Take.

fn serialize(
    data: &u128,
    _: Self::Meta,
    bytes: &'a mut [u8]
) -> Result<usize, Self::Error>

Serialize a type into raw bytes.

impl<'a> Serializer<'a, i8> for Le

type Error = BasicOutOfSpaceError

The error that may occur when serializing.

type Meta = ()

An extra value provided, currently only meant and used for Take.

fn serialize(
    data: &i8,
    _: Self::Meta,
    bytes: &'a mut [u8]
) -> Result<usize, Self::Error>

Serialize a type into raw bytes.

impl<'a> Serializer<'a, i16> for Le

type Error = BasicOutOfSpaceError

The error that may occur when serializing.

type Meta = ()

An extra value provided, currently only meant and used for Take.

fn serialize(
    data: &i16,
    _: Self::Meta,
    bytes: &'a mut [u8]
) -> Result<usize, Self::Error>

Serialize a type into raw bytes.

impl<'a> Serializer<'a, i32> for Le

type Error = BasicOutOfSpaceError

The error that may occur when serializing.

type Meta = ()

An extra value provided, currently only meant and used for Take.

fn serialize(
    data: &i32,
    _: Self::Meta,
    bytes: &'a mut [u8]
) -> Result<usize, Self::Error>

Serialize a type into raw bytes.

impl<'a> Serializer<'a, i64> for Le

type Error = BasicOutOfSpaceError

The error that may occur when serializing.

type Meta = ()

An extra value provided, currently only meant and used for Take.

fn serialize(
    data: &i64,
    _: Self::Meta,
    bytes: &'a mut [u8]
) -> Result<usize, Self::Error>

Serialize a type into raw bytes.

impl<'a> Serializer<'a, i128> for Le

type Error = BasicOutOfSpaceError

The error that may occur when serializing.

type Meta = ()

An extra value provided, currently only meant and used for Take.

fn serialize(
    data: &i128,
    _: Self::Meta,
    bytes: &'a mut [u8]
) -> Result<usize, Self::Error>

Serialize a type into raw bytes.