macaddr

https://github.com/svartalf/rust-macaddr
Admin
macaddr is a Rust crate providing MAC address types for IEEE EUI-48 and EUI-64 formats with helpful...
Tokens:25,129
Snippets:213
Trust Score:7.9
License:Apache-2.0
Update:4 weeks ago
Show doc for...
Tokens:
Raw
### MacAddr6::as_bytes usage example

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/api-reference/MacAddr6.md

Example usage of as_bytes. Creates a MacAddr6 and prints the byte slice, showing the raw octets.

```rust
use macaddr::MacAddr6;

let addr = MacAddr6::new(0xAC, 0xDE, 0x48, 0x23, 0x45, 0x67);
println!("{:02X?}", addr.as_bytes()); // [AC, DE, 48, 23, 45, 67]
```

--------------------------------

### MacAddr6::is_universal usage example

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/api-reference/MacAddr6.md

Example usage of is_universal. Creates a MacAddr6 with first byte 0x01 and prints the result, which is true.

```rust
use macaddr::MacAddr6;

let addr = MacAddr6::new(0x01, 0x00, 0x0C, 0xCC, 0xCC, 0xCC);
println!("universal: {}", addr.is_universal()); // universal: true
```

--------------------------------

### MacAddr8::nil usage example

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/api-reference/MacAddr8.md

Example of creating a nil MacAddr8 with MacAddr8::nil. The Display output is 00:00:00:00:00:00:00:00.

```rust
use macaddr::MacAddr8;

let addr = MacAddr8::nil();
println!("nil: {}", addr); // nil: 00:00:00:00:00:00:00:00
```

--------------------------------

### MacAddr6::into_array usage example

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/api-reference/MacAddr6.md

Example usage of into_array. Creates a MacAddr6, converts it to an array, and prints the array.

```rust
use macaddr::MacAddr6;

let addr = MacAddr6::new(0xAC, 0xDE, 0x48, 0x23, 0x45, 0x67);
let raw: [u8; 6] = addr.into_array();
println!("{:02X?}", raw); // [AC, DE, 48, 23, 45, 67]
```

--------------------------------

### MacAddr8::new usage example

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/api-reference/MacAddr8.md

Example of constructing a MacAddr8 with MacAddr8::new in a const context. The Display output is 01:23:45:67:89:AB:CD:EF.

```rust
use macaddr::MacAddr8;

const NIC: MacAddr8 = MacAddr8::new(0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF);
println!("{}", NIC); // 01:23:45:67:89:AB:CD:EF
```

--------------------------------

### MacAddr6::broadcast usage example

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/api-reference/MacAddr6.md

Creates a broadcast address and prints it.

```rust
use macaddr::MacAddr6;

let addr = MacAddr6::broadcast();
println!("broadcast: {}", addr); // broadcast: FF:FF:FF:FF:FF:FF
```

--------------------------------

### MacAddr8::broadcast usage example

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/api-reference/MacAddr8.md

Example of creating a broadcast MacAddr8 with MacAddr8::broadcast. The Display output is FF:FF:FF:FF:FF:FF:FF:FF.

```rust
use macaddr::MacAddr8;

let addr = MacAddr8::broadcast();
println!("broadcast: {}", addr); // broadcast: FF:FF:FF:FF:FF:FF:FF:FF
```

--------------------------------

### MacAddr6::is_local usage example

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/api-reference/MacAddr6.md

Example usage of is_local. Creates a MacAddr6 with first byte 0x02 and prints the result, which is true.

```rust
use macaddr::MacAddr6;

let addr = MacAddr6::new(0x02, 0x00, 0x0C, 0xCC, 0xCC, 0xCC);
println!("local: {}", addr.is_local()); // local: true
```

--------------------------------

### Consumer Cargo.toml dependency examples for macaddr

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/configuration.md

Shows four ways to depend on `macaddr` in a consumer `Cargo.toml`: default `std` build, `no_std` build with `default-features = false`, `no_std` with `serde`, and `std` with `serde_std`. Each line is a separate dependency declaration.

```toml
[dependencies]
macaddr = "1.0"                            # std build (default)
macaddr = { version = "1.0", default-features = false }   # no_std build
macaddr = { version = "1.0", features = ["serde"] }       # no_std + serde
macaddr = { version = "1.0", features = ["serde_std"] }   # std + serde
```

--------------------------------

### MacAddr6::new usage example

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/api-reference/MacAddr6.md

Creates a const MacAddr6 from six octets and prints it in EUI-48 format.

```rust
use macaddr::MacAddr6;

const NIC: MacAddr6 = MacAddr6::new(0x01, 0x23, 0x45, 0x67, 0x89, 0xAB);
println!("{}", NIC); // 01:23:45:67:89:AB
```

--------------------------------

### MacAddr6::is_multicast usage example

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/api-reference/MacAddr6.md

Creates an address with a set I/G bit and prints the result of is_multicast().

```rust
use macaddr::MacAddr6;

let addr = MacAddr6::new(0x01, 0x00, 0x0C, 0xCC, 0xCC, 0xCC);
println!("multicast: {}", addr.is_multicast()); // multicast: true
```

--------------------------------

### Parse EUI-64 string with MacAddr::from_str

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/api-reference/MacAddr.md

Example of parsing a full EUI-64 formatted string. It yields MacAddr::V8 and prints the parsed address; any error is printed to stderr.

```rust
use std::str::FromStr;
use macaddr::MacAddr;

match MacAddr::from_str("12-34-56-78-9A-BC-DE-F0") {
    Ok(addr) => println!("parsed {}", addr),   // parses as V8
    Err(e) => eprintln!("parse failed: {}", e),
}
```

--------------------------------

### MacAddr::is_v6 usage example

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/api-reference/MacAddr.md

Creates a MacAddr6 and converts it to MacAddr, then prints the results of is_v6 and is_v8. Expected output: is_v6: true, is_v8: false.

```rust
use macaddr::{MacAddr, MacAddr6};

let addr: MacAddr = MacAddr6::new(0xAC, 0xDE, 0x48, 0x23, 0x45, 0x67).into();
println!("is_v6: {}", addr.is_v6()); // true
println!("is_v8: {}", addr.is_v8()); // false
```

--------------------------------

### Format MacAddr6 with Display flags

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/api-reference/MacAddr6.md

Example of formatting a MacAddr6 using the Display implementation. The default format prints colon-separated uppercase hex, {:-} prints hyphen-separated, and {:#} prints period-separated Cisco style. The example uses MacAddr6::new to construct the address.

```rust
use macaddr::MacAddr6;

let addr = MacAddr6::new(0xab, 0x0d, 0xef, 0x12, 0x34, 0x56);
println!("{}",   addr); // AB:0D:EF:12:34:56
println!("{:-}", addr); // AB-0D-EF-12-34-56
println!("{:#}", addr); // AB0.DEF.123.456
```

--------------------------------

### MacAddr6::is_nil usage example

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/api-reference/MacAddr6.md

Creates an all-zero address and prints the result of is_nil().

```rust
use macaddr::MacAddr6;

let addr = MacAddr6::new(0x00, 0x00, 0x00, 0x00, 0x00, 0x00);
println!("is_nil: {}", addr.is_nil()); // is_nil: true
```

--------------------------------

### MacAddr::is_v8 usage example

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/api-reference/MacAddr.md

Creates a MacAddr8 and converts it to MacAddr, then prints the result of is_v8. Expected output: is_v8: true.

```rust
use macaddr::{MacAddr, MacAddr8};

let addr: MacAddr = MacAddr8::new(0xAC, 0xDE, 0x48, 0x23, 0x45, 0x67, 0x89, 0xAB).into();
println!("is_v8: {}", addr.is_v8()); // true
```

--------------------------------

### Parse a valid MAC address with FromStr

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/api-reference/MacAddr6.md

Example of parsing a valid MAC address string using FromStr. The parsed address is printed using the default Display format, which outputs uppercase hex with colons. The example uses the ? operator, so it must be used in a function that returns Result.

```rust
use std::str::FromStr;
use macaddr::MacAddr6;

let addr = MacAddr6::from_str("ab-cd-ef-ab-cd-ef")?;
println!("{}", addr); // AB:CD:EF:AB:CD:EF
# Ok::<(), macaddr::ParseError>(())
```

--------------------------------

### MacAddr6::nil usage example

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/api-reference/MacAddr6.md

Creates a nil address and prints it along with the result of is_nil().

```rust
use macaddr::MacAddr6;

let addr = MacAddr6::nil();
println!("nil: {}, is_nil: {}", addr, addr.is_nil()); // nil: 00:00:00:00:00:00, is_nil: true
```

--------------------------------

### MacAddr6::is_broadcast usage example

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/api-reference/MacAddr6.md

Creates an all-0xFF address and prints the result of is_broadcast().

```rust
use macaddr::MacAddr6;

let addr = MacAddr6::new(0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF);
println!("is_broadcast: {}", addr.is_broadcast()); // is_broadcast: true
```

--------------------------------

### MacAddr::as_bytes usage example

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/api-reference/MacAddr.md

Creates a MacAddr from an array and prints the byte length and hex representation. Expected output: 6 bytes: [AC, DE, 48, 23, 45, 67].

```rust
use macaddr::{MacAddr, MacAddr6};

let addr = MacAddr::from([0xAC, 0xDE, 0x48, 0x23, 0x45, 0x67]);
let bytes: &[u8] = addr.as_bytes();
println!("{} bytes: {:02X?}", bytes.len(), bytes); // 6 bytes: [AC, DE, 48, 23, 45, 67]
```

--------------------------------

### MacAddr6::is_unicast usage example

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/api-reference/MacAddr6.md

Creates an address with a clear I/G bit and prints both is_unicast and is_multicast results.

```rust
use macaddr::MacAddr6;

let addr = MacAddr6::new(0x00, 0x01, 0x44, 0x55, 0x66, 0x77);
println!("unicast: {} multicast: {}", addr.is_unicast(), addr.is_multicast());
// unicast: true multicast: false
```

--------------------------------

### Display::fmt

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/api-reference/MacAddr.md

Formats the MacAddr for display, supporting multiple format flags.

```APIDOC
## `Display`

### Description
Formats the `MacAddr` for display. Delegates to the inner type's `Display` implementation, so all format-flag variants (`{}`, `{:-}`, `{:#}`) apply.

### Signature
```rust
impl fmt::Display for MacAddr {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result;
}
```

### Parameters
- **f** (`&mut fmt::Formatter`) - The formatter.

### Returns
- `fmt::Result` - The result of the formatting operation.

### Example
```rust
use macaddr::MacAddr;

let addr = MacAddr::from([0xAB, 0x0D, 0xEF, 0x12, 0x34, 0x56]);
println!("{}",    addr); // AB:0D:EF:12:34:56
println!("{:-}",  addr); // AB-0D-EF-12-34-56
println!("{:#}",  addr); // AB0.DEF.123.456
```
```

--------------------------------

### From<[u8; 8]> for MacAddr8

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/api-reference/MacAddr8.md

Creates a MacAddr8 from an array of eight bytes.

```APIDOC
## From<[u8; 8]> for MacAddr8

### Description
Creates a MacAddr8 from an array of eight bytes.

### Method
`fn from(bytes: [u8; 8]) -> Self`

### Parameters
- `bytes` (`[u8; 8]`) - Required - The octets to wrap.

### Returns
`MacAddr8` - The address wrapping the supplied octets.
```

--------------------------------

### Convert MacAddr8 to byte array

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/api-reference/MacAddr8.md

Shows how to convert a MacAddr8 to a byte array using into_array (by value) and as_bytes (by reference). The borrow form avoids copying.

```rust
use macaddr::MacAddr8;

let addr = MacAddr8::new(0xAC, 0xDE, 0x48, 0x23, 0x45, 0x67, 0x89, 0xAB);
let raw: [u8; 8] = addr.into_array();
let bytes: &[u8] = addr.as_bytes(); // borrow form, no copy
println!("{:02X?} == {:02X?}", raw, bytes);
```

--------------------------------

### Convert MacAddr6 to MacAddr with From

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/api-reference/MacAddr.md

Implements conversion from MacAddr6 to MacAddr, wrapping the value in MacAddr::V6. All conversions are infallible.

```rust
impl From<MacAddr6> for MacAddr {
    fn from(addr: MacAddr6) -> Self { MacAddr::V6(addr) }
}
```

--------------------------------

### Implement Display for MacAddr

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/api-reference/MacAddr.md

Implements Display for MacAddr, delegating to the inner type's Display. Supports the format flags {} , {:-}, and {:#} as described for MacAddr6 and MacAddr8.

```rust
impl fmt::Display for MacAddr {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            MacAddr::V6(v6) => fmt::Display::fmt(v6, f),
            MacAddr::V8(v8) => fmt::Display::fmt(v8, f),
        }
    }
}
```

--------------------------------

### Convert MacAddr8 to MacAddr with From

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/api-reference/MacAddr.md

Implements conversion from MacAddr8 to MacAddr, wrapping the value in MacAddr::V8. All conversions are infallible.

```rust
impl From<MacAddr8> for MacAddr {
    fn from(addr: MacAddr8) -> Self { MacAddr::V8(addr) }
}
```

--------------------------------

### Handle ParseError from FromStr

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/api-reference/MacAddr6.md

Example of handling parse errors from FromStr. The input "ab-cd:ef-12-34-56" uses mixed delimiters (hyphen and colon), which is invalid and produces a ParseError. The match arms handle InvalidCharacter and InvalidLength variants, printing the offending character and position or the invalid length.

```rust
use std::str::FromStr;
use macaddr::{MacAddr6, ParseError};

match MacAddr6::from_str("ab-cd:ef-12-34-56") {
    Ok(addr) => println!("{}", addr),
    Err(ParseError::InvalidCharacter(chr, pos)) =>
        println!("unexpected '{}' at position {}", chr, pos),
    Err(ParseError::InvalidLength(len)) =>
        println!("invalid length {}", len),
}
```

--------------------------------

### From<MacAddr8>

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/api-reference/MacAddr.md

Converts a MacAddr8 into a MacAddr by wrapping it in the V8 variant.

```APIDOC
## `From<MacAddr8>`

### Description
Converts a `MacAddr8` into a `MacAddr` by wrapping it in the `MacAddr::V8` variant.

### Signature
```rust
impl From<MacAddr8> for MacAddr {
    fn from(addr: MacAddr8) -> Self;
}
```

### Parameters
- **addr** (`MacAddr8`) - The 8-octet MAC address to convert.

### Returns
- `MacAddr::V8(addr)` - The resulting `MacAddr` enum variant.
```

--------------------------------

### MacAddr6::new

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/api-reference/MacAddr6.md

Constructs a new MacAddr6 from six octets, in order. This is a const fn, so it can be used in constant contexts.

```APIDOC
## MacAddr6::new

### Description
Constructs a new `MacAddr6` from six octets, in order. This is a `const fn`, so it can be used in constant contexts.

### Method
`pub const fn new(a: u8, b: u8, c: u8, d: u8, e: u8, f: u8) -> MacAddr6`

### Parameters
- `a` (u8) - Required - First octet (most significant)
- `b` (u8) - Required - Second octet
- `c` (u8) - Required - Third octet
- `d` (u8) - Required - Fourth octet
- `e` (u8) - Required - Fifth octet
- `f` (u8) - Required - Sixth octet (least significant)

### Returns
`MacAddr6` constructed from the six bytes, in order.

### Example
```rust
use macaddr::MacAddr6;

const NIC: MacAddr6 = MacAddr6::new(0x01, 0x23, 0x45, 0x67, 0x89, 0xAB);
println!("{}", NIC); // 01:23:45:67:89:AB
```
```

--------------------------------

### Display implementation for MacAddr8

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/api-reference/MacAddr8.md

Implements Display for MacAddr8. The formatting is selected by formatter flags: default {} uses colons, {:-} uses hyphens, and {:#} uses periods (Cisco style). All output uses uppercase hex.

```rust
impl fmt::Display for MacAddr8 {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { /* ... */ }
}
```

--------------------------------

### From<[u8; 8]> implementation for MacAddr8

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/api-reference/MacAddr8.md

Implements From<[u8; 8]> for MacAddr8, wrapping the supplied octets into a MacAddr8.

```rust
impl From<[u8; 8]> for MacAddr8 {
    fn from(bytes: [u8; 8]) -> Self { MacAddr8(bytes) }
}
```

--------------------------------

### From<MacAddr6>

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/api-reference/MacAddr.md

Converts a MacAddr6 into a MacAddr by wrapping it in the V6 variant.

```APIDOC
## `From<MacAddr6>`

### Description
Converts a `MacAddr6` into a `MacAddr` by wrapping it in the `MacAddr::V6` variant.

### Signature
```rust
impl From<MacAddr6> for MacAddr {
    fn from(addr: MacAddr6) -> Self;
}
```

### Parameters
- **addr** (`MacAddr6`) - The 6-octet MAC address to convert.

### Returns
- `MacAddr::V6(addr)` - The resulting `MacAddr` enum variant.
```

--------------------------------

### Display MacAddr with format flags

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/api-reference/MacAddr.md

Shows the different Display format flags for a MacAddr created from a byte array. The default prints colon-separated, {:-} uses hyphens, and {:#} uses dotted notation.

```rust
use macaddr::MacAddr;

let addr = MacAddr::from([0xAB, 0x0D, 0xEF, 0x12, 0x34, 0x56]);
println!("{}",    addr); // AB:0D:EF:12:34:56
println!("{:-}",  addr); // AB-0D-EF-12-34-56
println!("{:#}",  addr); // AB0.DEF.123.456
```

--------------------------------

### MacAddr8::new

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/api-reference/MacAddr8.md

Constructs a MacAddr8 from eight octets. This is a const function usable in constant contexts.

```APIDOC
## MacAddr8::new

### Description
Constructs a MacAddr8 from eight octets. This is a const function usable in constant contexts.

### Method
Constructor

### Signature
```rust
pub const fn new(a: u8, b: u8, c: u8, d: u8, e: u8, f: u8, g: u8, h: u8) -> MacAddr8
```

### Parameters
- `a` (u8) - Required - First octet (most significant)
- `b` (u8) - Required - Second octet
- `c` (u8) - Required - Third octet
- `d` (u8) - Required - Fourth octet
- `e` (u8) - Required - Fifth octet
- `f` (u8) - Required - Sixth octet
- `g` (u8) - Required - Seventh octet
- `h` (u8) - Required - Eighth octet (least significant)

### Returns
`MacAddr8` constructed from the eight bytes, in order.

### Example
```rust
use macaddr::MacAddr8;

const NIC: MacAddr8 = MacAddr8::new(0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF);
println!("{}", NIC); // 01:23:45:67:89:AB:CD:EF
```
```

--------------------------------

### Handle ParseError from MacAddr6::from_str

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/errors.md

Shows how to handle ParseError from MacAddr6::from_str in consumer code. Because ParseError is Copy, Eq, and PartialEq, you can destructure it with match or compare directly. It implements Display (all builds) and std::error::Error (std builds), so you can propagate it with ? or box it as a trait object.

```rust
use std::str::FromStr;
use macaddr::{MacAddr6, ParseError};

fn classify(input: &str) {
    match MacAddr6::from_str(input) {
        Ok(addr) => println!("valid: {}", addr),
        Err(ParseError::InvalidCharacter(chr, pos)) =>
            println!("bad character '{}' at position {}", chr, pos),
        Err(ParseError::InvalidLength(len)) =>
            println!("wrong length: {} characters", len),
    }
}

fn propagate(input: &str) -> Result<MacAddr6, ParseError> {
    let addr = MacAddr6::from_str(input)?; // ? works because ParseError: Display (+ Error in std)
    Ok(addr)
}

fn as_boxed(input: &str) -> Box<dyn std::error::Error> {
    MacAddr6::from_str(input).err().map(Box::new).unwrap()
}

classify("12-34-56-78-9A-BC");      // valid
classify("ab-Qd-ef-12-34-56");      // bad character 'Q' ...
classify("12-34-56-78-9A-BC-DE");   // wrong length
```

--------------------------------

### From<[u8; 8]>

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/api-reference/MacAddr.md

Converts an 8-byte array into a MacAddr by wrapping it in the V8 variant.

```APIDOC
## `From<[u8; 8]>`

### Description
Converts an 8-byte array into a `MacAddr` by wrapping it in the `MacAddr::V8` variant.

### Signature
```rust
impl From<[u8; 8]> for MacAddr {
    fn from(bytes: [u8; 8]) -> Self;
}
```

### Parameters
- **bytes** (`[u8; 8]`) - The 8 octets to convert.

### Returns
- `MacAddr::V8` - The resulting `MacAddr` enum variant wrapping the supplied octets.
```

--------------------------------

### MacAddr8::nil

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/api-reference/MacAddr8.md

Creates a MacAddr8 with all octets set to 0x00, representing the nil address.

```APIDOC
## MacAddr8::nil

### Description
Creates a MacAddr8 with all octets set to 0x00, representing the nil address.

### Method
Constructor

### Signature
```rust
pub const fn nil() -> MacAddr8
```

### Returns
`MacAddr8` with all eight octets set to `0x00`. Satisfies `is_nil()`.

### Example
```rust
use macaddr::MacAddr8;

let addr = MacAddr8::nil();
println!("nil: {}", addr); // nil: 00:00:00:00:00:00:00:00
```
```

--------------------------------

### Combined MacAddr8 predicate usage

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/api-reference/MacAddr8.md

Combined usage of all MacAddr8 predicates. Constructs an address with 0x02 as the first octet and prints each predicate result. The expected output is unicast=true multicast=false universal=false local=true nil=false broadcast=false.

```rust
use macaddr::MacAddr8;

let addr = MacAddr8::new(0x02, 0x00, 0x0C, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC);
println!(
    "unicast={} multicast={} universal={} local={} nil={} broadcast={}",
    addr.is_unicast(), addr.is_multicast(),
    addr.is_universal(), addr.is_local(),
    addr.is_nil(), addr.is_broadcast(),
);
// unicast=true multicast=false universal=false local=true nil=false broadcast=false
```

--------------------------------

### Convert [u8; 8] to MacAddr with From

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/api-reference/MacAddr.md

Implements conversion from an eight-byte array to MacAddr, producing MacAddr::V8. The inner MacAddr8 handles the conversion.

```rust
impl From<[u8; 8]> for MacAddr {
    fn from(bytes: [u8; 8]) -> Self { MacAddr::V8(MacAddr8::from(bytes)) }
}
```

--------------------------------

### Crate-root re-exports (src/lib.rs:45-48)

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/api-reference/index.md

Declares the four public items re-exported at the crate root: MacAddr, MacAddr6, MacAddr8, and ParseError. Modules are private; this snippet is the sole entry point to the public API.

```rust
// src/lib.rs:45-48
pub use self::addr::MacAddr;
pub use self::addr6::MacAddr6;
pub use self::addr8::MacAddr8;
pub use self::parser::ParseError;
```

--------------------------------

### Implement FromStr for MacAddr

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/api-reference/MacAddr.md

Trait implementation for parsing a MAC address string into MacAddr. It returns Result<MacAddr, ParseError>. The parser first attempts EUI-48; if that fails with ParseError::InvalidLength, it resets and tries EUI-64, while InvalidCharacter aborts immediately.

```rust
impl FromStr for MacAddr {
    type Err = ParseError; // crate::ParseError — see [ParseError](ParseError.md)

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        parser::Parser::new(s).read_addr()
    }
}
```

--------------------------------

### Add macaddr dependency to Cargo.toml

Source: https://github.com/svartalf/rust-macaddr/blob/master/README.md

Add the macaddr crate to your Cargo.toml dependencies to use the MAC address types in your Rust project.

```toml
[dependencies]
macaddr = "1.0"
```

--------------------------------

### Display for MacAddr8

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/api-reference/MacAddr8.md

Formats the MAC address in different styles based on formatter flags.

```APIDOC
## Display for MacAddr8

### Description
Formats the MAC address in different styles based on formatter flags. All renderings use uppercase hex.

### Method
`fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result`

### Parameters
- `self` (`&MacAddr8`) - Required - The address to format.
- `f` (`&mut fmt::Formatter`) - Required - The formatter.

### Formatting Options
- `{}` (default) - Colon-separated, e.g., `AB:0D:EF:12:34:56:78:9A`
- `{:-}` - Hyphen-separated, e.g., `AB-0D-EF-12-34-56-78-9A`
- `{:#}` - Period-separated Cisco style, e.g., `AB0D.EF12.3456.789A`

### Example
```rust
use macaddr::MacAddr8;

let addr = MacAddr8::new(0xab, 0x0d, 0xef, 0x12, 0x34, 0x56, 0x78, 0x9A);
println!("{}",   addr); // AB:0D:EF:12:34:56:78:9A
println!("{:-}", addr); // AB-0D-EF-12-34-56-78-9A
println!("{:#}", addr); // AB0D.EF12.3456.789A
```
```

--------------------------------

### Display implementation for MacAddr6

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/api-reference/MacAddr6.md

Implementation of the Display trait for MacAddr6. Three renderings are selected by formatter flags, all with uppercase hex: default {} gives colon-separated output, {:-} gives hyphen-separated (using f.sign_minus()), and {:#} gives period-separated Cisco style (using f.alternate()) where octets are packed into three 12-bit groups via u16 arithmetic.

```rust
impl fmt::Display for MacAddr6 {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { /* ... */ }
}
```

--------------------------------

### From<[u8; 6]>

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/api-reference/MacAddr.md

Converts a 6-byte array into a MacAddr by wrapping it in the V6 variant.

```APIDOC
## `From<[u8; 6]>`

### Description
Converts a 6-byte array into a `MacAddr` by wrapping it in the `MacAddr::V6` variant.

### Signature
```rust
impl From<[u8; 6]> for MacAddr {
    fn from(bytes: [u8; 6]) -> Self;
}
```

### Parameters
- **bytes** (`[u8; 6]`) - The 6 octets to convert.

### Returns
- `MacAddr::V6` - The resulting `MacAddr` enum variant wrapping the supplied octets.
```

--------------------------------

### FromStr for MacAddr8

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/api-reference/MacAddr8.md

Parses a string into a MacAddr8, accepting eight octets separated by a consistent delimiter.

```APIDOC
## FromStr for MacAddr8

### Description
Parses a string into a MacAddr8. The accepted grammar is eight octets, each exactly two hex digits (`0-9`, `a-f`, `A-F`), separated by a consistent delimiter — hyphen `-`, colon `:`, or dot `.`. Empty strings, partial octets, trailing characters, and mixed delimiters all produce `ParseError`.

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

### Parameters
- `s` (`&str`) - Required - The string to parse.

### Returns
`Result<MacAddr8, ParseError>` - The parsed address or a parse error.

### Example
```rust
use std::str::FromStr;
use macaddr::MacAddr8;

let addr = MacAddr8::from_str("12:34:56:78:9A:BC:DE:F0")?;
println!("{}", addr); // 12:34:56:78:9A:BC:DE:F0
# Ok::<(), macaddr::ParseError>(())
```

```rust
use std::str::FromStr;
use macaddr::{MacAddr8, ParseError};

match MacAddr8::from_str("ab-cd-ef-12-34-56-78-9") {
    Ok(addr) => println!("{}", addr),
    Err(ParseError::InvalidLength(len)) =>
        println!("trailing or truncated input: length {} chars", len),
    Err(ParseError::InvalidCharacter(chr, pos)) =>
        println!("unexpected '{}' at position {}", chr, pos),
}
```
```

--------------------------------

### Format MacAddr8 with Display flags

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/api-reference/MacAddr8.md

Shows the three Display formatting options for MacAddr8: default colon-separated, hyphen-separated with {:-}, and period-separated Cisco style with {:#}. All output uses uppercase hex.

```rust
use macaddr::MacAddr8;

let addr = MacAddr8::new(0xab, 0x0d, 0xef, 0x12, 0x34, 0x56, 0x78, 0x9A);
println!("{}",   addr); // AB:0D:EF:12:34:56:78:9A
println!("{:-}", addr); // AB-0D-EF-12-34-56-78-9A
println!("{:#}", addr); // AB0D.EF12.3456.789A
```

--------------------------------

### MacAddr6::nil signature

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/api-reference/MacAddr6.md

Signature of the const constructor that returns an all-zero address.

```rust
// src/addr6.rs:34
pub const fn nil() -> MacAddr6
```

--------------------------------

### Convert [u8; 6] to MacAddr with From

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/api-reference/MacAddr.md

Implements conversion from a six-byte array to MacAddr, producing MacAddr::V6. The inner MacAddr6 handles the conversion.

```rust
impl From<[u8; 6]> for MacAddr {
    fn from(bytes: [u8; 6]) -> Self { MacAddr::V6(MacAddr6::from(bytes)) }
}
```

--------------------------------

### Handle parsing errors from MacAddr::from_str

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/api-reference/MacAddr.md

Demonstrates error handling when parsing an invalid MAC address. Invalid characters cause immediate failure with ParseError::InvalidCharacter, while trailing content yields ParseError::InvalidLength.

```rust
use std::str::FromStr;
use macaddr::MacAddr;

// Invalid characters abort immediately; trailing content yields InvalidLength.
match MacAddr::from_str("12-34-56-78-9A-BC\n") {
    Ok(_) => unreachable!(),
    Err(ParseError::InvalidLength(len)) => println!("bad length: {} chars", len),
    Err(ParseError::InvalidCharacter(ch, pos)) => println!("bad char '{}' at {}", ch, pos),
}
```

--------------------------------

### Cargo.toml feature declarations for macaddr

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/configuration.md

Declares the crate's Cargo features: `std` (default), `serde_std`, and an optional `serde` dependency. The `serde_std` feature enables `std` and `serde/std` via feature unification, while `serde` is intended for `no_std` builds.

```toml
[features]
default = ["std"]
std = []
serde_std = ["std", "serde/std"]

[dependencies]
serde = { version = "^1.0", default-features = false, features = ["derive"], optional = true }
```

--------------------------------

### FromStr::from_str

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/api-reference/MacAddr.md

Parses a string into a MacAddr enum, supporting both EUI-48 and EUI-64 formats.

```APIDOC
## `FromStr` (parsing)

### Description
Parses a string into a `MacAddr` enum. The parser first attempts an EUI-48 parse; if that fails with `ParseError::InvalidLength`, it resets and tries an EUI-64 parse. Any `ParseError::InvalidCharacter` from the EUI-48 attempt is propagated immediately. A 6-octet string yields `MacAddr::V6`; an 8-octet string yields `MacAddr::V8`.

### Signature
```rust
impl FromStr for MacAddr {
    type Err = ParseError;
    fn from_str(s: &str) -> Result<Self, Self::Err>;
}
```

### Parameters
- **s** (`&str`) - The string to parse.

### Returns
- `Result<MacAddr, ParseError>` - `Ok(MacAddr::V6)` for 6 octets, `Ok(MacAddr::V8)` for 8 octets, or `Err(ParseError)` on failure.

### Errors
- `ParseError::InvalidLength` - The string has an invalid length.
- `ParseError::InvalidCharacter` - The string contains an invalid character at a specific position.

### Example
```rust
use std::str::FromStr;
use macaddr::MacAddr;

match MacAddr::from_str("12-34-56-78-9A-BC-DE-F0") {
    Ok(addr) => println!("parsed {}", addr),   // parses as V8
    Err(e) => eprintln!("parse failed: {}", e),
}
```
```

--------------------------------

### MacAddr8 predicate method signatures

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/api-reference/MacAddr8.md

Predicate method signatures for MacAddr8. Each takes &self and returns bool. is_nil and is_broadcast are non-const; the rest are const fn. They check for nil (all 0x00), broadcast (all 0xFF), unicast (I/G bit clear), multicast (I/G bit set), universal (UAA), and local (LAA) addresses.

```rust
// src/addr8.rs:62
pub fn is_nil(&self) -> bool
```

```rust
// src/addr8.rs:77
pub fn is_broadcast(&self) -> bool
```

```rust
// src/addr8.rs:92
pub const fn is_unicast(&self) -> bool
```

```rust
// src/addr8.rs:107
pub const fn is_multicast(&self) -> bool
```

```rust
// src/addr8.rs:122
pub const fn is_universal(&self) -> bool
```

```rust
// src/addr8.rs:137
pub const fn is_local(&self) -> bool
```

--------------------------------

### MacAddr6::is_nil

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/api-reference/MacAddr6.md

Returns true if every octet is 0x00.

```APIDOC
## MacAddr6::is_nil

### Description
Returns `true` if every octet is `0x00`.

### Method
`pub fn is_nil(&self) -> bool`

### Parameters
- `self` (&MacAddr6) - Required - The address to inspect

### Returns
`bool` — `true` if every octet is `0x00`.

### Example
```rust
use macaddr::MacAddr6;

let addr = MacAddr6::new(0x00, 0x00, 0x00, 0x00, 0x00, 0x00);
println!("is_nil: {}", addr.is_nil()); // is_nil: true
```
```

--------------------------------

### FromStr implementation for MacAddr6

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/api-reference/MacAddr6.md

Implementation of the FromStr trait for MacAddr6. The error type is crate::ParseError (the crate-root ParseError; the parser:: path is private-module scope). Returns Result<MacAddr6, ParseError>. The accepted grammar is six octets, each exactly two hex digits (0-9, a-f, A-F), separated by a consistent delimiter — hyphen -, colon :, or dot . Empty strings, partial octets, trailing characters, and mixed delimiters all produce ParseError.

```rust
impl FromStr for MacAddr6 {
    type Err = parser::ParseError; // crate::ParseError — see [ParseError](ParseError.md)

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        parser::Parser::new(s).read_v6_addr()
    }
}
```

--------------------------------

### MacAddr6::nil

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/api-reference/MacAddr6.md

Returns a MacAddr6 with all six octets set to 0x00. A nil address satisfies is_nil().

```APIDOC
## MacAddr6::nil

### Description
Returns a `MacAddr6` with all six octets set to `0x00`. A nil address satisfies `is_nil()`.

### Method
`pub const fn nil() -> MacAddr6`

### Returns
`MacAddr6` with all six octets set to `0x00`.

### Example
```rust
use macaddr::MacAddr6;

let addr = MacAddr6::nil();
println!("nil: {}, is_nil: {}", addr, addr.is_nil()); // nil: 00:00:00:00:00:00, is_nil: true
```
```

--------------------------------

### FromStr implementation for MacAddr8

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/api-reference/MacAddr8.md

Implements FromStr for MacAddr8. The error type is crate::ParseError. Parsing accepts eight octets of exactly two hex digits separated by a consistent delimiter (hyphen, colon, or dot). Empty strings, partial octets, trailing characters, and mixed delimiters produce ParseError.

```rust
impl FromStr for MacAddr8 {
    type Err = parser::ParseError; // crate::ParseError — see [ParseError](ParseError.md)

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        parser::Parser::new(s).read_v8_addr()
    }
}
```

--------------------------------

### MacAddr6::new signature

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/api-reference/MacAddr6.md

Signature of the const constructor that takes six octets in order.

```rust
// src/addr6.rs:21
pub const fn new(a: u8, b: u8, c: u8, d: u8, e: u8, f: u8) -> MacAddr6
```

--------------------------------

### AsMut<[u8]> implementation for MacAddr8

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/api-reference/MacAddr8.md

Implements AsMut<[u8]> for MacAddr8, providing mutable access to the inner octet array.

```rust
impl AsMut<[u8]> for MacAddr8 {
    fn as_mut(&mut self) -> &mut [u8] { &mut self.0 }
}
```

--------------------------------

### MacAddr8::is_nil

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/api-reference/MacAddr8.md

Returns true if every octet of the address is 0x00.

```APIDOC
## MacAddr8::is_nil

### Description
Returns `true` if every octet of the address is `0x00`.

### Method
`pub fn is_nil(&self) -> bool`

### Parameters
- `self` (`&MacAddr8`) - Required - The address to inspect.

### Returns
`bool` - `true` if every octet is `0x00`.
```

--------------------------------

### MacAddr::is_v8

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/api-reference/MacAddr.md

Checks if the MAC address is an EUI-64 (8-octet) address.

```APIDOC
## MacAddr::is_v8

### Description
Determines whether the MAC address is an EUI-64 (8-octet) address.

### Method
`pub fn is_v8(&self) -> bool`

### Parameters
- `self` (`&MacAddr`) - Required - The address to inspect

### Returns
`bool` - `true` if the value is `MacAddr::V8`, `false` otherwise.

### Example
```rust
use macaddr::{MacAddr, MacAddr8};

let addr: MacAddr = MacAddr8::new(0xAC, 0xDE, 0x48, 0x23, 0x45, 0x67, 0x89, 0xAB).into();
println!("is_v8: {}", addr.is_v8()); // true
```
```

--------------------------------

### AsRef<[u8]> implementation for MacAddr8

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/api-reference/MacAddr8.md

Implements AsRef<[u8]> for MacAddr8, returning a reference to the inner octet array.

```rust
impl AsRef<[u8]> for MacAddr8 {
    fn as_ref(&self) -> &[u8] { &self.0 }
}
```

--------------------------------

### MacAddr8::into_array

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/api-reference/MacAddr8.md

Consumes the address and returns the eight raw octets as an array.

```APIDOC
## MacAddr8::into_array

### Description
Consumes the address and returns the eight raw octets as an array.

### Method
`pub const fn into_array(self) -> [u8; 8]`

### Parameters
- `self` (`MacAddr8`) - Required (consumed) - The address to convert.

### Returns
`[u8; 8]` - The eight raw octets by value; consumes the address.

### Example
```rust
use macaddr::MacAddr8;

let addr = MacAddr8::new(0xAC, 0xDE, 0x48, 0x23, 0x45, 0x67, 0x89, 0xAB);
let raw: [u8; 8] = addr.into_array();
println!("{:02X?}", raw);
```
```

--------------------------------

### From<[u8; 6]> implementation for MacAddr6

Source: https://github.com/svartalf/rust-macaddr/blob/master/_autodocs/api-reference/MacAddr6.md

Implementation of the From trait to convert a [u8; 6] array into a MacAddr6. Returns a MacAddr6 wrapping the supplied octets.

```rust
impl From<[u8; 6]> for MacAddr6 {
    fn from(bytes: [u8; 6]) -> Self { MacAddr6(bytes) }
}
```
Tokens:
Raw