Struct UdpManager

pub struct UdpManager<T>
where
    T: SerDesType,
{ /* private fields */ }

Sends and receives datagrams conveniently. Runs a background thread to continuously check for datagrams without interrupting other functionality.

Implementations

impl<T> UdpManager<T>

where T: SerDesType,

pub fn get<J>(&self) -> Result<(SocketAddr, J), Error>

where J: DeserializeOwned + 'static,

Provides the oldest datagram of the specified type, if one exists.

Attempts to retrieve the serialized object from the underlying storage depending on the requested data type. The serialized object is removed (if one exists) from the underyling storage regardless of deserialization success. The deserialized object is returned to the user, if deserialization is successful

Errors

Returns error when the underlying storage is empty or the data could not be deserialized.

Panics

This will panic if the lock becomes poisioned.

Examples found in repository

examples/messenger1.rs (line 25)

fn main() 
{
    let manager = Builder::init()
        .socket(String::from("0.0.0.0:40061"))
        //.use_ids(false)
        .start::<JSON>().unwrap();

    let manager = Arc::from(manager);
    let man = manager.clone();

    std::thread::spawn(move || {
        let man = man.clone();

        loop {
            match man.get::<Message>() {
                Ok((_,obj)) => println!("{} says: {}", obj.user, obj.message),
                Err(_) => {}
            }
        }
    });

    loop {
        let mut message = String::new();
        std::io::stdin().read_line(&mut message).expect("Did not enter a correct string");

        let m = Message{user: String::from("User1"), message};

        manager.send(m, String::from("127.0.0.1:40062")).unwrap();
    }
}

examples/messenger2.rs (line 25)

fn main() 
{
    let manager = Builder::init()
        .socket(String::from("0.0.0.0:40062"))
        //.use_ids(false)
        .start::<JSON>().unwrap();

    let manager = Arc::from(manager);
    let man = manager.clone();

    std::thread::spawn(move || {
        let man = man.clone();

        loop {
            match man.get::<Message>() {
                Ok((_,obj)) => println!("{} says: {}", obj.user, obj.message),
                Err(_) => {}
            }
        }
    });

    loop {
        let mut message = String::new();
        std::io::stdin().read_line(&mut message).expect("Did not enter a correct string");

        let m = Message{user: String::from("User1"), message};

        manager.send(m, String::from("127.0.0.1:40061")).unwrap();
    }
}

examples/simple.rs (line 34)

fn main() {
    //source_ip and dest_ip are the same so we don't have to spin up a server and client
    let source_ip = String::from("0.0.0.0:12000");
    let net_msg = Builder::init().socket(source_ip).start::<JSON>().unwrap();
    
    let dest_ip = String::from("127.0.0.1:12000");

    let new_entity = CreateEntity {entity_type: String::from("Boss"), location: (50f32, 15f32, 17f32)};

    match net_msg.send(new_entity, &dest_ip) {
        Ok(_) => println!("datagram sent!"),
        Err(e) => println!("datagram failed to send because: {}", e)
    }

    thread::sleep(time::Duration::from_millis(100));

    let (from_addr, create_entity_message) = net_msg.get::<CreateEntity>().unwrap();

    println!("Message Received!: {:?}", create_entity_message);

    let move_entity = UpdatePos {x: 16f32, y: 17f32, z: 20f32, text: String::from("Hello! I Moved")};

    match net_msg.send(move_entity, from_addr) {
        Ok(_) => println!("datagram sent!"),
        Err(e) => println!("datagram failed to send because: {}", e)
    }

    thread::sleep(time::Duration::from_millis(100));

    let (_, update_pos_message) = net_msg.get::<UpdatePos>().unwrap();

    println!("Message Received!: {:?}", update_pos_message);
}

pub fn get_all<J>(&self) -> Result<Vec<(SocketAddr, J)>, Error>

where J: DeserializeOwned + 'static,

Provides all datagrams of the specified type, if any exist.

Attempts to retrieve all serialized objects from the underlying storage depending on the requested data type. If storage for the object exists, it will attempt to deserialize any datagrams that exist. If deserialization fails, the datagram is lost. It will return an empty vector as long as the underlying storage existed. If use_ids is set to false, this will return only the datagrams that were able to be converted. All others are removed.

Errors

Returns an error when the underlying storage for that data type does not exist (different than being empty) or the data could not be deserialized

Panics

This will panic if the lock becomes poisioned.

pub fn peek<J>(&self) -> Result<(SocketAddr, J), Error>

where J: DeserializeOwned + 'static,

Provides the oldest datagram of the specified type, if one exists, without removing it from the underlying storage.

Attempts to retrieve the serialized object from the underlying storage depending on the requested data type. If a serialized object is available, a copy is taken and an attempt to deserialize the data is made. If successful, the deserialized object is returned to the user.

Errors

Returns error when the underlying storage is empty or the data could not be deserialized.

Panics

This will panic if the lock becomes poisioned.

pub fn remove_front<J>(&self) -> Result<(), Error>

where J: DeserializeOwned + 'static,

Removes the oldest datagram of the specified type, if one exists, without providing it to the user.

if use_ids is set false, it will remove the oldest datagram and the specified type is ignored.

Errors

Returns error when the underlying storage does not exist.

Panics

This will panic if the lock becomes poisioned.

pub fn remove_all<J>(&self) -> Result<(), Error>

where J: DeserializeOwned + 'static,

Removes all datagram of the specified type, if one exists, without providing it to the user.

if use_ids is set false, it will remove all datagram and the specified type is ignored.

Errors

Returns error when the underlying storage does not exist.

Panics

This will panic if the lock becomes poisioned.

pub fn send<J, A>(&self, datagram: J, dest_addr: A) -> Result<(), Error>

where J: Serialize + 'static, A: ToSocketAddrs,

Deserializes the datagram, appends the ID, and sends to requested location.

Consumes a datagram and a destination address for the datagram to be sent to. An attempt to serialize the data is made; If use_id is true, the datagram ID is prepended to the message. A request to the underlying UDP socket is then made to send the data.

Errors

Returns an error when the data could not be serialized or when the underyling UDP socket failed to send the message.

Panics

This will panic if the lock becomes poisioned.

Examples found in repository

examples/messenger1.rs (line 38)

fn main() 
{
    let manager = Builder::init()
        .socket(String::from("0.0.0.0:40061"))
        //.use_ids(false)
        .start::<JSON>().unwrap();

    let manager = Arc::from(manager);
    let man = manager.clone();

    std::thread::spawn(move || {
        let man = man.clone();

        loop {
            match man.get::<Message>() {
                Ok((_,obj)) => println!("{} says: {}", obj.user, obj.message),
                Err(_) => {}
            }
        }
    });

    loop {
        let mut message = String::new();
        std::io::stdin().read_line(&mut message).expect("Did not enter a correct string");

        let m = Message{user: String::from("User1"), message};

        manager.send(m, String::from("127.0.0.1:40062")).unwrap();
    }
}

examples/messenger2.rs (line 38)

fn main() 
{
    let manager = Builder::init()
        .socket(String::from("0.0.0.0:40062"))
        //.use_ids(false)
        .start::<JSON>().unwrap();

    let manager = Arc::from(manager);
    let man = manager.clone();

    std::thread::spawn(move || {
        let man = man.clone();

        loop {
            match man.get::<Message>() {
                Ok((_,obj)) => println!("{} says: {}", obj.user, obj.message),
                Err(_) => {}
            }
        }
    });

    loop {
        let mut message = String::new();
        std::io::stdin().read_line(&mut message).expect("Did not enter a correct string");

        let m = Message{user: String::from("User1"), message};

        manager.send(m, String::from("127.0.0.1:40061")).unwrap();
    }
}

examples/simple.rs (line 27)

fn main() {
    //source_ip and dest_ip are the same so we don't have to spin up a server and client
    let source_ip = String::from("0.0.0.0:12000");
    let net_msg = Builder::init().socket(source_ip).start::<JSON>().unwrap();
    
    let dest_ip = String::from("127.0.0.1:12000");

    let new_entity = CreateEntity {entity_type: String::from("Boss"), location: (50f32, 15f32, 17f32)};

    match net_msg.send(new_entity, &dest_ip) {
        Ok(_) => println!("datagram sent!"),
        Err(e) => println!("datagram failed to send because: {}", e)
    }

    thread::sleep(time::Duration::from_millis(100));

    let (from_addr, create_entity_message) = net_msg.get::<CreateEntity>().unwrap();

    println!("Message Received!: {:?}", create_entity_message);

    let move_entity = UpdatePos {x: 16f32, y: 17f32, z: 20f32, text: String::from("Hello! I Moved")};

    match net_msg.send(move_entity, from_addr) {
        Ok(_) => println!("datagram sent!"),
        Err(e) => println!("datagram failed to send because: {}", e)
    }

    thread::sleep(time::Duration::from_millis(100));

    let (_, update_pos_message) = net_msg.get::<UpdatePos>().unwrap();

    println!("Message Received!: {:?}", update_pos_message);
}

pub fn set_id<F>(&self, id: u64)

where F: 'static,

Allows the header id of a particular struct to be specified rather than be automatically generated.

Generally, the struct ID is automatically created using a hash of the TypeID. This method allows the struct id to be set by the user. This should be called before any attempt to send or receive a datagram is made. This is commonly used if interacting with a socket that does not use this crate and is expecting a specific ID for the type of message you are sending.

Panics

This will panic if the lock becomes poisioned.

Trait Implementations

impl<T> Drop for UdpManager<T>

where T: SerDesType,

Allows the background thread to safely shutdown when the struct loses scope or program performs a shutdown.

fn drop(&mut self)

Executes the destructor for this type.