# Struct ipnet::Ipv4Net [−] [src]

    pub struct Ipv4Net { /* fields omitted */ }

An IPv4 network address.

See `IpNet` for a type encompassing both IPv4 and IPv6 network addresses.

# Textual representation

`Ipv4Net` provides a `FromStr` implementation for parsing network addresses represented in CIDR notation. See IETF RFC 4632 for the CIDR notation.

# Examples

    use std::net::Ipv4Addr;
    use ipnet::Ipv4Net;

    let net: Ipv4Net = "10.1.1.0/24".parse().unwrap();
    assert_eq!(Ok(net.network()), "10.1.1.0".parse());

## Implementations

### `impl Ipv4Net` [src]

#### `pub fn new(ip: Ipv4Addr, prefix_len: u8) -> Result<Ipv4Net, PrefixLenError>` [src]

Creates a new IPv4 network address from an `Ipv4Addr` and prefix length.

# Examples

    use std::net::Ipv4Addr;
    use ipnet::{Ipv4Net, PrefixLenError};

    let net = Ipv4Net::new(Ipv4Addr::new(10, 1, 1, 0), 24);
    assert!(net.is_ok());

    let bad_prefix_len = Ipv4Net::new(Ipv4Addr::new(10, 1, 1, 0), 33);
    assert_eq!(bad_prefix_len, Err(PrefixLenError));

#### `pub fn trunc(&self) -> Ipv4Net` [src]

Returns a copy of the network with the address truncated to the prefix length.

# Examples

    assert_eq!(
        "192.168.12.34/16".parse::<Ipv4Net>().unwrap().trunc(),
        "192.168.0.0/16".parse().unwrap()
    );

#### `pub fn addr(&self) -> Ipv4Addr` [src]

Returns the address.

#### `pub fn prefix_len(&self) -> u8` [src]

Returns the prefix length.

#### `pub fn max_prefix_len(&self) -> u8` [src]

Returns the maximum valid prefix length.

#### `pub fn netmask(&self) -> Ipv4Addr` [src]

Returns the network mask.

# Examples

    let net: Ipv4Net = "10.1.0.0/20".parse().unwrap();
    assert_eq!(Ok(net.netmask()), "255.255.240.0".parse());

#### `pub fn hostmask(&self) -> Ipv4Addr` [src]

Returns the host mask.

# Examples

    let net: Ipv4Net = "10.1.0.0/20".parse().unwrap();
    assert_eq!(Ok(net.hostmask()), "0.0.15.255".parse());

#### `pub fn network(&self) -> Ipv4Addr` [src]

Returns the network address.

# Examples

    let net: Ipv4Net = "172.16.123.123/16".parse().unwrap();
    assert_eq!(Ok(net.network()), "172.16.0.0".parse());

#### `pub fn broadcast(&self) -> Ipv4Addr` [src]

Returns the broadcast address.

# Examples

    let net: Ipv4Net = "172.16.0.0/22".parse().unwrap();
    assert_eq!(Ok(net.broadcast()), "172.16.3.255".parse());

#### `pub fn supernet(&self) -> Option<Ipv4Net>` [src]

Returns the `Ipv4Net` that contains this one.

# Examples

    let n1: Ipv4Net = "172.16.1.0/24".parse().unwrap();
    let n2: Ipv4Net = "172.16.0.0/23".parse().unwrap();
    let n3: Ipv4Net = "172.16.0.0/0".parse().unwrap();

    assert_eq!(n1.supernet().unwrap(), n2);
    assert_eq!(n3.supernet(), None);

#### `pub fn is_sibling(&self, other: &Ipv4Net) -> bool` [src]

Returns `true` if this network and the given network are children of the same supernet.

# Examples

    let n1: Ipv4Net = "10.1.0.0/24".parse().unwrap();
    let n2: Ipv4Net = "10.1.1.0/24".parse().unwrap();
    let n3: Ipv4Net = "10.1.2.0/24".parse().unwrap();

    assert!(n1.is_sibling(&n2));
    assert!(!n2.is_sibling(&n3));

#### `pub fn hosts(&self) -> Ipv4AddrRangeⓘ

### Notable traits for Ipv4AddrRange

`impl Iterator for Ipv4AddrRange type Item = Ipv4Addr;`
` [src]

Return an `Iterator` over the host addresses in this network.

If the prefix length is less than 31 both the network address and broadcast address are excluded. These are only valid host addresses when the prefix length is 31.

# Examples

    let net: Ipv4Net = "10.0.0.0/30".parse().unwrap();
    assert_eq!(net.hosts().collect::<Vec<Ipv4Addr>>(), vec![
        "10.0.0.1".parse::<Ipv4Addr>().unwrap(),
        "10.0.0.2".parse().unwrap(),
    ]);

    let net: Ipv4Net = "10.0.0.0/31".parse().unwrap();
    assert_eq!(net.hosts().collect::<Vec<Ipv4Addr>>(), vec![
        "10.0.0.0".parse::<Ipv4Addr>().unwrap(),
        "10.0.0.1".parse().unwrap(),
    ]);

#### `pub fn subnets(&self, new_prefix_len: u8) -> Result<Ipv4Subnets, PrefixLenError>` [src]

Returns an `Iterator` over the subnets of this network with the given prefix length.

# Examples

    let net: Ipv4Net = "10.0.0.0/24".parse().unwrap();
    assert_eq!(net.subnets(26).unwrap().collect::<Vec<Ipv4Net>>(), vec![
        "10.0.0.0/26".parse::<Ipv4Net>().unwrap(),
        "10.0.0.64/26".parse().unwrap(),
        "10.0.0.128/26".parse().unwrap(),
        "10.0.0.192/26".parse().unwrap(),
    ]);

    let net: Ipv4Net = "10.0.0.0/30".parse().unwrap();
    assert_eq!(net.subnets(32).unwrap().collect::<Vec<Ipv4Net>>(), vec![
        "10.0.0.0/32".parse::<Ipv4Net>().unwrap(),
        "10.0.0.1/32".parse().unwrap(),
        "10.0.0.2/32".parse().unwrap(),
        "10.0.0.3/32".parse().unwrap(),
    ]);

    let net: Ipv4Net = "10.0.0.0/24".parse().unwrap();
    assert_eq!(net.subnets(23), Err(PrefixLenError));

    let net: Ipv4Net = "10.0.0.0/24".parse().unwrap();
    assert_eq!(net.subnets(33), Err(PrefixLenError));

#### `pub fn contains<T>(&self, other: T) -> bool where
Self: Contains<T>,` [src]

Test if a network address contains either another network address or an IP address.

# Examples

    let net: Ipv4Net = "192.168.0.0/24".parse().unwrap();
    let net_yes: Ipv4Net = "192.168.0.0/25".parse().unwrap();
    let net_no: Ipv4Net = "192.168.0.0/23".parse().unwrap();
    let ip_yes: Ipv4Addr = "192.168.0.1".parse().unwrap();
    let ip_no: Ipv4Addr = "192.168.1.0".parse().unwrap();

    assert!(net.contains(&net));
    assert!(net.contains(&net_yes));
    assert!(!net.contains(&net_no));
    assert!(net.contains(&ip_yes));
    assert!(!net.contains(&ip_no));

#### `pub fn aggregate(networks: &Vec<Ipv4Net>) -> Vec<Ipv4Net>` [src]

Aggregate a `Vec` of `Ipv4Net`s and return the result as a new `Vec`.

# Examples

    let nets = vec![
        "10.0.0.0/24".parse::<Ipv4Net>().unwrap(),
        "10.0.1.0/24".parse().unwrap(),
        "10.0.2.0/24".parse().unwrap(),
    ];

    assert_eq!(Ipv4Net::aggregate(&nets), vec![
        "10.0.0.0/23".parse::<Ipv4Net>().unwrap(),
        "10.0.2.0/24".parse().unwrap(),
    ]);

## Trait Implementations

### `impl Clone for Ipv4Net` [src]

#### `fn clone(&self) -> Ipv4Net` [src]

Returns a copy of the value. Read more

#### `pub fn clone_from(&mut self, source: &Self)`1.0.0 [src]

Performs copy-assignment from `source`. Read more

### `impl Copy for Ipv4Net` [src]

### `impl Debug for Ipv4Net` [src]

#### `fn fmt(&self, fmt: &mut Formatter<'_>) -> Result` [src]

Formats the value using the given formatter. Read more

### `impl Default for Ipv4Net` [src]

#### `fn default() -> Self` [src]

Returns the “default value” for a type. Read more

### `impl Display for Ipv4Net` [src]

#### `fn fmt(&self, fmt: &mut Formatter<'_>) -> Result` [src]

Formats the value using the given formatter. Read more

### `impl Eq for Ipv4Net` [src]

### `impl From<Ipv4Addr> for Ipv4Net` [src]

#### `fn from(addr: Ipv4Addr) -> Ipv4Net` [src]

Performs the conversion.

### `impl From<Ipv4Net> for IpNet` [src]

#### `fn from(net: Ipv4Net) -> IpNet` [src]

Performs the conversion.

### `impl FromStr for Ipv4Net` [src]

#### `type Err = AddrParseError`

The associated error which can be returned from parsing.

#### `fn from_str(s: &str) -> Result<Ipv4Net, AddrParseError>` [src]

Parses a string `s` to return a value of this type. Read more

### `impl Hash for Ipv4Net` [src]

#### `fn hash<__H: Hasher>(&self, state: &mut __H)` [src]

Feeds this value into the given `Hasher`. Read more

#### `pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,` 1.3.0 [src]

Feeds a slice of this type into the given `Hasher`. Read more

### `impl Ord for Ipv4Net` [src]

#### `fn cmp(&self, other: &Ipv4Net) -> Ordering` [src]

This method returns an `Ordering` between `self` and `other`. Read more

#### `#[must_use]pub fn max(self, other: Self) -> Self` 1.21.0 [src]

Compares and returns the maximum of two values. Read more

#### `#[must_use]pub fn min(self, other: Self) -> Self` 1.21.0 [src]

Compares and returns the minimum of two values. Read more

#### `#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self` 1.50.0 [src]

Restrict a value to a certain interval. Read more

### `impl PartialEq<Ipv4Net> for Ipv4Net` [src]

#### `fn eq(&self, other: &Ipv4Net) -> bool` [src]

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

#### `fn ne(&self, other: &Ipv4Net) -> bool` [src]

This method tests for `!=`.

### `impl PartialOrd<Ipv4Net> for Ipv4Net` [src]

#### `fn partial_cmp(&self, other: &Ipv4Net) -> Option<Ordering>` [src]

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

#### `#[must_use]pub fn lt(&self, other: &Rhs) -> bool` 1.0.0 [src]

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

#### `#[must_use]pub fn le(&self, other: &Rhs) -> bool` 1.0.0 [src]

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

#### `#[must_use]pub fn gt(&self, other: &Rhs) -> bool` 1.0.0 [src]

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

#### `#[must_use]pub fn ge(&self, other: &Rhs) -> bool` 1.0.0 [src]

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

### `impl StructuralEq for Ipv4Net` [src]

### `impl StructuralPartialEq for Ipv4Net` [src]

## Auto Trait Implementations

### `impl RefUnwindSafe for Ipv4Net`

### `impl Send for Ipv4Net`

### `impl Sync for Ipv4Net`

### `impl Unpin for Ipv4Net`

### `impl UnwindSafe for Ipv4Net`

## Blanket Implementations

### `impl<T> Any for T where
T: 'static + ?Sized,` [src]

#### `pub fn type_id(&self) -> TypeId` [src]

Gets the `TypeId` of `self`. Read more

### `impl<T> Borrow<T> for T where
T: ?Sized,` [src]

#### `pub fn borrow(&self) -> &T` [src]

Immutably borrows from an owned value. Read more

### `impl<T> BorrowMut<T> for T where
T: ?Sized,` [src]

#### `pub fn borrow_mut(&mut self) -> &mut T` [src]

Mutably borrows from an owned value. Read more

### `impl<T> From<T> for T` [src]

#### `pub fn from(t: T) -> T` [src]

Performs the conversion.

### `impl<T, U> Into<U> for T where
U: From<T>,` [src]

#### `pub fn into(self) -> U` [src]

Performs the conversion.

### `impl<T> ToOwned for T where
T: Clone,` [src]

#### `type Owned = T`

The resulting type after obtaining ownership.

#### `pub fn to_owned(&self) -> T` [src]

Creates owned data from borrowed data, usually by cloning. Read more

#### `pub fn clone_into(&self, target: &mut T)` [src]

🔬 This is a nightly-only experimental API. (`toowned_clone_into`)

recently added

Uses borrowed data to replace owned data, usually by cloning. Read more

### `impl<T> ToString for T where
T: Display + ?Sized,` [src]

#### `pub default fn to_string(&self) -> String` [src]

Converts the given value to a `String`. Read more

### `impl<T, U> TryFrom<U> for T where
U: Into<T>,` [src]

#### `type Error = Infallible`

The type returned in the event of a conversion error.

#### `pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>` [src]

Performs the conversion.

### `impl<T, U> TryInto<U> for T where
U: TryFrom<T>,` [src]

#### `type Error = <U as TryFrom<T>>::Error`

The type returned in the event of a conversion error.

#### `pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>` [src]

Performs the conversion.