Struct coap_lite::CoapRequest

pub struct CoapRequest<Endpoint> {
    pub message: Packet,
    pub response: Option<CoapResponse>,
    pub source: Option<Endpoint>,
}

The CoAP request.

Fields

message: Packet

response: Option<CoapResponse>

source: Option<Endpoint>

Implementations

impl<Endpoint> CoapRequest<Endpoint>

pub fn new() -> CoapRequest<Endpoint>

Creates a new request.

Examples found in repository

examples/client.rs (line 5)

fn main() {
    let mut request: CoapRequest<SocketAddr> = CoapRequest::new();

    request.set_method(Method::Get);
    request.set_path("/test");

    let socket = UdpSocket::bind("127.0.0.1:0").unwrap();

    let packet = request.message.to_bytes().unwrap();
    socket
        .send_to(&packet[..], "127.0.0.1:5683")
        .expect("Could not send the data");
}

pub fn from_packet(packet: Packet, source: Endpoint) -> CoapRequest<Endpoint>

Creates a request from a packet.

Examples found in repository

examples/server.rs (line 12)

fn main() {
    let socket = UdpSocket::bind("127.0.0.1:5683").unwrap();
    let mut buf = [0; 100];
    let (size, src) = socket.recv_from(&mut buf).expect("Didn't receive data");

    println!("Payload {:x?}", &buf[..size]);

    let packet = Packet::from_bytes(&buf[..size]).unwrap();
    let request = CoapRequest::from_packet(packet, src);

    let method = request.get_method().clone();
    let path = request.get_path();

    println!("Received CoAP request '{:?} {}' from {}", method, path, src);

    let mut response = request.response.unwrap();
    response.message.payload = b"OK".to_vec();

    let packet = response.message.to_bytes().unwrap();
    socket
        .send_to(&packet[..], &src)
        .expect("Could not send the data");
}

pub fn apply_from_error(&mut self, error: HandlingError) -> bool

Applies the given error to the request and returns true if that was successful.

pub fn set_method(&mut self, method: Method)

Sets the method.

Examples found in repository

examples/client.rs (line 7)

fn main() {
    let mut request: CoapRequest<SocketAddr> = CoapRequest::new();

    request.set_method(Method::Get);
    request.set_path("/test");

    let socket = UdpSocket::bind("127.0.0.1:0").unwrap();

    let packet = request.message.to_bytes().unwrap();
    socket
        .send_to(&packet[..], "127.0.0.1:5683")
        .expect("Could not send the data");
}

pub fn get_method(&self) -> &Method

Returns the method.

Examples found in repository

examples/server.rs (line 14)

fn main() {
    let socket = UdpSocket::bind("127.0.0.1:5683").unwrap();
    let mut buf = [0; 100];
    let (size, src) = socket.recv_from(&mut buf).expect("Didn't receive data");

    println!("Payload {:x?}", &buf[..size]);

    let packet = Packet::from_bytes(&buf[..size]).unwrap();
    let request = CoapRequest::from_packet(packet, src);

    let method = request.get_method().clone();
    let path = request.get_path();

    println!("Received CoAP request '{:?} {}' from {}", method, path, src);

    let mut response = request.response.unwrap();
    response.message.payload = b"OK".to_vec();

    let packet = response.message.to_bytes().unwrap();
    socket
        .send_to(&packet[..], &src)
        .expect("Could not send the data");
}

pub fn set_path(&mut self, path: &str)

Sets the path.

Examples found in repository

examples/client.rs (line 8)

fn main() {
    let mut request: CoapRequest<SocketAddr> = CoapRequest::new();

    request.set_method(Method::Get);
    request.set_path("/test");

    let socket = UdpSocket::bind("127.0.0.1:0").unwrap();

    let packet = request.message.to_bytes().unwrap();
    socket
        .send_to(&packet[..], "127.0.0.1:5683")
        .expect("Could not send the data");
}

pub fn get_path(&self) -> String

Returns the path.

Examples found in repository

examples/server.rs (line 15)

fn main() {
    let socket = UdpSocket::bind("127.0.0.1:5683").unwrap();
    let mut buf = [0; 100];
    let (size, src) = socket.recv_from(&mut buf).expect("Didn't receive data");

    println!("Payload {:x?}", &buf[..size]);

    let packet = Packet::from_bytes(&buf[..size]).unwrap();
    let request = CoapRequest::from_packet(packet, src);

    let method = request.get_method().clone();
    let path = request.get_path();

    println!("Received CoAP request '{:?} {}' from {}", method, path, src);

    let mut response = request.response.unwrap();
    response.message.payload = b"OK".to_vec();

    let packet = response.message.to_bytes().unwrap();
    socket
        .send_to(&packet[..], &src)
        .expect("Could not send the data");
}

pub fn get_path_as_vec( &self ) -> Result<Vec<String>, IncompatibleOptionValueFormat>

Returns the path as a vector (as it is encoded in CoAP rather than in HTTP-style paths).

pub fn get_observe_flag(&self) -> Option<Result<ObserveOption, InvalidObserve>>

Returns the flag in the Observe option or InvalidObserve if the flag was provided but not understood.

pub fn set_observe_flag(&mut self, flag: ObserveOption)

Sets the flag in the Observe option.

Trait Implementations

impl<Endpoint: Clone> Clone for CoapRequest<Endpoint>

fn clone(&self) -> CoapRequest<Endpoint>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Endpoint: Debug> Debug for CoapRequest<Endpoint>

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

Formats the value using the given formatter.

impl<Endpoint> Default for CoapRequest<Endpoint>

fn default() -> Self

Returns the “default value” for a type.

impl<Endpoint: Ord + Clone> From<&CoapRequest<Endpoint>> for RequestCacheKey<Endpoint>

fn from(request: &CoapRequest<Endpoint>) -> Self

Converts to this type from the input type.