Struct Channel 

pub struct Channel<H>
where
    H: WebImpl,
{ /* private fields */ }

Available on crate feature web03 only.

A channel to a WebSocket server.

See Handle::channel for more details.

Implementations

impl<H> Channel<H>

where H: WebImpl,

pub fn id(&self) -> ChannelId

Get the connection identifier for this handle.

pub fn handle(&self) -> &Handle<H>

Get a handle for this channel.

A handle sheds the channel information and allows for setting up things like broadcast listener.

pub fn request(&self) -> RequestBuilder<'_, H, EmptyBody, EmptyCallback>

Send a request of type T over the current channel.

Returns a handle for the request.

If the handle is dropped, the request is cancelled.

Examples

use yew::prelude::*;
use musli_web::web03::prelude::*;

mod api {
    use musli::{Decode, Encode};
    use musli_web::api;

    #[derive(Encode, Decode)]
    pub struct HelloRequest<'de> {
        pub message: &'de str,
    }

    #[derive(Encode, Decode)]
    pub struct HelloResponse<'de> {
        pub message: &'de str,
    }

    api::define! {
        pub type Hello;

        impl Endpoint for Hello {
            impl<'de> Request for HelloRequest<'de>;
            type Response<'de> = HelloResponse<'de>;
        }
    }
}

enum Msg {
    OnHello(Result<ws::Packet<api::Hello>, ws::Error>),
    OnChannel(Result<ws::Channel, ws::Error>),
}

#[derive(Properties, PartialEq)]
struct Props {
    ws: ws::Handle,
}

struct App {
    message: String,
    _hello: ws::Request,
    _channel_open: ws::Request,
    channel: ws::Channel,
}

impl Component for App {
    type Message = Msg;
    type Properties = Props;

    fn create(ctx: &Context<Self>) -> Self {
        let link = ctx.link().clone();

        let _channel_open = ctx.props().ws
            .channel()
            .on_open(ctx.link().callback(Msg::OnChannel))
            .send();

        Self {
            message: String::from("No Message :("),
            _hello: ws::Request::default(),
            _channel_open: _channel_open,
            channel: ws::Channel::default(),
        }
    }

    fn update(&mut self, ctx: &Context<Self>, msg: Self::Message) -> bool {
        match msg {
            Msg::OnHello(Err(error)) => {
                tracing::error!("Request error: {:?}", error);
                false
            }
            Msg::OnHello(Ok(packet)) => {
                if let Ok(response) = packet.decode() {
                    self.message = response.message.to_owned();
                }

                true
            }
            Msg::OnChannel(result) => {
                if let Ok(channel) = result {
                    self.channel = channel;
                }

                self._hello = self.channel
                    .request()
                    .body(api::HelloRequest { message: "Hello!"})
                    .on_packet(ctx.link().callback(Msg::OnHello))
                    .send();

                true
            }
        }
    }

    fn view(&self, ctx: &Context<Self>) -> Html {
        html! {
            <div>
                <h1>{"WebSocket Example"}</h1>
                <p>{format!("Message: {}", self.message)}</p>
            </div>
        }
    }
}

Trait Implementations

impl<H> Debug for Channel<H>

where H: WebImpl,

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

Formats the value using the given formatter.

impl<H> Default for Channel<H>

where H: WebImpl,

Construct a default connected handle.

Examples

use musli_web::web03::prelude::*;

let channel = ws::Channel::default();
assert_eq!(channel.id(), ws::ChannelId::NONE);

fn default() -> Self

Returns the “default value” for a type.

impl<H> Drop for Channel<H>

where H: WebImpl,

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl<H> PartialEq for Channel<H>

where H: WebImpl,

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

Equality operator ==.

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

Inequality operator !=.