Struct Addressed 

pub struct Addressed {
    pub mac_address: MacAddress,
    pub dac: Dac,
}

A DAC along with its broadcasted MAC address.

This type can be used as though it is a Dac in many places as it implements Deref<Target = Dac>

Fields

mac_address: MacAddress

The unique MAC address associated with the DAC.

This may be used to distinguish between multiple DACs broadcasting on a network.

dac: Dac

The state of the DAC itself.

Implementations

impl Addressed

pub fn from_broadcast( dac_broadcast: &DacBroadcast, ) -> Result<Self, ProtocolError>

Create an Addressed DAC from a received DacBroadcast.

Examples found in repository

examples/enumerate_dacs.rs (line 26)

fn main() {
    println!("Searching for Ether Dream DACs...");

    let mut dacs = HashMap::new();
    let three_secs = time::Duration::from_secs(3);
    let mut rx = ether_dream::recv_dac_broadcasts().expect("failed to bind to UDP socket");
    rx.set_timeout(Some(three_secs))
        .expect("failed to set timeout on UDP socket");
    let loop_start = time::Instant::now();
    while loop_start.elapsed() < three_secs {
        let (dac_broadcast, source_addr) = match rx.next_broadcast() {
            Ok(dac) => dac,
            Err(e) => match e.kind() {
                io::ErrorKind::WouldBlock | io::ErrorKind::TimedOut => continue,
                _ => panic!("an IO error occurred: {}", e),
            },
        };
        let dac::Addressed { mac_address, dac } = dac::Addressed::from_broadcast(&dac_broadcast)
            .expect("failed to interpret DAC status from received broadcast");
        if dacs.insert(mac_address, (dac, source_addr)).is_none() {
            println!("Discovered new DAC \"{}\"...", mac_address);
        }
    }

    if dacs.is_empty() {
        println!("No Ether Dream DACs found on the network.");
    } else {
        println!("Discovered the following Ether Dream DACs on the network:");
        for (i, (mac, (dac, source_addr))) in dacs.into_iter().enumerate() {
            println!(
                "{}.\n  MAC address: \"{}\"\n  Network address: \"{}\"\n  {:?}",
                i + 1,
                mac,
                source_addr,
                dac
            );
        }
    }
}

Methods from Deref<Target = Dac>

pub fn update_status(&mut self, status: &DacStatus) -> Result<(), ProtocolError>

Update the inner status given a new protocol representation.

Trait Implementations

impl Clone for Addressed

fn clone(&self) -> Addressed

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Addressed

impl Debug for Addressed

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

Formats the value using the given formatter.

impl Deref for Addressed

type Target = Dac

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for Addressed

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl Eq for Addressed

impl Hash for Addressed

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

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Addressed

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

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

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

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

impl StructuralPartialEq for Addressed