Struct Ipv6Prefix120

#[repr(C)]
pub struct Ipv6Prefix120 { /* private fields */ }

An Ipv6 prefix limited to 120 bits and encoded as u128 (EXPERIMENTAL)

In many applications, managed Ipv6 prefixes are never longer than 120 bits. In theses cases, it is possible to save memory space by encoding it in 128 bits with its length encoded in last byte.

|---------------------- 120 bits -----------------------|--8 bits--|
                     ip prefix slot                         length

The resulting prefix is twice as short as the corresponding Ipv6 generic prefix.

Implementations

impl Ipv6Prefix120

pub unsafe fn from_slot_unchecked(slot: u128) -> Self

Creates a prefix from a well structured slot.

A well-structured slot is structured as follows where length is encoded on the last byte (8 bits) and this length should not exceed the prefix limit Self::MAX_LEN.

|------------ ip prefix slot ------------|-- length --|

Safety

Results are unpredictable if the last byte is not a valid length (i.e. exceeds Self::MAX_LEN)

A safe version of this function exists as Self::from_slot or also [`Self::try_from_slot] which doesn’t panic.

Example

let prefix = "1:1::/48".parse::<Ipv6Prefix56>().unwrap();
let slot : u64 = prefix.into_slot();
assert_eq!( prefix, unsafe { Ipv6Prefix56::from_slot_unchecked(slot)});

let prefix = "1:1::/48".parse::<Ipv6Prefix120>().unwrap();
let slot : u128 = prefix.into_slot();
assert_eq!( prefix, unsafe { Ipv6Prefix120::from_slot_unchecked(slot)});

pub fn from_slot(slot: u128) -> Result<Self, IpPrefixError>

Creates a prefix from a well structured slot.

A well-structured slot is structured as follows where length is encoded on the last byte (8 bits) and this length should not exceed the prefix limit Self::MAX_LEN.

|------------ ip prefix slot ------------|-- length --|

It returns an error if the last byte is not a valid length.

If you are sure that the slot is well-structured, an unchecked (and unsafe) version of this function is provided by Self::from_slot_unchecked.

Example

let prefix = "1:1::/48".parse::<Ipv6Prefix56>().unwrap();
let slot : u64 = prefix.into_slot();
assert_eq!( Ok(prefix), Ipv6Prefix56::from_slot(slot));

let prefix = "1:1::/48".parse::<Ipv6Prefix120>().unwrap();
let slot : u128 = prefix.into_slot();
assert_eq!( Ok(prefix), Ipv6Prefix120::from_slot(slot));

pub fn into_slot(self) -> u128

Gets the raw value of the inner slot.

This slot is structured as follows where length is encoded on the last byte (8 bits).

|------------ ip prefix slot ------------|-- length --|

The returned slot could be safely used with Self::from_slot_unchecked.

impl Ipv6Prefix120

pub fn new(addr: Ipv6Addr, len: u8) -> Result<Self, IpPrefixError>

Trait Implementations

impl Clone for Ipv6Prefix120

fn clone(&self) -> Ipv6Prefix120

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Ipv6Prefix120

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

Formats the value using the given formatter.

impl Default for Ipv6Prefix120

fn default() -> Ipv6Prefix120

Returns the “default value” for a type.

impl Display for Ipv6Prefix120

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

Formats the value using the given formatter.

impl From<Ipv6NetAddr> for Ipv6Prefix120

fn from(value: Ipv6NetAddr) -> Self

Converts to this type from the input type.

impl From<Ipv6Prefix120> for Ipv6Net

fn from(value: Ipv6Prefix120) -> Self

Converts to this type from the input type.

impl From<Ipv6Prefix120> for Ipv6Prefix

fn from(value: Ipv6Prefix120) -> Self

Converts to this type from the input type.

impl From<Ipv6Prefix56> for Ipv6Prefix120

fn from(value: Ipv6Prefix56) -> Self

Converts to this type from the input type.

impl FromStr for Ipv6Prefix120

type Err = IpPrefixError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for Ipv6Prefix120

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 IpPrefix for Ipv6Prefix120

const MAX_LEN: u8 = 120u8

The maximum allowed length for this prefix

type Slot = u128

The slot manipulated inside this prefix

type Addr = Ipv6Addr

The underlying ip address (usually Ipv4Addr or Ipv6Addr)

fn bitslot(&self) -> Self::Slot

The inner slot as is

fn bitslot_trunc(&self) -> Self::Slot

The inner slot with all the masked bits set to 0.

fn len(&self) -> u8

Length of the prefix.

fn network(&self) -> Self::Addr

The address of the network defined by the prefixv

fn bitmask(&self) -> Self::Slot

Mask of the prefix.

impl IpPrefixCovering<Ipv6Addr> for Ipv6Prefix120

fn covers(&self, other: &P) -> bool

Checks the coverage of this prefix against a set of addresses

impl IpPrefixCovering<Ipv6Net> for Ipv6Prefix120

fn covers(&self, other: &P) -> bool

Checks the coverage of this prefix against a set of addresses

impl IpPrefixCovering<Ipv6NetAddr> for Ipv6Prefix120

fn covers(&self, other: &P) -> bool

Checks the coverage of this prefix against a set of addresses

impl IpPrefixCovering<Ipv6Prefix> for Ipv6Prefix120

fn covers(&self, other: &P) -> bool

Checks the coverage of this prefix against a set of addresses

impl IpPrefixCovering<Ipv6Prefix120> for Ipv6Net

fn covers(&self, other: &P) -> bool

Checks the coverage of this prefix against a set of addresses

impl IpPrefixCovering<Ipv6Prefix120> for Ipv6NetAddr

fn covers(&self, other: &P) -> bool

Checks the coverage of this prefix against a set of addresses

impl IpPrefixCovering<Ipv6Prefix120> for Ipv6Prefix

fn covers(&self, other: &P) -> bool

Checks the coverage of this prefix against a set of addresses

impl IpPrefixCovering<Ipv6Prefix120> for Ipv6Prefix56

fn covers(&self, other: &P) -> bool

Checks the coverage of this prefix against a set of addresses

impl IpPrefixCovering<Ipv6Prefix56> for Ipv6Prefix120

fn covers(&self, other: &P) -> bool

Checks the coverage of this prefix against a set of addresses

impl IpPrefixShortening for Ipv6Prefix120

fn shorten(&mut self, maxlen: u8)

Shortens the prefix

impl IpPrivatePrefix for Ipv6Prefix120

fn is_private(&self) -> bool

impl IpRootPrefix for Ipv6Prefix120

fn root() -> Self

Root prefix has a length of 0

impl PartialEq<Ipv6Net> for Ipv6Prefix120

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<Ipv6NetAddr> for Ipv6Prefix120

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<Ipv6Prefix> for Ipv6Prefix120

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<Ipv6Prefix120> for Ipv6Net

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<Ipv6Prefix120> for Ipv6NetAddr

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<Ipv6Prefix120> for Ipv6Prefix

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<Ipv6Prefix120> for Ipv6Prefix56

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<Ipv6Prefix56> for Ipv6Prefix120

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq for Ipv6Prefix120

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl TryFrom<Ipv6Net> for Ipv6Prefix120

type Error = IpPrefixError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<Ipv6Prefix> for Ipv6Prefix120

type Error = IpPrefixError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<Ipv6Prefix120> for Ipv6NetAddr

type Error = IpPrefixError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<Ipv6Prefix120> for Ipv6Prefix56

type Error = IpPrefixError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl Copy for Ipv6Prefix120

impl Eq for Ipv6Prefix120

impl StructuralPartialEq for Ipv6Prefix120