Impl From<Ipv4Addr, Ipv6Addr> for IpNetwork (#218)

* feat: iterator size hints

* fix: add size_hint to IpNetworkIterator

.github/dependabot.yml

@@ -0,0 +1,7 @@
+version: 2
+updates:
+- package-ecosystem: cargo
+  directory: "/"
+  schedule:
+    interval: daily
+  open-pull-requests-limit: 10

.github/workflows/publish.yml

@@ -0,0 +1,54 @@
+name: Release-plz
+
+permissions:
+  pull-requests: write
+  contents: write
+
+on:
+  workflow_dispatch:
+  push:
+    branches:
+      - main
+
+jobs:
+
+  # Release unpublished packages.
+  release-plz-release:
+    name: Release-plz release
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@stable
+      - name: Run release-plz
+        uses: release-plz/action@v0.5
+        with:
+          command: release
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }}
+
+  # Create a PR with the new versions and changelog, preparing the next release.
+  release-plz-pr:
+    name: Release-plz PR
+    runs-on: ubuntu-latest
+    concurrency:
+      group: release-plz-${{ github.ref }}
+      cancel-in-progress: false
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@stable
+      - name: Run release-plz
+        uses: release-plz/action@v0.5
+        with:
+          command: release-pr
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }}

.github/workflows/rust.yml

@@ -0,0 +1,32 @@
+name: Rust
+
+on:
+  workflow_dispatch:
+  pull_request:
+    branches: 
+      - master
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        rust: [stable, beta, nightly]
+    steps:
+    - uses: dtolnay/rust-toolchain@stable
+      with:
+        rust-version: ${{ matrix.rust }}
+        components: clippy, rustfmt
+    - uses: actions/checkout@master
+      with:
+        ref: ${{ github.ref }}
+    - name: Show current git branch
+      run: git branch
+    - name: Build
+      run: cargo build --verbose
+    - name: Run tests
+      run: cargo test --verbose --all-features
+    - name: Build docs
+      run: cargo doc --verbose
+    - name: Run clippy
+      run: cargo clippy --verbose --all-features

.gitignore

@@ -1,5 +1,4 @@
-.gitignore
 Cargo.lock
 target
 .vscode
-.idea/
+.idea/

.travis.yml

@@ -9,6 +9,8 @@ env:
     - FEATURES: default
 
 script:
+  - cargo build --verbose --no-default-features
+  - cargo test --verbose --no-default-features
   - cargo build --verbose
   - cargo test --verbose
   - cargo build --release --verbose

CHANGELOG.md

@@ -0,0 +1,61 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.21.1](https://github.com/achanda/ipnetwork/compare/v0.21.0...v0.21.1) - 2025-01-07
+
+### Other
+
+- Fix for 0::/0 network ([#205](https://github.com/achanda/ipnetwork/pull/205))
+
+## [0.21.0](https://github.com/achanda/ipnetwork/compare/v0.20.0...v0.21.0) - 2025-01-06
+
+### Fixed
+
+- fix for 0.0.0.0/0 network ([#199](https://github.com/achanda/ipnetwork/pull/199))
+- *(deps)* update rust crate serde to 1.0.200 (#196)
+- *(deps)* update rust crate serde to 1.0.199 (#194)
+- use associated constants (#191)
+
+### Other
+
+- Update .gitignore
+- Update publish.yml
+- Update publish.yml
+- Replace `Ipv{4,6}Network::new_unchecked` with `Ipv{4,6}Network::new_checked` ([#203](https://github.com/achanda/ipnetwork/pull/203))
+- Make the serde feature opt-in instead of opt-out ([#200](https://github.com/achanda/ipnetwork/pull/200))
+- Fix typo ([#198](https://github.com/achanda/ipnetwork/pull/198))
+- Update publish.yml ([#195](https://github.com/achanda/ipnetwork/pull/195))
+- *(deps)* update rust crate serde_json to 1.0.116 (#193)
+- setup release plz (#192)
+- Update Rust crate criterion to 0.5.1 ([#172](https://github.com/achanda/ipnetwork/pull/172))
+- Update actions/checkout action to v4 ([#182](https://github.com/achanda/ipnetwork/pull/182))
+- rewrite core ipv6 methods to operate on u128s  (#187)
+- move to dtolnay/rust-toolchain and run clippy (#189)
+- Hash implementation to match PartialEq (#186)
+- Update Rust crate schemars to 0.8.17 ([#184](https://github.com/achanda/ipnetwork/pull/184))
+- Add const unsafe `new_unchecked` to `Ipv4Network` & `Ipv6Network` ([#185](https://github.com/achanda/ipnetwork/pull/185))
+- Update Rust crate schemars to 0.8.15 ([#183](https://github.com/achanda/ipnetwork/pull/183))
+- Update Rust crate schemars to 0.8.13 ([#181](https://github.com/achanda/ipnetwork/pull/181))
+- Add `Ipv6Network::nth` to get the nth address (take two) ([#176](https://github.com/achanda/ipnetwork/pull/176))
+- Added needed traits to `NetworkSize` ([#175](https://github.com/achanda/ipnetwork/pull/175))
+- Update criterion requirement from 0.4.0 to 0.5.0
+- Update katyo/publish-crates action to v2
+- Update actions/checkout action to v3
+- Update Rust crate schemars to 0.8.12
+- Add renovate.json
+- Replace assert_eq with assert for bool comparison
+- Use cargo clippy --fix to autofix code
+- Add a reference where missing
+- Cleanup mask for Ipv4Addr
+- Shrink the enumerate call on mask
+- Cleanup both size functions
+- Simplify FromStr for Ipv6Network
+- Make parse_prefix more idiomatic
+- Update criterion requirement from 0.3.4 to 0.4.0 ([#162](https://github.com/achanda/ipnetwork/pull/162))
+- Update does-it-json requirement from 0.0.3 to 0.0.4 ([#161](https://github.com/achanda/ipnetwork/pull/161))

Cargo.toml

@@ -1,26 +1,35 @@
 [package]
 name = "ipnetwork"
-version = "0.14.0" # When updating version, also modify html_root_url in the lib.rs
+version = "0.21.1"
 authors = ["Abhishek Chanda <abhishek.becs@gmail.com>", "Linus Färnstrand <faern@faern.net>"]
-description = "A library to work with IP CIDRs in Rust, heavily WIP"
-license = "Apache-2.0"
+description = "A library to work with IP CIDRs in Rust"
+license = "MIT OR Apache-2.0"
 repository = "https://github.com/achanda/ipnetwork"
-keywords = ["network", "ip", "address"]
+keywords = ["network", "ip", "address", "cidr"]
 readme = "README.md"
-documentation = "https://docs.rs/ipnetwork/"
-categories = ["network-programming", "os"]
+categories = ["network-programming", "parser-implementations"]
+edition = "2021"
+rust-version = "1.80.0"
 
 [dependencies]
-clippy = {version = "0.0.302", optional = true}
-serde = ">=0.8.0, <2.0"
+serde = { version = "1.0.200", optional = true }
+schemars = { version = "0.8.17", optional = true }
 
 [dev-dependencies]
-serde_json = "1.0"
-serde_derive = ">=0.8.0, <2.0"
+serde_json = "1.0.116"
+criterion = {version = "0.5.1", features= ["html_reports"]}
+does-it-json = "0.0.4"
 
 [badges]
 travis-ci = { repository = "achanda/ipnetwork" }
+maintenance = { status = "passively-maintained" }
 
 [features]
+# Keep optional dependencies out of the default features.
+# Since most people add a dependency without `default-features = false` they involuntarily
+# pull in unused dependencies.
 default = []
-dev = ["clippy"]
+
+[[bench]]
+name = "parse_bench"
+harness = false

LICENSE-MIT.md

@@ -0,0 +1,25 @@
+Copyright 2020 Developers of the ipnetwork project
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

README.md

@@ -1,14 +1,14 @@
 ipnetwork
 ===
-This is a library to work with IPv4 and v6 CIDRs in rust
-The IPv4 implementation is stable, IPv6 implementation is not done yet.
+This is a library to work with IPv4 and IPv6 CIDRs in Rust
 
 [![Build Status](https://travis-ci.org/achanda/ipnetwork.svg?branch=master)](https://travis-ci.org/achanda/ipnetwork)
 [![Merit Badge](http://meritbadge.herokuapp.com/ipnetwork)](https://crates.io/crates/ipnetwork)
 
 Run Clippy by doing
 ```
-cargo test --features "dev"
+rustup component add clippy
+cargo clippy
 ```
 
 ### Installation
@@ -20,7 +20,7 @@ cargo test
 ```
 
 You can also add `ipnetwork` as a dependency to your project's `Cargo.toml`:
-```
+```toml
 [dependencies]
 ipnetwork = "*"
 ```

benches/parse_bench.rs

@@ -0,0 +1,49 @@
+use criterion::{criterion_group, criterion_main, Criterion};
+use ipnetwork::{Ipv4Network, Ipv6Network};
+use std::net::{Ipv4Addr, Ipv6Addr};
+
+fn parse_ipv4_prefix_benchmark(c: &mut Criterion) {
+    c.bench_function("parse ipv4 prefix", |b| {
+        b.iter(|| "127.1.0.0/24".parse::<Ipv4Network>().unwrap())
+    });
+}
+
+fn parse_ipv6_benchmark(c: &mut Criterion) {
+    c.bench_function("parse ipv6", |b| {
+        b.iter(|| "FF01:0:0:17:0:0:0:2/64".parse::<Ipv6Network>().unwrap())
+    });
+}
+
+fn parse_ipv4_netmask_benchmark(c: &mut Criterion) {
+    c.bench_function("parse ipv4 netmask", |b| {
+        b.iter(|| "127.1.0.0/255.255.255.0".parse::<Ipv4Network>().unwrap())
+    });
+}
+
+fn contains_ipv4_benchmark(c: &mut Criterion) {
+    let cidr = "74.125.227.0/25".parse::<Ipv4Network>().unwrap();
+    c.bench_function("contains ipv4", |b| {
+        b.iter(|| {
+            cidr.contains(Ipv4Addr::new(74, 125, 227, 4))
+        })
+    });
+}
+
+fn contains_ipv6_benchmark(c: &mut Criterion) {
+    let cidr = "FF01:0:0:17:0:0:0:2/65".parse::<Ipv6Network>().unwrap();
+    c.bench_function("contains ipv6", |b| {
+        b.iter(|| {
+            cidr.contains(Ipv6Addr::new(0xff01, 0, 0, 0x17, 0x7fff, 0, 0, 0x2))
+        })
+    });
+}
+
+criterion_group!(
+    benches,
+    parse_ipv4_prefix_benchmark,
+    parse_ipv6_benchmark,
+    parse_ipv4_netmask_benchmark,
+    contains_ipv4_benchmark,
+    contains_ipv6_benchmark
+);
+criterion_main!(benches);

renovate.json

@@ -0,0 +1,6 @@
+{
+  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
+  "extends": [
+    "config:base"
+  ]
+}

src/common.rs

@@ -1,57 +0,0 @@
-use std::error::Error;
-use std::fmt;
-
-/// Represents a bunch of errors that can occur while working with a `IpNetwork`
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum IpNetworkError {
-    InvalidAddr(String),
-    InvalidPrefix,
-    InvalidCidrFormat(String),
-}
-
-impl fmt::Display for IpNetworkError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use IpNetworkError::*;
-        match *self {
-            InvalidAddr(ref s) => write!(f, "invalid address: {}", s),
-            InvalidPrefix => write!(f, "invalid prefix"),
-            InvalidCidrFormat(ref s) => write!(f, "invalid cidr format: {}", s),
-        }
-    }
-}
-
-impl Error for IpNetworkError {
-    fn description(&self) -> &str {
-        use IpNetworkError::*;
-        match *self {
-            InvalidAddr(_) => "address is invalid",
-            InvalidPrefix => "prefix is invalid",
-            InvalidCidrFormat(_) => "cidr is invalid",
-        }
-    }
-}
-
-pub fn cidr_parts(cidr: &str) -> Result<(&str, Option<&str>), IpNetworkError> {
-    let parts = cidr.split('/').collect::<Vec<&str>>();
-    if parts.len() == 1 {
-        Ok((parts[0], None))
-    } else if parts.len() == 2 {
-        Ok((parts[0], Some(parts[1])))
-    } else {
-        Err(IpNetworkError::InvalidCidrFormat(format!(
-            "CIDR must contain a single '/': {}",
-            cidr
-        )))
-    }
-}
-
-pub fn parse_prefix(prefix: &str, max: u8) -> Result<u8, IpNetworkError> {
-    let mask = prefix
-        .parse::<u8>()
-        .map_err(|_| IpNetworkError::InvalidPrefix)?;
-    if mask > max {
-        Err(IpNetworkError::InvalidPrefix)
-    } else {
-        Ok(mask)
-    }
-}

src/error.rs

@@ -0,0 +1,56 @@
+use std::{error::Error, fmt, net::AddrParseError};
+
+use crate::error::IpNetworkError::*;
+
+/// Represents a bunch of errors that can occur while working with a `IpNetwork`
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum IpNetworkError {
+    InvalidAddr(String),
+    InvalidPrefix,
+    InvalidCidrFormat(String),
+    NetworkSizeError(NetworkSizeError),
+}
+
+impl fmt::Display for IpNetworkError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match *self {
+            InvalidAddr(ref s) => write!(f, "invalid address: {s}"),
+            InvalidPrefix => write!(f, "invalid prefix"),
+            InvalidCidrFormat(ref s) => write!(f, "invalid cidr format: {s}"),
+            NetworkSizeError(ref e) => write!(f, "network size error: {e}"),
+        }
+    }
+}
+
+impl Error for IpNetworkError {
+    fn description(&self) -> &str {
+        match *self {
+            InvalidAddr(_) => "address is invalid",
+            InvalidPrefix => "prefix is invalid",
+            InvalidCidrFormat(_) => "cidr is invalid",
+            NetworkSizeError(_) => "network size error",
+        }
+    }
+}
+
+impl From<AddrParseError> for IpNetworkError {
+    fn from(e: AddrParseError) -> Self {
+        InvalidAddr(e.to_string())
+    }
+}
+
+/// Cannot convert an IPv6 network size to a u32 as it is a 128-bit value.
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum NetworkSizeError {
+    NetworkIsTooLarge,
+}
+
+impl fmt::Display for NetworkSizeError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str("Network is too large to fit into an unsigned 32-bit integer!")
+    }
+}
+
+impl Error for NetworkSizeError {}

src/ipv4.rs

@@ -1,10 +1,6 @@
-use std::fmt;
-use std::net::Ipv4Addr;
-use std::str::FromStr;
-
-use serde::{de, Deserialize, Deserializer, Serialize, Serializer};
-
-use common::{cidr_parts, parse_prefix, IpNetworkError};
+use crate::error::IpNetworkError;
+use crate::parse::{cidr_parts, parse_prefix};
+use std::{convert::TryFrom, fmt, net::Ipv4Addr, str::FromStr};
 
 const IPV4_BITS: u8 = 32;
 
@@ -15,53 +11,161 @@ pub struct Ipv4Network {
     prefix: u8,
 }
 
-impl<'de> Deserialize<'de> for Ipv4Network {
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for Ipv4Network {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
-        D: Deserializer<'de>,
+        D: serde::Deserializer<'de>,
     {
-        let s = <&str>::deserialize(deserializer)?;
-        Ipv4Network::from_str(s).map_err(de::Error::custom)
+        let s = <String>::deserialize(deserializer)?;
+        Ipv4Network::from_str(&s).map_err(serde::de::Error::custom)
     }
 }
 
-impl Serialize for Ipv4Network {
+#[cfg(feature = "serde")]
+impl serde::Serialize for Ipv4Network {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
-        S: Serializer,
+        S: serde::Serializer,
     {
-        serializer.serialize_str(&self.to_string())
+        serializer.collect_str(self)
+    }
+}
+
+#[cfg(feature = "schemars")]
+impl schemars::JsonSchema for Ipv4Network {
+    fn schema_name() -> String {
+        "Ipv4Network".to_string()
+    }
+
+    fn json_schema(_: &mut schemars::gen::SchemaGenerator) -> schemars::schema::Schema {
+        schemars::schema::SchemaObject {
+            instance_type: Some(schemars::schema::InstanceType::String.into()),
+            string: Some(Box::new(schemars::schema::StringValidation {
+                pattern: Some(
+                    concat!(
+                        r#"^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}"#,
+                        r#"(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)"#,
+                        r#"\/(3[0-2]|[0-2]?[0-9])$"#,
+                    )
+                    .to_string(),
+                ),
+                ..Default::default()
+            })),
+            extensions: [("x-rust-type".to_string(), "ipnetwork::Ipv4Network".into())]
+                .iter()
+                .cloned()
+                .collect(),
+            ..Default::default()
+        }
+        .into()
     }
 }
 
 impl Ipv4Network {
     /// Constructs a new `Ipv4Network` from any `Ipv4Addr` and a prefix denoting the network size.
+    ///
     /// If the prefix is larger than 32 this will return an `IpNetworkError::InvalidPrefix`.
-    pub fn new(addr: Ipv4Addr, prefix: u8) -> Result<Ipv4Network, IpNetworkError> {
-        if prefix > IPV4_BITS {
-            Err(IpNetworkError::InvalidPrefix)
-        } else {
-            Ok(Ipv4Network { addr, prefix })
+    pub const fn new(addr: Ipv4Addr, prefix: u8) -> Result<Ipv4Network, IpNetworkError> {
+        match Ipv4Network::new_checked(addr, prefix) {
+            Some(a) => Ok(a),
+            None => Err(IpNetworkError::InvalidPrefix),
         }
     }
 
+    /// Constructs a new `Ipv4Network` from any `Ipv4Addr`, and a prefix denoting the network size.
+    ///
+    /// If the prefix is larger than 32 this will return `None`. This is useful in const contexts,
+    /// where [`Option::unwrap`] may be called to trigger a compile-time error in case the prefix
+    /// is an unexpected value.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::net::Ipv4Addr;
+    /// use ipnetwork::Ipv4Network;
+    ///
+    /// const PREFIX: u8 = 24;
+    /// const ADDR: Ipv4Addr = Ipv4Addr::new(192, 168, 1, 1);
+    ///
+    /// // Okay!
+    /// const NETWORK: Ipv4Network = Ipv4Network::new_checked(ADDR, PREFIX).unwrap();
+    /// assert_eq!(NETWORK.prefix(), PREFIX);
+    /// ```
+    ///
+    /// ```should_panic
+    /// use std::net::Ipv4Addr;
+    /// use ipnetwork::Ipv4Network;
+    ///
+    /// // Prefix is greater than 32.
+    /// const PREFIX: u8 = 32 + 1;
+    /// const ADDR: Ipv4Addr = Ipv4Addr::new(192, 168, 1, 1);
+    ///
+    /// // This fails!
+    /// const NETWORK: Option<Ipv4Network> = Ipv4Network::new_checked(ADDR, PREFIX);
+    /// assert_eq!(NETWORK.unwrap().prefix(), PREFIX);
+    /// ```
+    pub const fn new_checked(addr: Ipv4Addr, prefix: u8) -> Option<Ipv4Network> {
+        if prefix > IPV4_BITS {
+            None
+        } else {
+            Some(Ipv4Network { addr, prefix })
+        }
+    }
+
+    /// Constructs a new `Ipv4Network` from a network address and a network mask.
+    ///
+    /// If the netmask is not valid this will return an `IpNetworkError::InvalidPrefix`.
+    pub fn with_netmask(
+        netaddr: Ipv4Addr,
+        netmask: Ipv4Addr,
+    ) -> Result<Ipv4Network, IpNetworkError> {
+        let prefix = ipv4_mask_to_prefix(netmask)?;
+        let net = Self {
+            addr: netaddr,
+            prefix,
+        };
+        Ok(net)
+    }
+
     /// Returns an iterator over `Ipv4Network`. Each call to `next` will return the next
     /// `Ipv4Addr` in the given network. `None` will be returned when there are no more
     /// addresses.
-    pub fn iter(&self) -> Ipv4NetworkIterator {
+    pub fn iter(self) -> Ipv4NetworkIterator {
         let start = u32::from(self.network());
-        let end = start + self.size();
-        Ipv4NetworkIterator { next: start, end }
+        let end = start + (self.size() - 1);
+        Ipv4NetworkIterator {
+            next: Some(start),
+            end,
+        }
     }
 
-    pub fn ip(&self) -> Ipv4Addr {
+    pub const fn ip(self) -> Ipv4Addr {
         self.addr
     }
 
-    pub fn prefix(&self) -> u8 {
+    pub const fn prefix(self) -> u8 {
         self.prefix
     }
 
+    /// Checks if the given `Ipv4Network` is a subnet of the other.
+    pub fn is_subnet_of(self, other: Ipv4Network) -> bool {
+        other.ip() <= self.ip() && other.broadcast() >= self.broadcast()
+    }
+
+    /// Checks if the given `Ipv4Network` is a supernet of the other.
+    pub fn is_supernet_of(self, other: Ipv4Network) -> bool {
+        other.is_subnet_of(self)
+    }
+
+    /// Checks if the given `Ipv4Network` is partly contained in other.
+    pub fn overlaps(self, other: Ipv4Network) -> bool {
+        other.contains(self.ip())
+            || other.contains(self.broadcast())
+            || self.contains(other.ip())
+            || self.contains(other.broadcast())
+    }
+
     /// Returns the mask for this `Ipv4Network`.
     /// That means the `prefix` most significant bits will be 1 and the rest 0
     ///
@@ -76,10 +180,13 @@ impl Ipv4Network {
     /// let net: Ipv4Network = "127.0.0.0/16".parse().unwrap();
     /// assert_eq!(net.mask(), Ipv4Addr::new(255, 255, 0, 0));
     /// ```
-    pub fn mask(&self) -> Ipv4Addr {
-        let prefix = self.prefix;
-        let mask = !(0xffff_ffff as u64 >> prefix) as u32;
-        Ipv4Addr::from(mask)
+    pub const fn mask(&self) -> Ipv4Addr {
+        debug_assert!(self.prefix <= 32);
+        if self.prefix == 0 {
+            return Ipv4Addr::new(0, 0, 0, 0);
+        }
+        let mask = u32::MAX << (IPV4_BITS - self.prefix);
+        Ipv4Addr::from_bits(mask)
     }
 
     /// Returns the address of the network denoted by this `Ipv4Network`.
@@ -94,10 +201,10 @@ impl Ipv4Network {
     /// let net: Ipv4Network = "10.1.9.32/16".parse().unwrap();
     /// assert_eq!(net.network(), Ipv4Addr::new(10, 1, 0, 0));
     /// ```
-    pub fn network(&self) -> Ipv4Addr {
-        let mask = u32::from(self.mask());
-        let ip = u32::from(self.addr) & mask;
-        Ipv4Addr::from(ip)
+    pub const fn network(&self) -> Ipv4Addr {
+        let mask = self.mask().to_bits();
+        let ip = self.addr.to_bits() & mask;
+        Ipv4Addr::from_bits(ip)
     }
 
     /// Returns the broadcasting address of this `Ipv4Network`.
@@ -112,10 +219,10 @@ impl Ipv4Network {
     /// let net: Ipv4Network = "10.9.0.32/16".parse().unwrap();
     /// assert_eq!(net.broadcast(), Ipv4Addr::new(10, 9, 255, 255));
     /// ```
-    pub fn broadcast(&self) -> Ipv4Addr {
-        let mask = u32::from(self.mask());
-        let broadcast = u32::from(self.addr) | !mask;
-        Ipv4Addr::from(broadcast)
+    pub const fn broadcast(&self) -> Ipv4Addr {
+        let mask = self.mask().to_bits();
+        let broadcast = self.addr.to_bits() | !mask;
+        Ipv4Addr::from_bits(broadcast)
     }
 
     /// Checks if a given `Ipv4Addr` is in this `Ipv4Network`
@@ -130,10 +237,13 @@ impl Ipv4Network {
     /// assert!(net.contains(Ipv4Addr::new(127, 0, 0, 70)));
     /// assert!(!net.contains(Ipv4Addr::new(127, 0, 1, 70)));
     /// ```
-    pub fn contains(&self, ip: Ipv4Addr) -> bool {
-        let net = u32::from(self.network());
-        let mask = u32::from(self.mask());
-        (u32::from(ip) & mask) == net
+    #[inline]
+    pub const fn contains(&self, ip: Ipv4Addr) -> bool {
+        debug_assert!(self.prefix <= IPV4_BITS);
+
+        let mask = !(0xffff_ffff_u64 >> self.prefix) as u32;
+        let net = self.addr.to_bits() & mask;
+        (ip.to_bits() & mask) == net
     }
 
     /// Returns number of possible host addresses in this `Ipv4Network`.
@@ -150,9 +260,12 @@ impl Ipv4Network {
     /// let tinynet: Ipv4Network = "0.0.0.0/32".parse().unwrap();
     /// assert_eq!(tinynet.size(), 1);
     /// ```
-    pub fn size(&self) -> u32 {
-        let host_bits = u32::from(IPV4_BITS - self.prefix);
-        (2 as u32).pow(host_bits)
+    pub fn size(self) -> u32 {
+        debug_assert!(self.prefix <= 32);
+        if self.prefix == 0 {
+            return u32::MAX;
+        }
+        1 << (IPV4_BITS - self.prefix)
     }
 
     /// Returns the `n`:th address within this network.
@@ -172,7 +285,7 @@ impl Ipv4Network {
     /// let net2: Ipv4Network = "10.0.0.0/16".parse().unwrap();
     /// assert_eq!(net2.nth(256).unwrap(), Ipv4Addr::new(10, 0, 1, 0));
     /// ```
-    pub fn nth(&self, n: u32) -> Option<Ipv4Addr> {
+    pub fn nth(self, n: u32) -> Option<Ipv4Addr> {
         if n < self.size() {
             let net = u32::from(self.network());
             Some(Ipv4Addr::from(net + n))
@@ -183,7 +296,7 @@ impl Ipv4Network {
 }
 
 impl fmt::Display for Ipv4Network {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(fmt, "{}/{}", self.ip(), self.prefix())
     }
 }
@@ -203,18 +316,31 @@ impl fmt::Display for Ipv4Network {
 /// ```
 impl FromStr for Ipv4Network {
     type Err = IpNetworkError;
-    fn from_str(s: &str) -> Result<Ipv4Network, IpNetworkError> {
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
         let (addr_str, prefix_str) = cidr_parts(s)?;
-        let addr = Ipv4Addr::from_str(addr_str)
-            .map_err(|_| IpNetworkError::InvalidAddr(addr_str.to_string()))?;
+        let addr = Ipv4Addr::from_str(addr_str)?;
         let prefix = match prefix_str {
-            Some(v) => parse_prefix(v, IPV4_BITS)?,
+            Some(v) => {
+                if let Ok(netmask) = Ipv4Addr::from_str(v) {
+                    ipv4_mask_to_prefix(netmask)?
+                } else {
+                    parse_prefix(v, IPV4_BITS)?
+                }
+            }
             None => IPV4_BITS,
         };
         Ipv4Network::new(addr, prefix)
     }
 }
 
+impl TryFrom<&str> for Ipv4Network {
+    type Error = IpNetworkError;
+
+    fn try_from(s: &str) -> Result<Self, Self::Error> {
+        Ipv4Network::from_str(s)
+    }
+}
+
 impl From<Ipv4Addr> for Ipv4Network {
     fn from(a: Ipv4Addr) -> Ipv4Network {
         Ipv4Network {
@@ -224,8 +350,9 @@ impl From<Ipv4Addr> for Ipv4Network {
     }
 }
 
+#[derive(Clone, Debug)]
 pub struct Ipv4NetworkIterator {
-    next: u32,
+    next: Option<u32>,
     end: u32,
 }
 
@@ -233,26 +360,55 @@ impl Iterator for Ipv4NetworkIterator {
     type Item = Ipv4Addr;
 
     fn next(&mut self) -> Option<Ipv4Addr> {
-        if self.next < self.end {
-            let next = Ipv4Addr::from(self.next as u32);
-            self.next += 1;
-            Some(next)
-        } else {
+        let next = self.next?;
+        self.next = if next == self.end {
             None
+        } else {
+            Some(next + 1)
+        };
+        Some(next.into())
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        if let Some(n) = self.next {
+            let elms = (self.end - n + 1) as usize;
+            (elms, Some(elms))
+        } else {
+            (0, None)
         }
     }
 }
 
+impl IntoIterator for &'_ Ipv4Network {
+    type IntoIter = Ipv4NetworkIterator;
+    type Item = Ipv4Addr;
+    fn into_iter(self) -> Ipv4NetworkIterator {
+        self.iter()
+    }
+}
+
 /// Converts a `Ipv4Addr` network mask into a prefix.
+///
 /// If the mask is invalid this will return an `IpNetworkError::InvalidPrefix`.
 pub fn ipv4_mask_to_prefix(mask: Ipv4Addr) -> Result<u8, IpNetworkError> {
-    let mask = u32::from(mask);
+    match ipv4_mask_to_prefix_checked(mask) {
+        Some(prefix) => Ok(prefix),
+        None => Err(IpNetworkError::InvalidPrefix),
+    }
+}
+
+/// Converts a `Ipv4Addr` network mask into a prefix.
+///
+/// If the mask is invalid this will return `None`. This is useful in const contexts where
+/// [`Option::unwrap`] may be called to trigger a compile-time error if the prefix is invalid.
+pub const fn ipv4_mask_to_prefix_checked(mask: Ipv4Addr) -> Option<u8> {
+    let mask = mask.to_bits();
 
     let prefix = (!mask).leading_zeros() as u8;
-    if (u64::from(mask) << prefix) & 0xffff_ffff != 0 {
-        Err(IpNetworkError::InvalidPrefix)
+    if ((mask as u64) << prefix) & 0xffff_ffff != 0 {
+        None
     } else {
-        Ok(prefix)
+        Some(prefix)
     }
 }
 
@@ -275,6 +431,18 @@ mod test {
         assert!(net.is_err());
     }
 
+    #[test]
+    fn create_checked_v4() {
+        let cidr = Ipv4Network::new_checked(Ipv4Addr::new(77, 88, 21, 11), 24).unwrap();
+        assert_eq!(cidr.prefix(), 24);
+    }
+
+    #[test]
+    #[should_panic]
+    fn try_create_invalid_checked_v4() {
+        Ipv4Network::new_checked(Ipv4Addr::new(0, 0, 0, 0), 33).unwrap();
+    }
+
     #[test]
     fn parse_v4_24bit() {
         let cidr: Ipv4Network = "127.1.0.0/24".parse().unwrap();
@@ -357,6 +525,7 @@ mod test {
     }
 
     #[test]
+    #[allow(dropping_copy_types)]
     fn copy_compatibility_v4() {
         let net = Ipv4Network::new(Ipv4Addr::new(127, 0, 0, 1), 16).unwrap();
         mem::drop(net);
@@ -416,12 +585,31 @@ mod test {
     fn iterator_v4_huge() {
         let cidr: Ipv4Network = "0/0".parse().unwrap();
         let mut iter = cidr.iter();
-        for i in 0..(u32::max_value() as u64 + 1) {
+        for i in 0..(u32::MAX as u64 + 1) {
             assert_eq!(i as u32, u32::from(iter.next().unwrap()));
         }
         assert_eq!(None, iter.next());
     }
 
+    #[test]
+    fn iterator_v4_size_hint() {
+        let cidr: Ipv4Network = "192.168.0.0/24".parse().unwrap();
+        let mut iter = cidr.iter();
+        assert_eq!((256, Some(256)), iter.size_hint());
+        iter.next();
+        assert_eq!((255, Some(255)), iter.size_hint());
+
+        let cidr: Ipv4Network = "192.168.0.0/32".parse().unwrap();
+        let mut iter = cidr.iter();
+        assert_eq!((1, Some(1)), iter.size_hint());
+        iter.next();
+        assert_eq!((0, None), iter.size_hint());
+
+        let cidr: Ipv4Network = "192.168.0.0/0".parse().unwrap();
+        let iter = cidr.iter();
+        assert_eq!((4294967295, Some(4294967295)), iter.size_hint());
+    }
+
     #[test]
     fn v4_mask_to_prefix() {
         let mask = Ipv4Addr::new(255, 255, 255, 128);
@@ -429,6 +617,22 @@ mod test {
         assert_eq!(prefix, 25);
     }
 
+    /// Parse netmask as well as prefix
+    #[test]
+    fn parse_netmask() {
+        let from_netmask: Ipv4Network = "192.168.1.0/255.255.255.0".parse().unwrap();
+        let from_prefix: Ipv4Network = "192.168.1.0/24".parse().unwrap();
+        assert_eq!(from_netmask, from_prefix);
+    }
+
+    #[test]
+    fn parse_netmask_broken_v4() {
+        assert_eq!(
+            "192.168.1.0/255.0.255.0".parse::<Ipv4Network>(),
+            Err(IpNetworkError::InvalidPrefix)
+        );
+    }
+
     #[test]
     fn invalid_v4_mask_to_prefix() {
         let mask = Ipv4Addr::new(255, 0, 255, 0);
@@ -436,6 +640,24 @@ mod test {
         assert!(prefix.is_err());
     }
 
+    #[test]
+    fn ipv4network_with_netmask() {
+        {
+            // Positive test-case.
+            let addr = Ipv4Addr::new(127, 0, 0, 1);
+            let mask = Ipv4Addr::new(255, 0, 0, 0);
+            let net = Ipv4Network::with_netmask(addr, mask).unwrap();
+            let expected = Ipv4Network::new(Ipv4Addr::new(127, 0, 0, 1), 8).unwrap();
+            assert_eq!(net, expected);
+        }
+        {
+            // Negative test-case.
+            let addr = Ipv4Addr::new(127, 0, 0, 1);
+            let mask = Ipv4Addr::new(255, 0, 255, 0);
+            Ipv4Network::with_netmask(addr, mask).unwrap_err();
+        }
+    }
+
     #[test]
     fn ipv4network_from_ipv4addr() {
         let net = Ipv4Network::from(Ipv4Addr::new(127, 0, 0, 1));
@@ -454,4 +676,121 @@ mod test {
         fn assert_sync<T: Sync>() {}
         assert_sync::<Ipv4Network>();
     }
+
+    // Tests from cpython https://github.com/python/cpython/blob/e9bc4172d18db9c182d8e04dd7b033097a994c06/Lib/test/test_ipaddress.py
+    #[test]
+    fn test_is_subnet_of() {
+        let mut test_cases: HashMap<(Ipv4Network, Ipv4Network), bool> = HashMap::new();
+
+        test_cases.insert(
+            (
+                "10.0.0.0/30".parse().unwrap(),
+                "10.0.1.0/24".parse().unwrap(),
+            ),
+            false,
+        );
+        test_cases.insert(
+            (
+                "10.0.0.0/30".parse().unwrap(),
+                "10.0.0.0/24".parse().unwrap(),
+            ),
+            true,
+        );
+        test_cases.insert(
+            (
+                "10.0.0.0/30".parse().unwrap(),
+                "10.0.1.0/24".parse().unwrap(),
+            ),
+            false,
+        );
+        test_cases.insert(
+            (
+                "10.0.1.0/24".parse().unwrap(),
+                "10.0.0.0/30".parse().unwrap(),
+            ),
+            false,
+        );
+
+        for (key, val) in test_cases.iter() {
+            let (src, dest) = (key.0, key.1);
+            assert_eq!(
+                src.is_subnet_of(dest),
+                *val,
+                "testing with {src} and {dest}"
+            );
+        }
+    }
+
+    #[test]
+    fn test_is_supernet_of() {
+        let mut test_cases: HashMap<(Ipv4Network, Ipv4Network), bool> = HashMap::new();
+
+        test_cases.insert(
+            (
+                "10.0.0.0/30".parse().unwrap(),
+                "10.0.1.0/24".parse().unwrap(),
+            ),
+            false,
+        );
+        test_cases.insert(
+            (
+                "10.0.0.0/30".parse().unwrap(),
+                "10.0.0.0/24".parse().unwrap(),
+            ),
+            false,
+        );
+        test_cases.insert(
+            (
+                "10.0.0.0/30".parse().unwrap(),
+                "10.0.1.0/24".parse().unwrap(),
+            ),
+            false,
+        );
+        test_cases.insert(
+            (
+                "10.0.0.0/24".parse().unwrap(),
+                "10.0.0.0/30".parse().unwrap(),
+            ),
+            true,
+        );
+
+        for (key, val) in test_cases.iter() {
+            let (src, dest) = (key.0, key.1);
+            assert_eq!(
+                src.is_supernet_of(dest),
+                *val,
+                "testing with {src} and {dest}"
+            );
+        }
+    }
+
+    #[test]
+    fn test_overlaps() {
+        let other: Ipv4Network = "1.2.3.0/30".parse().unwrap();
+        let other2: Ipv4Network = "1.2.2.0/24".parse().unwrap();
+        let other3: Ipv4Network = "1.2.2.64/26".parse().unwrap();
+
+        let skynet: Ipv4Network = "1.2.3.0/24".parse().unwrap();
+        assert!(skynet.overlaps(other));
+        assert!(!skynet.overlaps(other2));
+        assert!(other2.overlaps(other3));
+    }
+
+    #[test]
+    fn edges() {
+        let low: Ipv4Network = "0.0.0.0/24".parse().unwrap();
+        let low_addrs: Vec<Ipv4Addr> = low.iter().collect();
+        assert_eq!(256, low_addrs.len());
+        assert_eq!("0.0.0.0".parse::<Ipv4Addr>().unwrap(), low_addrs[0]);
+        assert_eq!("0.0.0.255".parse::<Ipv4Addr>().unwrap(), low_addrs[255]);
+
+        let high: Ipv4Network = "255.255.255.0/24".parse().unwrap();
+        let high_addrs: Vec<Ipv4Addr> = high.iter().collect();
+        assert_eq!(256, high_addrs.len());
+        assert_eq!("255.255.255.0".parse::<Ipv4Addr>().unwrap(), high_addrs[0]);
+        assert_eq!(
+            "255.255.255.255".parse::<Ipv4Addr>().unwrap(),
+            high_addrs[255]
+        );
+    }
 }

src/ipv6.rs

@@ -1,11 +1,6 @@
-use std::cmp;
-use std::fmt;
-use std::net::Ipv6Addr;
-use std::str::FromStr;
-
-use serde::{de, Deserialize, Deserializer, Serialize, Serializer};
-
-use common::{cidr_parts, parse_prefix, IpNetworkError};
+use crate::error::IpNetworkError;
+use crate::parse::{cidr_parts, parse_prefix};
+use std::{convert::TryFrom, fmt, net::Ipv6Addr, str::FromStr};
 
 const IPV6_BITS: u8 = 128;
 const IPV6_SEGMENT_BITS: u8 = 16;
@@ -17,42 +12,140 @@ pub struct Ipv6Network {
     prefix: u8,
 }
 
-impl<'de> Deserialize<'de> for Ipv6Network {
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for Ipv6Network {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
-        D: Deserializer<'de>,
+        D: serde::Deserializer<'de>,
     {
-        let s = <&str>::deserialize(deserializer)?;
-        Ipv6Network::from_str(s).map_err(de::Error::custom)
+        let s = <String>::deserialize(deserializer)?;
+        Ipv6Network::from_str(&s).map_err(serde::de::Error::custom)
     }
 }
 
-impl Serialize for Ipv6Network {
+#[cfg(feature = "serde")]
+impl serde::Serialize for Ipv6Network {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
-        S: Serializer,
+        S: serde::Serializer,
     {
-        serializer.serialize_str(&self.to_string())
+        serializer.collect_str(self)
+    }
+}
+
+#[cfg(feature = "schemars")]
+impl schemars::JsonSchema for Ipv6Network {
+    fn schema_name() -> String {
+        "Ipv6Network".to_string()
+    }
+
+    fn json_schema(_: &mut schemars::gen::SchemaGenerator) -> schemars::schema::Schema {
+        schemars::schema::SchemaObject {
+            instance_type: Some(schemars::schema::InstanceType::String.into()),
+            string: Some(Box::new(schemars::schema::StringValidation {
+                pattern: Some(
+                    concat!(
+                        r#"^("#,
+                        r#"([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}"#,
+                        r#"|([0-9a-fA-F]{1,4}:){1,7}:"#,
+                        r#"|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}"#,
+                        r#"|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}"#,
+                        r#"|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}"#,
+                        r#"|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}"#,
+                        r#"|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}"#,
+                        r#"|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})"#,
+                        r#"|:((:[0-9a-fA-F]{1,4}){1,7}|:)"#,
+                        r#"|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}"#,
+                        r#"|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])"#,
+                        r#"|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])"#,
+                        r#"")[/](12[0-8]|1[0-1][0-9]|[0-9]?[0-9])$"#,
+                    ).to_string(),
+                ),
+                ..Default::default()
+            })),
+            extensions: [("x-rust-type".to_string(), "ipnetwork::Ipv6Network".into())]
+                .iter()
+                .cloned()
+                .collect(),
+            ..Default::default()
+        }
+        .into()
     }
 }
 
 impl Ipv6Network {
     /// Constructs a new `Ipv6Network` from any `Ipv6Addr` and a prefix denoting the network size.
+    ///
     /// If the prefix is larger than 128 this will return an `IpNetworkError::InvalidPrefix`.
-    pub fn new(addr: Ipv6Addr, prefix: u8) -> Result<Ipv6Network, IpNetworkError> {
-        if prefix > IPV6_BITS {
-            Err(IpNetworkError::InvalidPrefix)
-        } else {
-            Ok(Ipv6Network { addr, prefix })
+    pub const fn new(addr: Ipv6Addr, prefix: u8) -> Result<Ipv6Network, IpNetworkError> {
+        match Ipv6Network::new_checked(addr, prefix) {
+            Some(a) => Ok(a),
+            None => Err(IpNetworkError::InvalidPrefix),
         }
     }
 
+    /// Constructs a new `Ipv6Network` from any `Ipv6Addr`, and a prefix denoting the network size.
+    ///
+    /// If the prefix is larger than 128 this will return `None`. This is useful in const contexts,
+    /// where [`Option::unwrap`] may be called to trigger a compile-time error in case the prefix
+    /// is an unexpected value.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::net::Ipv6Addr;
+    /// use ipnetwork::Ipv6Network;
+    ///
+    /// const PREFIX: u8 = 64;
+    /// const ADDR: Ipv6Addr = Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0);
+    ///
+    /// // Okay!
+    /// const NETWORK: Ipv6Network = Ipv6Network::new_checked(ADDR, PREFIX).unwrap();
+    /// assert_eq!(NETWORK.prefix(), PREFIX);
+    /// ```
+    ///
+    /// ```should_panic
+    /// use std::net::Ipv6Addr;
+    /// use ipnetwork::Ipv6Network;
+    ///
+    /// // Prefix is greater than 128.
+    /// const PREFIX: u8 = 128 + 1;
+    /// const ADDR: Ipv6Addr = Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0);
+    ///
+    /// // This fails!
+    /// const NETWORK: Option<Ipv6Network> = Ipv6Network::new_checked(ADDR, PREFIX);
+    /// assert_eq!(NETWORK.unwrap().prefix(), PREFIX);
+    /// ```
+    pub const fn new_checked(addr: Ipv6Addr, prefix: u8) -> Option<Ipv6Network> {
+        if prefix > IPV6_BITS {
+            None
+        } else {
+            Some(Ipv6Network { addr, prefix })
+        }
+    }
+
+    /// Constructs a new `Ipv6Network` from a network address and a network mask.
+    ///
+    /// If the netmask is not valid this will return an `IpNetworkError::InvalidPrefix`.
+    pub fn with_netmask(netaddr: Ipv6Addr, netmask: Ipv6Addr) -> Result<Self, IpNetworkError> {
+        let prefix = ipv6_mask_to_prefix(netmask)?;
+        let net = Self {
+            addr: netaddr,
+            prefix,
+        };
+        Ok(net)
+    }
+
     /// Returns an iterator over `Ipv6Network`. Each call to `next` will return the next
     /// `Ipv6Addr` in the given network. `None` will be returned when there are no more
     /// addresses.
+    ///
+    /// # Warning
+    ///
+    /// This can return up to 2^128 addresses, which will take a _long_ time to iterate over.
     pub fn iter(&self) -> Ipv6NetworkIterator {
         let dec = u128::from(self.addr);
-        let max = u128::max_value();
+        let max = u128::MAX;
         let prefix = self.prefix;
 
         let mask = max.checked_shl(u32::from(IPV6_BITS - prefix)).unwrap_or(0);
@@ -62,55 +155,37 @@ impl Ipv6Network {
         let end: u128 = dec | mask;
 
         Ipv6NetworkIterator {
-            next: start,
-            end: end,
+            next: Some(start),
+            end,
         }
     }
 
-    /// Returns the address of the network denoted by this `Ipv6Network`.
-    /// This means the lowest possible IPv6 address inside of the network.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::net::Ipv6Addr;
-    /// use ipnetwork::Ipv6Network;
-    ///
-    /// let net: Ipv6Network = "2001:db8::/96".parse().unwrap();
-    /// assert_eq!(net.network(), Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0));
-    /// ```
-    pub fn network(&self) -> Ipv6Addr {
-        let mask = u128::from(self.mask());
-        let ip = u128::from(self.addr) & mask;
-        Ipv6Addr::from(ip)
-    }
-
-    /// Returns the broadcast address of this `Ipv6Network`.
-    /// This means the highest possible IPv4 address inside of the network.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::net::Ipv6Addr;
-    /// use ipnetwork::Ipv6Network;
-    ///
-    /// let net: Ipv6Network = "2001:db8::/96".parse().unwrap();
-    /// assert_eq!(net.broadcast(), Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0xffff, 0xffff));
-    /// ```
-    pub fn broadcast(&self) -> Ipv6Addr {
-        let mask = u128::from(self.mask());
-        let broadcast = u128::from(self.addr) | !mask;
-        Ipv6Addr::from(broadcast)
-    }
-
-    pub fn ip(&self) -> Ipv6Addr {
+    pub const fn ip(&self) -> Ipv6Addr {
         self.addr
     }
 
-    pub fn prefix(&self) -> u8 {
+    pub const fn prefix(&self) -> u8 {
         self.prefix
     }
 
+    /// Checks if the given `Ipv6Network` is a subnet of the other.
+    pub fn is_subnet_of(self, other: Ipv6Network) -> bool {
+        other.ip() <= self.ip() && other.broadcast() >= self.broadcast()
+    }
+
+    /// Checks if the given `Ipv6Network` is a supernet of the other.
+    pub fn is_supernet_of(self, other: Ipv6Network) -> bool {
+        other.is_subnet_of(self)
+    }
+
+    /// Checks if the given `Ipv6Network` is partly contained in other.
+    pub fn overlaps(self, other: Ipv6Network) -> bool {
+        other.contains(self.ip())
+            || other.contains(self.broadcast())
+            || self.contains(other.ip())
+            || self.contains(other.broadcast())
+    }
+
     /// Returns the mask for this `Ipv6Network`.
     /// That means the `prefix` most significant bits will be 1 and the rest 0
     ///
@@ -125,15 +200,50 @@ impl Ipv6Network {
     /// let net: Ipv6Network = "ff01::0/32".parse().unwrap();
     /// assert_eq!(net.mask(), Ipv6Addr::new(0xffff, 0xffff, 0, 0, 0, 0, 0, 0));
     /// ```
-    pub fn mask(&self) -> Ipv6Addr {
-        // Ipv6Addr::from is only implemented for [u8; 16]
-        let mut segments = [0; 16];
-        for (i, segment) in segments.iter_mut().enumerate() {
-            let bits_remaining = self.prefix.saturating_sub(i as u8 * 8);
-            let set_bits = cmp::min(bits_remaining, 8);
-            *segment = !(0xff as u16 >> set_bits) as u8;
+    pub const fn mask(&self) -> Ipv6Addr {
+        debug_assert!(self.prefix <= IPV6_BITS);
+
+        if self.prefix == 0 {
+            return Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0);
         }
-        Ipv6Addr::from(segments)
+        let mask = u128::MAX << (IPV6_BITS - self.prefix);
+        Ipv6Addr::from_bits(mask)
+    }
+
+    /// Returns the address of the network denoted by this `Ipv6Network`.
+    /// This means the lowest possible IPv6 address inside of the network.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::net::Ipv6Addr;
+    /// use ipnetwork::Ipv6Network;
+    ///
+    /// let net: Ipv6Network = "2001:db8::/96".parse().unwrap();
+    /// assert_eq!(net.network(), Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0));
+    /// ```
+    pub const fn network(&self) -> Ipv6Addr {
+        let mask = self.mask().to_bits();
+        let network = self.addr.to_bits() & mask;
+        Ipv6Addr::from_bits(network)
+    }
+
+    /// Returns the broadcast address of this `Ipv6Network`.
+    /// This means the highest possible IPv4 address inside of the network.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::net::Ipv6Addr;
+    /// use ipnetwork::Ipv6Network;
+    ///
+    /// let net: Ipv6Network = "2001:db8::/96".parse().unwrap();
+    /// assert_eq!(net.broadcast(), Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0xffff, 0xffff));
+    /// ```
+    pub const fn broadcast(&self) -> Ipv6Addr {
+        let mask = self.mask().to_bits();
+        let broadcast = self.addr.to_bits() | !mask;
+        Ipv6Addr::from_bits(broadcast)
     }
 
     /// Checks if a given `Ipv6Addr` is in this `Ipv6Network`
@@ -148,15 +258,12 @@ impl Ipv6Network {
     /// assert!(net.contains(Ipv6Addr::new(0xff01, 0, 0, 0, 0, 0, 0, 0x1)));
     /// assert!(!net.contains(Ipv6Addr::new(0xffff, 0, 0, 0, 0, 0, 0, 0x1)));
     /// ```
-    pub fn contains(&self, ip: Ipv6Addr) -> bool {
-        let a = self.addr.segments();
-        let b = ip.segments();
-        let addrs = Iterator::zip(a.iter(), b.iter());
-        self.mask()
-            .segments()
-            .iter()
-            .zip(addrs)
-            .all(|(mask, (a, b))| a & mask == b & mask)
+    #[inline]
+    pub const fn contains(&self, ip: Ipv6Addr) -> bool {
+        let ip = ip.to_bits();
+        let net = self.network().to_bits();
+        let mask = self.mask().to_bits();
+        (ip & mask) == net
     }
 
     /// Returns number of possible host addresses in this `Ipv6Network`.
@@ -174,25 +281,70 @@ impl Ipv6Network {
     /// assert_eq!(tinynet.size(), 1);
     /// ```
     pub fn size(&self) -> u128 {
-        let host_bits = u32::from(IPV6_BITS - self.prefix);
-        (2 as u128).pow(host_bits)
+        debug_assert!(self.prefix <= IPV6_BITS);
+
+        if self.prefix == 0 {
+            return u128::MAX;
+        }
+        1 << (IPV6_BITS - self.prefix)
+    }
+
+    /// Returns the `n`:th address within this network.
+    /// The addresses are indexed from 0 and `n` must be smaller than the size of the network.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::net::Ipv6Addr;
+    /// use ipnetwork::Ipv6Network;
+    ///
+    /// let net: Ipv6Network = "ff01::0/32".parse().unwrap();
+    /// assert_eq!(net.nth(0).unwrap(), "ff01::0".parse::<Ipv6Addr>().unwrap());
+    /// assert_eq!(net.nth(255).unwrap(), "ff01::ff".parse::<Ipv6Addr>().unwrap());
+    /// assert_eq!(net.nth(65538).unwrap(), "ff01::1:2".parse::<Ipv6Addr>().unwrap());
+    /// assert!(net.nth(net.size()).is_none());
+    /// ```
+    pub fn nth(self, n: u128) -> Option<Ipv6Addr> {
+        if n < self.size() {
+            let net = u128::from(self.network());
+            Some(Ipv6Addr::from(net + n))
+        } else {
+            None
+        }
     }
 }
 
+/// Creates an `Ipv6Network` from parsing a string in CIDR notation.
+///
+/// # Examples
+///
+/// ```
+/// use std::net::Ipv6Addr;
+/// use ipnetwork::Ipv6Network;
+///
+/// let new = Ipv6Network::new(Ipv6Addr::new(0xff01, 0, 0, 0x17, 0, 0, 0, 0x2), 65).unwrap();
+/// let from_cidr: Ipv6Network = "FF01:0:0:17:0:0:0:2/65".parse().unwrap();
+/// assert_eq!(new.ip(), from_cidr.ip());
+/// assert_eq!(new.prefix(), from_cidr.prefix());
+/// ```
 impl FromStr for Ipv6Network {
     type Err = IpNetworkError;
-    fn from_str(s: &str) -> Result<Ipv6Network, IpNetworkError> {
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
         let (addr_str, prefix_str) = cidr_parts(s)?;
-        let addr = Ipv6Addr::from_str(addr_str)
-            .map_err(|_| IpNetworkError::InvalidAddr(addr_str.to_string()))?;
-        let prefix = match prefix_str {
-            Some(v) => parse_prefix(v, IPV6_BITS)?,
-            None => IPV6_BITS,
-        };
+        let addr = Ipv6Addr::from_str(addr_str)?;
+        let prefix = parse_prefix(prefix_str.unwrap_or(&IPV6_BITS.to_string()), IPV6_BITS)?;
         Ipv6Network::new(addr, prefix)
     }
 }
 
+impl TryFrom<&str> for Ipv6Network {
+    type Error = IpNetworkError;
+
+    fn try_from(s: &str) -> Result<Self, Self::Error> {
+        Ipv6Network::from_str(s)
+    }
+}
+
 impl From<Ipv6Addr> for Ipv6Network {
     fn from(a: Ipv6Addr) -> Ipv6Network {
         Ipv6Network {
@@ -202,8 +354,9 @@ impl From<Ipv6Addr> for Ipv6Network {
     }
 }
 
+#[derive(Clone, Debug)]
 pub struct Ipv6NetworkIterator {
-    next: u128,
+    next: Option<u128>,
     end: u128,
 }
 
@@ -211,18 +364,35 @@ impl Iterator for Ipv6NetworkIterator {
     type Item = Ipv6Addr;
 
     fn next(&mut self) -> Option<Ipv6Addr> {
-        if self.next <= self.end {
-            let next = Ipv6Addr::from(self.next);
-            self.next += 1;
-            Some(next)
-        } else {
+        let next = self.next?;
+        self.next = if next == self.end {
             None
+        } else {
+            Some(next + 1)
+        };
+        Some(next.into())
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        if let Some(n) = self.next {
+            let elms = (self.end - n + 1) as usize;
+            (elms, Some(elms))
+        } else {
+            (0, None)
         }
     }
 }
 
+impl IntoIterator for &'_ Ipv6Network {
+    type IntoIter = Ipv6NetworkIterator;
+    type Item = Ipv6Addr;
+    fn into_iter(self) -> Ipv6NetworkIterator {
+        self.iter()
+    }
+}
+
 impl fmt::Display for Ipv6Network {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(fmt, "{}/{}", self.ip(), self.prefix())
     }
 }
@@ -230,12 +400,25 @@ impl fmt::Display for Ipv6Network {
 /// Converts a `Ipv6Addr` network mask into a prefix.
 /// If the mask is invalid this will return an `IpNetworkError::InvalidPrefix`.
 pub fn ipv6_mask_to_prefix(mask: Ipv6Addr) -> Result<u8, IpNetworkError> {
+    match ipv6_mask_to_prefix_checked(mask) {
+        Some(prefix) => Ok(prefix),
+        None => Err(IpNetworkError::InvalidPrefix),
+    }
+}
+
+/// Converts a `Ipv6Addr` network mask into a prefix.
+///
+/// If the mask is invalid this will return `None`. This is useful in const contexts where
+/// [`Option::unwrap`] may be called to trigger a compile-time error if the prefix is invalid.
+pub const fn ipv6_mask_to_prefix_checked(mask: Ipv6Addr) -> Option<u8> {
     let mask = mask.segments();
-    let mut mask_iter = mask.into_iter();
 
     // Count the number of set bits from the start of the address
     let mut prefix = 0;
-    for &segment in &mut mask_iter {
+    let mut i = 0;
+    while i < mask.len() {
+        let segment = mask[i];
+        i += 1;
         if segment == 0xffff {
             prefix += IPV6_SEGMENT_BITS;
         } else if segment == 0 {
@@ -245,7 +428,7 @@ pub fn ipv6_mask_to_prefix(mask: Ipv6Addr) -> Result<u8, IpNetworkError> {
             let prefix_bits = (!segment).leading_zeros() as u8;
             // Check that the remainder of the bits are all unset
             if segment << prefix_bits != 0 {
-                return Err(IpNetworkError::InvalidPrefix);
+                return None;
             }
             prefix += prefix_bits;
             break;
@@ -253,18 +436,21 @@ pub fn ipv6_mask_to_prefix(mask: Ipv6Addr) -> Result<u8, IpNetworkError> {
     }
 
     // Now check all the remaining bits are unset
-    for &segment in mask_iter {
+    while i < mask.len() {
+        let segment = mask[i];
+        i += 1;
         if segment != 0 {
-            return Err(IpNetworkError::InvalidPrefix);
+            return None;
         }
     }
 
-    Ok(prefix)
+    Some(prefix)
 }
 
 #[cfg(test)]
 mod test {
     use super::*;
+    use std::collections::HashMap;
     use std::net::Ipv6Addr;
 
     #[test]
@@ -273,12 +459,32 @@ mod test {
         assert_eq!(cidr.prefix(), 24);
     }
 
+    #[test]
+    fn parse_netmask_broken_v6() {
+        assert_eq!(
+            "FF01:0:0:17:0:0:0:2/255.255.255.0".parse::<Ipv6Network>(),
+            Err(IpNetworkError::InvalidPrefix)
+        );
+    }
+
     #[test]
     fn create_v6_invalid_prefix() {
         let cidr = Ipv6Network::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1), 129);
         assert!(cidr.is_err());
     }
 
+    #[test]
+    fn create_checked_v6() {
+        let cidr = Ipv6Network::new_checked(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1), 24).unwrap();
+        assert_eq!(cidr.prefix(), 24);
+    }
+
+    #[test]
+    #[should_panic]
+    fn try_create_invalid_checked_v6() {
+        Ipv6Network::new_checked(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1), 129).unwrap();
+    }
+
     #[test]
     fn parse_v6() {
         let cidr: Ipv6Network = "::1/0".parse().unwrap();
@@ -353,6 +559,25 @@ mod test {
         assert!(prefix.is_err());
     }
 
+    #[test]
+    fn ipv6network_with_netmask() {
+        {
+            // Positive test-case.
+            let addr = Ipv6Addr::new(0xff01, 0, 0, 0x17, 0, 0, 0, 0x2);
+            let mask = Ipv6Addr::new(0xffff, 0xffff, 0xffff, 0, 0, 0, 0, 0);
+            let net = Ipv6Network::with_netmask(addr, mask).unwrap();
+            let expected =
+                Ipv6Network::new(Ipv6Addr::new(0xff01, 0, 0, 0x17, 0, 0, 0, 0x2), 48).unwrap();
+            assert_eq!(net, expected);
+        }
+        {
+            // Negative test-case.
+            let addr = Ipv6Addr::new(0xff01, 0, 0, 0x17, 0, 0, 0, 0x2);
+            let mask = Ipv6Addr::new(0, 0, 0xffff, 0xffff, 0, 0, 0, 0);
+            Ipv6Network::with_netmask(addr, mask).unwrap_err();
+        }
+    }
+
     #[test]
     fn iterator_v6() {
         let cidr: Ipv6Network = "2001:db8::/126".parse().unwrap();
@@ -396,6 +621,18 @@ mod test {
         assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 2), iter.next().unwrap());
     }
 
+    #[test]
+    fn iterator_v6_size_hint() {
+        let cidr: Ipv6Network = "2001:db8::/128".parse().unwrap();
+        let mut iter = cidr.iter();
+        assert_eq!((1, Some(1)), iter.size_hint());
+        assert_eq!(
+            Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0),
+            iter.next().unwrap()
+        );
+        assert_eq!((0, None), iter.size_hint());
+    }
+
     #[test]
     fn network_v6() {
         let cidr: Ipv6Network = "2001:db8::0/96".parse().unwrap();
@@ -436,4 +673,144 @@ mod test {
         fn assert_sync<T: Sync>() {}
         assert_sync::<Ipv6Network>();
     }
+
+    // Tests from cpython https://github.com/python/cpython/blob/e9bc4172d18db9c182d8e04dd7b033097a994c06/Lib/test/test_ipaddress.py
+    #[test]
+    fn test_is_subnet_of() {
+        let mut test_cases: HashMap<(Ipv6Network, Ipv6Network), bool> = HashMap::new();
+
+        test_cases.insert(
+            (
+                "2000:999::/56".parse().unwrap(),
+                "2000:aaa::/48".parse().unwrap(),
+            ),
+            false,
+        );
+        test_cases.insert(
+            (
+                "2000:aaa::/56".parse().unwrap(),
+                "2000:aaa::/48".parse().unwrap(),
+            ),
+            true,
+        );
+        test_cases.insert(
+            (
+                "2000:bbb::/56".parse().unwrap(),
+                "2000:aaa::/48".parse().unwrap(),
+            ),
+            false,
+        );
+        test_cases.insert(
+            (
+                "2000:aaa::/48".parse().unwrap(),
+                "2000:aaa::/56".parse().unwrap(),
+            ),
+            false,
+        );
+
+        for (key, val) in test_cases.iter() {
+            let (src, dest) = (key.0, key.1);
+            assert_eq!(
+                src.is_subnet_of(dest),
+                *val,
+                "testing with {src} and {dest}"
+            );
+        }
+    }
+
+    #[test]
+    fn test_is_supernet_of() {
+        let mut test_cases: HashMap<(Ipv6Network, Ipv6Network), bool> = HashMap::new();
+
+        test_cases.insert(
+            (
+                "2000:999::/56".parse().unwrap(),
+                "2000:aaa::/48".parse().unwrap(),
+            ),
+            false,
+        );
+        test_cases.insert(
+            (
+                "2000:aaa::/56".parse().unwrap(),
+                "2000:aaa::/48".parse().unwrap(),
+            ),
+            false,
+        );
+        test_cases.insert(
+            (
+                "2000:bbb::/56".parse().unwrap(),
+                "2000:aaa::/48".parse().unwrap(),
+            ),
+            false,
+        );
+        test_cases.insert(
+            (
+                "2000:aaa::/48".parse().unwrap(),
+                "2000:aaa::/56".parse().unwrap(),
+            ),
+            true,
+        );
+
+        for (key, val) in test_cases.iter() {
+            let (src, dest) = (key.0, key.1);
+            assert_eq!(
+                src.is_supernet_of(dest),
+                *val,
+                "testing with {src} and {dest}"
+            );
+        }
+    }
+
+    #[test]
+    fn test_overlaps() {
+        let other: Ipv6Network = "2001:DB8:ACAD::1/64".parse().unwrap();
+        let other2: Ipv6Network = "2001:DB8:ACAD::20:2/64".parse().unwrap();
+
+        assert!(other2.overlaps(other));
+    }
+
+    #[test]
+    fn edges() {
+        let low: Ipv6Network = "::0/120".parse().unwrap();
+        let low_addrs: Vec<Ipv6Addr> = low.iter().collect();
+        assert_eq!(256, low_addrs.len());
+
+        let high: Ipv6Network = "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ff00/120"
+            .parse()
+            .unwrap();
+        let high_addrs: Vec<Ipv6Addr> = high.iter().collect();
+        assert_eq!(256, high_addrs.len());
+    }
+
+    #[test]
+    fn test_nth_ipv6() {
+        let net = Ipv6Network::from_str("ff01::/32").unwrap();
+
+        assert_eq!(
+            net.nth(0).unwrap(),
+            Ipv6Addr::from_str("ff01:0:0:0:0:0:0:0").unwrap()
+        );
+        assert_eq!(
+            net.nth(255).unwrap(),
+            Ipv6Addr::from_str("ff01::ff").unwrap()
+        );
+        assert_eq!(
+            net.nth(65538).unwrap(),
+            Ipv6Addr::from_str("ff01::1:2").unwrap()
+        );
+        assert_eq!(net.nth(net.size()), None);
+    }
+
+    #[test]
+    fn test_mask_with_prefix_0() {
+        let network: Ipv6Network = "0::/0".parse().unwrap();
+        let mask = network.mask();
+        assert_eq!(mask, Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0));
+    }
+
+    #[test]
+    fn test_size_with_prefix_0() {
+        let network: Ipv6Network = "0::/0".parse().unwrap();
+        assert_eq!(network.size(), u128::MAX);
+    }
 }

src/lib.rs

@@ -1,27 +1,32 @@
 //! The `ipnetwork` crate provides a set of APIs to work with IP CIDRs in
-//! Rust. Implementation for IPv4 is more or less stable, IPv6 implementation
-//! is still WIP.
-#![cfg_attr(feature = "dev", feature(plugin))]
-#![cfg_attr(feature = "dev", plugin(clippy))]
+//! Rust.
 #![crate_type = "lib"]
-#![doc(html_root_url = "https://docs.rs/ipnetwork/0.14.0")]
+#![deny(
+    missing_debug_implementations,
+    unsafe_code,
+    unused_extern_crates,
+    unused_import_braces
+)]
 
-extern crate serde;
+use std::{
+    convert::TryFrom,
+    fmt,
+    net::{IpAddr, Ipv4Addr, Ipv6Addr},
+    str::FromStr,
+};
 
-use std::fmt;
-use std::net::IpAddr;
-
-mod common;
+mod error;
 mod ipv4;
 mod ipv6;
+mod parse;
+mod size;
 
-use std::str::FromStr;
-
-use serde::{de, Deserialize, Deserializer, Serialize, Serializer};
-
-pub use common::IpNetworkError;
-pub use ipv4::{ipv4_mask_to_prefix, Ipv4Network};
-pub use ipv6::{ipv6_mask_to_prefix, Ipv6Network};
+pub use crate::error::{IpNetworkError, NetworkSizeError};
+pub use crate::ipv4::Ipv4NetworkIterator;
+pub use crate::ipv4::{ipv4_mask_to_prefix, ipv4_mask_to_prefix_checked, Ipv4Network};
+pub use crate::ipv6::Ipv6NetworkIterator;
+pub use crate::ipv6::{ipv6_mask_to_prefix, ipv6_mask_to_prefix_checked, Ipv6Network};
+pub use crate::size::NetworkSize;
 
 /// Represents a generic network range. This type can have two variants:
 /// the v4 and the v6 case.
@@ -31,30 +36,93 @@ pub enum IpNetwork {
     V6(Ipv6Network),
 }
 
-impl<'de> Deserialize<'de> for IpNetwork {
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for IpNetwork {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
-        D: Deserializer<'de>,
+        D: serde::Deserializer<'de>,
     {
         let s = <String>::deserialize(deserializer)?;
-        IpNetwork::from_str(&s).map_err(de::Error::custom)
+        IpNetwork::from_str(&s).map_err(serde::de::Error::custom)
     }
 }
 
-impl Serialize for IpNetwork {
+#[cfg(feature = "serde")]
+impl serde::Serialize for IpNetwork {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
-        S: Serializer,
+        S: serde::Serializer,
     {
-        serializer.serialize_str(&self.to_string())
+        serializer.collect_str(self)
     }
 }
 
-/// Represents a generic network size. For IPv4, the max size is a u32 and for IPv6, it is a u128
-#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
-pub enum NetworkSize {
-    V4(u32),
-    V6(u128),
+#[cfg(feature = "schemars")]
+impl schemars::JsonSchema for IpNetwork {
+    fn schema_name() -> String {
+        "IpNetwork".to_string()
+    }
+
+    fn json_schema(gen: &mut schemars::gen::SchemaGenerator) -> schemars::schema::Schema {
+        schemars::schema::SchemaObject {
+            metadata: Some(
+                schemars::schema::Metadata {
+                    ..Default::default()
+                }
+                .into(),
+            ),
+            subschemas: Some(
+                schemars::schema::SubschemaValidation {
+                    one_of: Some(vec![
+                        schemars::schema::SchemaObject {
+                            metadata: Some(
+                                schemars::schema::Metadata {
+                                    title: Some("v4".to_string()),
+                                    ..Default::default()
+                                }
+                                .into(),
+                            ),
+                            subschemas: Some(
+                                schemars::schema::SubschemaValidation {
+                                    all_of: Some(vec![gen.subschema_for::<Ipv4Network>()]),
+                                    ..Default::default()
+                                }
+                                .into(),
+                            ),
+                            ..Default::default()
+                        }
+                        .into(),
+                        schemars::schema::SchemaObject {
+                            metadata: Some(
+                                schemars::schema::Metadata {
+                                    title: Some("v6".to_string()),
+                                    ..Default::default()
+                                }
+                                .into(),
+                            ),
+                            subschemas: Some(
+                                schemars::schema::SubschemaValidation {
+                                    all_of: Some(vec![gen.subschema_for::<Ipv6Network>()]),
+                                    ..Default::default()
+                                }
+                                .into(),
+                            ),
+                            ..Default::default()
+                        }
+                        .into(),
+                    ]),
+                    ..Default::default()
+                }
+                .into(),
+            ),
+            extensions: [("x-rust-type".to_string(), "ipnetwork::IpNetwork".into())]
+                .iter()
+                .cloned()
+                .collect(),
+            ..Default::default()
+        }
+        .into()
+    }
 }
 
 impl IpNetwork {
@@ -69,8 +137,16 @@ impl IpNetwork {
         }
     }
 
+    /// Constructs a new `IpNetwork` from a network address and a network mask.
+    ///
+    /// If the netmask is not valid this will return an `IpNetworkError::InvalidPrefix`.
+    pub fn with_netmask(netaddr: IpAddr, netmask: IpAddr) -> Result<Self, IpNetworkError> {
+        let prefix = ip_mask_to_prefix(netmask)?;
+        Self::new(netaddr, prefix)
+    }
+
     /// Returns the IP part of a given `IpNetwork`
-    pub fn ip(&self) -> IpAddr {
+    pub const fn ip(&self) -> IpAddr {
         match *self {
             IpNetwork::V4(ref a) => IpAddr::V4(a.ip()),
             IpNetwork::V6(ref a) => IpAddr::V6(a.ip()),
@@ -89,7 +165,7 @@ impl IpNetwork {
     /// assert_eq!(IpNetwork::V6("ff01::0".parse().unwrap()).prefix(), 128u8);
     /// assert_eq!(IpNetwork::V6("ff01::0/32".parse().unwrap()).prefix(), 32u8);
     /// ```
-    pub fn prefix(&self) -> u8 {
+    pub const fn prefix(&self) -> u8 {
         match *self {
             IpNetwork::V4(ref a) => a.prefix(),
             IpNetwork::V6(ref a) => a.prefix(),
@@ -110,7 +186,7 @@ impl IpNetwork {
     /// let net: IpNetwork = "2001:db8::/96".parse().unwrap();
     /// assert_eq!(net.network(), Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0));
     /// ```
-    pub fn network(&self) -> IpAddr {
+    pub const fn network(&self) -> IpAddr {
         match *self {
             IpNetwork::V4(ref a) => IpAddr::V4(a.network()),
             IpNetwork::V6(ref a) => IpAddr::V6(a.network()),
@@ -129,7 +205,7 @@ impl IpNetwork {
     /// let net: Ipv4Network = "10.9.0.32/16".parse().unwrap();
     /// assert_eq!(net.broadcast(), Ipv4Addr::new(10, 9, 255, 255));
     /// ```
-    pub fn broadcast(&self) -> IpAddr {
+    pub const fn broadcast(&self) -> IpAddr {
         match *self {
             IpNetwork::V4(ref a) => IpAddr::V4(a.broadcast()),
             IpNetwork::V6(ref a) => IpAddr::V6(a.broadcast()),
@@ -155,7 +231,7 @@ impl IpNetwork {
     /// let v6_net: IpNetwork = "ff01::0/32".parse().unwrap();
     /// assert_eq!(v6_net.mask(), Ipv6Addr::new(0xffff, 0xffff, 0, 0, 0, 0, 0, 0));
     /// ```
-    pub fn mask(&self) -> IpAddr {
+    pub const fn mask(&self) -> IpAddr {
         match *self {
             IpNetwork::V4(ref a) => IpAddr::V4(a.mask()),
             IpNetwork::V6(ref a) => IpAddr::V6(a.mask()),
@@ -174,7 +250,7 @@ impl IpNetwork {
     /// assert_eq!(v4.is_ipv4(), true);
     /// assert_eq!(v4.is_ipv6(), false);
     ///```
-    pub fn is_ipv4(&self) -> bool {
+    pub const fn is_ipv4(&self) -> bool {
         match *self {
             IpNetwork::V4(_) => true,
             IpNetwork::V6(_) => false,
@@ -193,13 +269,17 @@ impl IpNetwork {
     /// assert_eq!(v6.is_ipv6(), true);
     /// assert_eq!(v6.is_ipv4(), false);
     ///```
-    pub fn is_ipv6(&self) -> bool {
+    pub const fn is_ipv6(&self) -> bool {
         match *self {
             IpNetwork::V4(_) => false,
             IpNetwork::V6(_) => true,
         }
     }
 
+    // TODO(abhishek) when TryFrom is stable, implement it for IpNetwork to
+    // variant conversions. Then use that to implement a generic is_subnet_of
+    // is_supernet_of, overlaps
+
     /// Checks if a given `IpAddr` is in this `IpNetwork`
     ///
     /// # Examples
@@ -216,7 +296,8 @@ impl IpNetwork {
     /// assert!(!net.contains(ip2));
     /// assert!(!net.contains(ip4));
     /// ```
-    pub fn contains(&self, ip: IpAddr) -> bool {
+    #[inline]
+    pub const fn contains(&self, ip: IpAddr) -> bool {
         match (*self, ip) {
             (IpNetwork::V4(net), IpAddr::V4(ip)) => net.contains(ip),
             (IpNetwork::V6(net), IpAddr::V6(ip)) => net.contains(ip),
@@ -241,6 +322,17 @@ impl IpNetwork {
             IpNetwork::V6(ref ip) => NetworkSize::V6(ip.size()),
         }
     }
+
+    /// Returns an iterator over the addresses contained in the network.
+    ///
+    /// This lists all the addresses in the network range, in ascending order.
+    pub fn iter(&self) -> IpNetworkIterator {
+        let inner = match self {
+            IpNetwork::V4(ip) => IpNetworkIteratorInner::V4(ip.iter()),
+            IpNetwork::V6(ip) => IpNetworkIteratorInner::V6(ip.iter()),
+        };
+        IpNetworkIterator { inner }
+    }
 }
 
 /// Tries to parse the given string into a `IpNetwork`. Will first try to parse
@@ -259,7 +351,7 @@ impl IpNetwork {
 /// ```
 impl FromStr for IpNetwork {
     type Err = IpNetworkError;
-    fn from_str(s: &str) -> Result<IpNetwork, IpNetworkError> {
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
         if let Ok(net) = Ipv4Network::from_str(s) {
             Ok(IpNetwork::V4(net))
         } else if let Ok(net) = Ipv6Network::from_str(s) {
@@ -270,6 +362,14 @@ impl FromStr for IpNetwork {
     }
 }
 
+impl TryFrom<&str> for IpNetwork {
+    type Error = IpNetworkError;
+
+    fn try_from(s: &str) -> Result<Self, Self::Error> {
+        IpNetwork::from_str(s)
+    }
+}
+
 impl From<Ipv4Network> for IpNetwork {
     fn from(v4: Ipv4Network) -> IpNetwork {
         IpNetwork::V4(v4)
@@ -282,17 +382,29 @@ impl From<Ipv6Network> for IpNetwork {
     }
 }
 
+impl From<Ipv4Addr> for IpNetwork {
+    fn from(addr: Ipv4Addr) -> IpNetwork {
+        IpNetwork::V4(Ipv4Network::from(addr))
+    }
+}
+
+impl From<Ipv6Addr> for IpNetwork {
+    fn from(addr: Ipv6Addr) -> IpNetwork {
+        IpNetwork::V6(Ipv6Network::from(addr))
+    }
+}
+
 impl From<IpAddr> for IpNetwork {
     fn from(addr: IpAddr) -> IpNetwork {
         match addr {
-            IpAddr::V4(a) => IpNetwork::V4(Ipv4Network::from(a)),
-            IpAddr::V6(a) => IpNetwork::V6(Ipv6Network::from(a)),
+            IpAddr::V4(a) => IpNetwork::from(a),
+            IpAddr::V6(a) => IpNetwork::from(a),
         }
     }
 }
 
 impl fmt::Display for IpNetwork {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match *self {
             IpNetwork::V4(net) => net.fmt(f),
             IpNetwork::V6(net) => net.fmt(f),
@@ -300,6 +412,41 @@ impl fmt::Display for IpNetwork {
     }
 }
 
+#[derive(Clone, Debug)]
+enum IpNetworkIteratorInner {
+    V4(Ipv4NetworkIterator),
+    V6(Ipv6NetworkIterator),
+}
+
+#[derive(Clone, Debug)]
+pub struct IpNetworkIterator {
+    inner: IpNetworkIteratorInner,
+}
+
+impl Iterator for IpNetworkIterator {
+    type Item = IpAddr;
+    fn next(&mut self) -> Option<IpAddr> {
+        match &mut self.inner {
+            IpNetworkIteratorInner::V4(iter) => iter.next().map(IpAddr::V4),
+            IpNetworkIteratorInner::V6(iter) => iter.next().map(IpAddr::V6),
+        }
+    }
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        match &self.inner {
+            IpNetworkIteratorInner::V4(iter) => iter.size_hint(),
+            IpNetworkIteratorInner::V6(iter) => iter.size_hint(),
+        }
+    }
+}
+
+impl IntoIterator for &'_ IpNetwork {
+    type IntoIter = IpNetworkIterator;
+    type Item = IpAddr;
+    fn into_iter(self) -> IpNetworkIterator {
+        self.iter()
+    }
+}
+
 /// Converts a `IpAddr` network mask into a prefix.
 /// If the mask is invalid this will return an `IpNetworkError::InvalidPrefix`.
 pub fn ip_mask_to_prefix(mask: IpAddr) -> Result<u8, IpNetworkError> {
@@ -309,14 +456,27 @@ pub fn ip_mask_to_prefix(mask: IpAddr) -> Result<u8, IpNetworkError> {
     }
 }
 
+/// Converts a `IpAddr` network mask into a prefix.
+///
+/// If the mask is invalid this will return `None`. This is useful in const contexts where
+/// [`Option::unwrap`] may be called to trigger a compile-time error if the prefix is invalid.
+pub const fn ip_mask_to_prefix_checked(mask: IpAddr) -> Option<u8> {
+    match mask {
+        IpAddr::V4(mask) => ipv4_mask_to_prefix_checked(mask),
+        IpAddr::V6(mask) => ipv6_mask_to_prefix_checked(mask),
+    }
+}
+
 #[cfg(test)]
 mod test {
     #[test]
+    #[cfg(feature = "serde")]
     fn deserialize_from_serde_json_value() {
         use super::*;
         let network = IpNetwork::from_str("0.0.0.0/0").unwrap();
-        let val: serde_json::value::Value = serde_json::from_str(&serde_json::to_string(&network).unwrap()).unwrap();
-        let _deser: IpNetwork =
-            serde_json::from_value(val).expect("Fails to deserialize from json_value::value::Value");
+        let val: serde_json::value::Value =
+            serde_json::from_str(&serde_json::to_string(&network).unwrap()).unwrap();
+        let _deser: IpNetwork = serde_json::from_value(val)
+            .expect("Fails to deserialize from json_value::value::Value");
     }
 }

src/parse.rs

@@ -0,0 +1,33 @@
+use crate::error::IpNetworkError;
+
+pub fn cidr_parts(cidr: &str) -> Result<(&str, Option<&str>), IpNetworkError> {
+    // Try to find a single slash
+    if let Some(sep) = cidr.find('/') {
+        let (ip, prefix) = cidr.split_at(sep);
+        // Error if cidr has multiple slashes
+        if prefix[1..].find('/').is_some() {
+            Err(IpNetworkError::InvalidCidrFormat(format!(
+                "CIDR must contain a single '/': {cidr}"
+            )))
+        } else {
+            // Handle the case when cidr has exactly one slash
+            Ok((ip, Some(&prefix[1..])))
+        }
+    } else {
+        // Handle the case when cidr does not have a slash
+        Ok((cidr, None))
+    }
+}
+
+pub fn parse_prefix(prefix: &str, max: u8) -> Result<u8, IpNetworkError> {
+    prefix
+        .parse()
+        .map_err(|_| IpNetworkError::InvalidPrefix)
+        .and_then(|mask| {
+            if mask > max {
+                Err(IpNetworkError::InvalidPrefix)
+            } else {
+                Ok(mask)
+            }
+        })
+}

src/size.rs

@@ -0,0 +1,207 @@
+use std::{
+    cmp::Ordering,
+    fmt::Display,
+    hash::{Hash, Hasher},
+};
+
+use crate::error::NetworkSizeError;
+use NetworkSize::*;
+
+/// Represents a generic network size.
+///
+/// IPv4 network sizes are represented as `u32` values, while IPv6 network sizes are represented as `u128` values.
+///
+/// # Comparisons
+///
+/// Network sizes are compared by _value_, not by type.
+///
+/// ```
+/// use ipnetwork::NetworkSize;
+///
+/// let ns1 = NetworkSize::V4(100);
+/// let ns2 = NetworkSize::V6(100);
+///
+/// assert_eq!(ns1, ns2);
+/// ```
+#[derive(Debug, Clone, Copy)]
+pub enum NetworkSize {
+    V4(u32),
+    V6(u128),
+}
+
+impl NetworkSize {
+    /// Returns the size of the network as a `u128`
+    fn as_u128(&self) -> u128 {
+        match *self {
+            V4(a) => a as u128,
+            V6(a) => a,
+        }
+    }
+}
+
+impl From<u32> for NetworkSize {
+    fn from(value: u32) -> Self {
+        V4(value)
+    }
+}
+
+impl From<u128> for NetworkSize {
+    fn from(value: u128) -> Self {
+        V6(value)
+    }
+}
+
+impl TryFrom<NetworkSize> for u32 {
+    type Error = NetworkSizeError;
+    fn try_from(value: NetworkSize) -> Result<Self, Self::Error> {
+        match value {
+            V4(a) => Ok(a),
+            V6(_) => Err(NetworkSizeError::NetworkIsTooLarge),
+        }
+    }
+}
+
+impl From<NetworkSize> for u128 {
+    fn from(val: NetworkSize) -> Self {
+        val.as_u128()
+    }
+}
+
+impl PartialEq for NetworkSize {
+    fn eq(&self, other: &Self) -> bool {
+        let a = self.as_u128();
+        let b = other.as_u128();
+        a == b
+    }
+}
+
+impl Eq for NetworkSize {}
+
+impl Hash for NetworkSize {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        let a = self.as_u128();
+        a.hash(state);
+    }
+}
+
+impl Ord for NetworkSize {
+    fn cmp(&self, other: &Self) -> Ordering {
+        let a = self.as_u128();
+        let b = other.as_u128();
+        a.cmp(&b)
+    }
+}
+
+impl PartialOrd for NetworkSize {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Display for NetworkSize {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.as_u128())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_from_u128() {
+        let value: u128 = 100;
+        let ns = NetworkSize::from(value);
+        assert_eq!(ns, V6(100));
+    }
+
+    #[test]
+    fn test_from_u32() {
+        let value: u32 = 100;
+        let ns = NetworkSize::from(value);
+        assert_eq!(ns, V4(100));
+    }
+
+    #[test]
+    fn test_try_into_u32() {
+        let value: u32 = 100;
+        let ns = V4(value);
+        let result: Result<u32, _> = ns.try_into();
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), value);
+    }
+
+    #[test]
+    fn test_try_into_u32_error() {
+        let value: u128 = u32::MAX as u128 + 1;
+        let ns = V6(value);
+        let result: Result<u32, _> = ns.try_into();
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_into_u128() {
+        let value: u32 = 100;
+        let ns = V4(value);
+        let result: u128 = ns.into();
+        assert_eq!(result, value as u128);
+    }
+
+    #[test]
+    fn test_eq() {
+        let ns1 = V4(100);
+        let ns2 = V4(100);
+        assert_eq!(ns1, ns2);
+
+        let ns1 = V6(100);
+        let ns2 = V6(100);
+        assert_eq!(ns1, ns2);
+
+        let ns1 = V4(100);
+        let ns2 = V6(100);
+        assert_eq!(ns1, ns2);
+    }
+
+    #[test]
+    fn test_cmp() {
+        let ns1 = V4(100);
+        let ns2 = V4(200);
+        assert!(ns1 < ns2);
+
+        let ns1 = V6(200);
+        let ns2 = V6(100);
+        assert!(ns1 > ns2);
+
+        let ns1 = V4(100);
+        let ns2 = V6(200);
+        assert!(ns1 < ns2);
+    }
+
+    #[test]
+    fn test_display() {
+        let ns1 = V4(u32::MAX);
+        let ns2 = V6(ns1.into());
+        assert_eq!(ns1.to_string(), ns2.to_string());
+    }
+
+    // Verify that [`std::hash::Hash`] and [`std::cmp::PartialEq`] are consistent
+    #[test]
+    fn test_hash() {
+        let a = NetworkSize::V4(100);
+        let b = NetworkSize::V6(100);
+
+        // Calculate the hash of the two values
+        let mut hasher = std::hash::DefaultHasher::default();
+        a.hash(&mut hasher);
+        let hash_a = hasher.finish();
+
+        let mut hasher = std::hash::DefaultHasher::default();
+        b.hash(&mut hasher);
+        let hash_b = hasher.finish();
+
+        // a == b
+        assert_eq!(a, b);
+        // implies hash(a) == hash(b)
+        assert_eq!(hash_a, hash_b);
+    }
+}

tests/test_json.rs

@@ -1,16 +1,9 @@
-extern crate serde;
-
-extern crate serde_json;
-
-#[macro_use]
-extern crate serde_derive;
-
-extern crate ipnetwork;
+#![cfg(feature = "serde")]
 
 #[cfg(test)]
 mod tests {
-
     use ipnetwork::{IpNetwork, Ipv4Network, Ipv6Network};
+    use serde::{Deserialize, Serialize};
     use std::net::{Ipv4Addr, Ipv6Addr};
 
     #[test]
@@ -18,6 +11,7 @@ mod tests {
         let json_string = r#"{"ipnetwork":"127.1.0.0/24"}"#;
 
         #[derive(Serialize, Deserialize)]
+        #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
         struct MyStruct {
             ipnetwork: Ipv4Network,
         }
@@ -28,6 +22,11 @@ mod tests {
         assert_eq!(mystruct.ipnetwork.prefix(), 24);
 
         assert_eq!(::serde_json::to_string(&mystruct).unwrap(), json_string);
+
+        #[cfg(feature = "schemars")]
+        if let Err(s) = does_it_json::validate_with_output(&mystruct) {
+            panic!("{}", s);
+        }
     }
 
     #[test]
@@ -35,6 +34,7 @@ mod tests {
         let json_string = r#"{"ipnetwork":"::1/0"}"#;
 
         #[derive(Serialize, Deserialize)]
+        #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
         struct MyStruct {
             ipnetwork: Ipv6Network,
         }
@@ -48,6 +48,11 @@ mod tests {
         assert_eq!(mystruct.ipnetwork.prefix(), 0);
 
         assert_eq!(::serde_json::to_string(&mystruct).unwrap(), json_string);
+
+        #[cfg(feature = "schemars")]
+        if let Err(s) = does_it_json::validate_with_output(&mystruct) {
+            panic!("{}", s);
+        }
     }
 
     #[test]
@@ -55,6 +60,7 @@ mod tests {
         let json_string = r#"{"ipnetwork":["127.1.0.0/24","::1/0"]}"#;
 
         #[derive(Serialize, Deserialize)]
+        #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
         struct MyStruct {
             ipnetwork: Vec<IpNetwork>,
         }
@@ -70,5 +76,18 @@ mod tests {
         assert_eq!(mystruct.ipnetwork[1].prefix(), 0);
 
         assert_eq!(::serde_json::to_string(&mystruct).unwrap(), json_string);
+
+        #[cfg(feature = "schemars")]
+        if let Err(s) = does_it_json::validate_with_output(&mystruct) {
+            panic!("{}", s);
+        }
+    }
+
+
+    #[test]
+    fn test_ipnetwork_size_with_prefix_0() {
+        let network: Ipv4Network = "0.0.0.0/0".parse().unwrap();
+        let size = network.size();
+        assert_eq!(size, u32::MAX);
     }
 }