Struct localghost::net::EventSource

pub struct EventSource { /* fields omitted */ }

A receiver of Server Sent Events (SSE).

Examples

use localghost::dom::{self, Element};
use localghost::prelude::*;
use localghost::net::EventSource;
use async_std::prelude::*;

use std::io;

#[localghost::main]
async fn main() -> io::Result<()> {
    // Connect the `EventSource`.
    let interests = ["fruit"];
    let mut sse = EventSource::connect("http://localhost:8081/sse", &interests).await?;

    // Create a table
    let table = Element::new("table");
    let tr = Element::new("tr");
    tr.append(Element::with_text("th", "name"));
    tr.append(Element::with_text("th", "data"));
    table.append(tr);
    dom::body().append(&table);

    // For every event in the `EventSource` add an entry to the table.
    while let Some(ev) = sse.next().await.transpose()? {
        let tr = Element::new("tr");
        tr.append(Element::with_text("td", ev.name()));
        tr.append(Element::with_text("td", ev.data()));
        table.append(tr);
    };

    Ok(())
}

Implementations

impl EventSource

pub async fn connect<S, '_, '_>(
    url: &'_ str,
    interests: &'_ [S]
) -> Result<Self> where
    S: AsRef<str>, 

Create a new instance of EventSource and wait for a connection to be established.

pub fn reconnect(&mut self) -> bool

Get whether the instance should reconnect.

Defaults to true.

pub fn set_reconnect(&mut self, reconnect: bool)

Track whether the instance should reconnect.

pub fn register(&mut self, name: &str)

Register interest in an event.

pub async fn recv<'_>(&'_ self) -> Result<MessageEvent>

Receive a message from the stream.

pub fn ready_state(&self) -> ReadyState

Access the EventSource's connection state.

Trait Implementations

impl AsRef<EventTarget> for EventSource

fn as_ref(&self) -> &EventTarget

Performs the conversion.

impl Debug for EventSource

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

Formats the value using the given formatter.

impl Drop for EventSource

fn drop(&mut self)

Executes the destructor for this type.

impl PinnedDrop for EventSource

unsafe fn drop(self: Pin<&mut Self>)

impl Stream for EventSource

type Item = Result<MessageEvent>

Values yielded by the stream.

fn poll_next(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Option<Self::Item>>

Attempt to pull out the next value of this stream, registering the current task for wakeup if the value is not yet available, and returning None if the stream is exhausted.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the stream.

impl<'pin> Unpin for EventSource where
    __EventSource<'pin>: Unpin, 

impl UnsafeUnpin for EventSource