Struct etherparse::Ipv6FlowLabel

pub struct Ipv6FlowLabel(/* private fields */);

The IPv6 “Flow Label” is a 20 bit unsigned integer present in the crate::Ipv6Header.

Example Usage:

use etherparse::Ipv6FlowLabel;

// try into
{
    let flow_label: Ipv6FlowLabel = 123.try_into().unwrap();
    assert_eq!(flow_label.value(), 123);

    // fragment offset can always be converted back to an u32
    let value: u32 = flow_label.into();
    assert_eq!(123, value);
}

// via try_new
{
    let flow_label = Ipv6FlowLabel::try_new(123).unwrap();
    assert_eq!(flow_label.value(), 123);

    // note that only 20 bit numbers are allowed (meaning
    // 0b1111_11111111_11111111 is the maximum allowed value)
    use etherparse::err::{ValueTooBigError, ValueType};
    assert_eq!(
        Ipv6FlowLabel::try_new(Ipv6FlowLabel::MAX_U32 + 1),
        Err(ValueTooBigError{
            actual: Ipv6FlowLabel::MAX_U32 + 1,
            max_allowed: Ipv6FlowLabel::MAX_U32,
            value_type: ValueType::Ipv6FlowLabel,
        })
    );
}

// via new_unchecked
{
    // in case you are sure the number does not exceed the max
    // you can use the unsafe new_unchecked function
    let flow_label = unsafe {
        // please make sure that the value is not greater than Ipv6FlowLabel::MAX_U32
        // before calling this method
        Ipv6FlowLabel::new_unchecked(123)
    };
    assert_eq!(flow_label.value(), 123);
}

Implementations

impl Ipv6FlowLabel

pub const ZERO: Ipv6FlowLabel = _

Ipv6FlowLabel with value 0.

pub const MAX_U32: u32 = 1_048_575u32

Maximum value of an IPv6 Flow Label.

pub const fn try_new(value: u32) -> Result<Ipv6FlowLabel, ValueTooBigError<u32>>

Tries to create an Ipv6FlowLabel and checks that the passed value is smaller or equal than Ipv6FlowLabel::MAX_U32 (20 bit unsigned integer).

In case the passed value is bigger then what can be represented in an 20 bit integer an error is returned. Otherwise an Ok containing the Ipv6FlowLabel.

use etherparse::Ipv6FlowLabel;

let frag_offset = Ipv6FlowLabel::try_new(123).unwrap();
assert_eq!(frag_offset.value(), 123);

// if a number that can not be represented in an 20 bit integer
// gets passed in an error is returned
use etherparse::err::{ValueTooBigError, ValueType};
assert_eq!(
    Ipv6FlowLabel::try_new(Ipv6FlowLabel::MAX_U32 + 1),
    Err(ValueTooBigError{
        actual: Ipv6FlowLabel::MAX_U32 + 1,
        max_allowed: Ipv6FlowLabel::MAX_U32,
        value_type: ValueType::Ipv6FlowLabel,
    })
);

pub const unsafe fn new_unchecked(value: u32) -> Ipv6FlowLabel

Creates an Ipv6FlowLabel without checking that the value is smaller or equal than Ipv6FlowLabel::MAX_U32 (20 bit unsigned integer). The caller must guarantee that value <= Ipv6FlowLabel::MAX_U32.

Safety

value must be smaller or equal than Ipv6FlowLabel::MAX_U32 otherwise the behavior of functions or data structures relying on this pre-requirement is undefined.

pub const fn value(self) -> u32

Returns the underlying unsigned 20 bit value as an u32 value.

Trait Implementations

impl Clone for Ipv6FlowLabel

fn clone(&self) -> Ipv6FlowLabel

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Ipv6FlowLabel

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Ipv6FlowLabel

fn default() -> Ipv6FlowLabel

Returns the “default value” for a type.

impl Display for Ipv6FlowLabel

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<Ipv6FlowLabel> for u32

fn from(value: Ipv6FlowLabel) -> Self

Converts to this type from the input type.

impl Hash for Ipv6FlowLabel

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Ipv6FlowLabel

fn cmp(&self, other: &Ipv6FlowLabel) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for Ipv6FlowLabel

fn eq(&self, other: &Ipv6FlowLabel) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Ipv6FlowLabel

fn partial_cmp(&self, other: &Ipv6FlowLabel) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl TryFrom<u32> for Ipv6FlowLabel

type Error = ValueTooBigError<u32>

The type returned in the event of a conversion error.

fn try_from(value: u32) -> Result<Self, Self::Error>

Performs the conversion.

impl Copy for Ipv6FlowLabel

impl Eq for Ipv6FlowLabel

impl StructuralPartialEq for Ipv6FlowLabel