Struct Calls 

pub struct Calls;

Implementations

impl Calls

pub fn call<Req: Serialize + ?Sized, Resp: DeserializeOwned>( &self, method: &str, request: &Req, to: Target, ) -> Result<Resp>

Calls method with a typed request and waits for the typed response, 10 s at most.

pub fn call_json( &self, method: &str, request: &Json, to: Target, ) -> Result<Json>

pub fn call_json_timeout( &self, method: &str, request: &Json, to: Target, timeout_ms: u32, ) -> Result<Json>

Calls::call_json waiting at most timeout_ms (30 s at most).

pub fn send<Req: Serialize + ?Sized>( &self, method: &str, request: &Req, to: Target, ) -> Result<()>

Sends method and returns at once; nothing answers. For commands whose outcome arrives another way (a value, a live message).

Examples found in repository

examples/together_ui.rs (line 105)

    fn event(&mut self, event: Event, cx: &mut Context) {
        match event {
            Event::Plugin { name, .. } if name == "together.changed" => {
                self.reload(cx);
                self.paint();
                // A commit from an event is sampled on the next frame;
                // ask for one.
                cx.request_frame();
            }
            Event::Resize { .. } => {
                self.paint();
                cx.request_frame();
            }
            Event::Pointer(pointer) if pointer.kind == PointerKind::Down => {
                // Side-effect free unless this viewer is the one the user
                // is driving, and then exactly once across viewers.
                if !view::is_driving() {
                    return;
                }
                // `send` returns at once: the companion's answer arrives as
                // the value it writes, not here.
                let _ = claims().once("together.rebuild", 5_000, || {
                    let _ = cx.calls().send("rebuild", &(), Target::Singleton);
                });
            }
            _ => {}
        }
    }

pub fn call_async<Req: Serialize + ?Sized>( &self, method: &str, request: &Req, to: Target, ) -> Result<CallId>

Starts a call and returns at once; its answer arrives as Event::CallResult with the id returned here, after 10 s at most.

pub fn call_async_timeout<Req: Serialize + ?Sized>( &self, method: &str, request: &Req, to: Target, timeout_ms: u32, ) -> Result<CallId>

Calls::call_async answered within timeout_ms (30 s at most).

Trait Implementations

impl Clone for Calls

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Calls

impl Debug for Calls

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

Formats the value using the given formatter.

impl Default for Calls

fn default() -> Self

Returns the “default value” for a type.