Struct zenoh::publication::Publisher

pub struct Publisher<'a> { /* private fields */ }

A publisher that allows to send data through a stream.

Publishers are automatically undeclared when dropped.

Examples

use zenoh::prelude::r#async::*;

let session = zenoh::open(config::peer()).res().await.unwrap().into_arc();
let publisher = session.declare_publisher("key/expression").res().await.unwrap();
publisher.put("value").res().await.unwrap();

Publisher implements the Sink trait which is useful to forward streams to zenoh.

use futures::StreamExt;
use zenoh::prelude::r#async::*;

let session = zenoh::open(config::peer()).res().await.unwrap().into_arc();
let mut subscriber = session.declare_subscriber("key/expression").res().await.unwrap();
let publisher = session.declare_publisher("another/key/expression").res().await.unwrap();
subscriber.stream().map(Ok).forward(publisher).await.unwrap();

Implementations

impl<'a> Publisher<'a>

pub fn key_expr(&self) -> &KeyExpr<'a>

pub fn congestion_control(self, congestion_control: CongestionControl) -> Self

Change the congestion_control to apply when routing the data.

pub fn priority(self, priority: Priority) -> Self

Change the priority of the written data.

pub fn write<IntoValue>(
    &self,
    kind: SampleKind,
    value: IntoValue
) -> Publication<'_>where
    IntoValue: Into<Value>,

Send data with kind (Put or Delete).

Examples

use zenoh::prelude::r#async::*;

let session = zenoh::open(config::peer()).res().await.unwrap().into_arc();
let publisher = session.declare_publisher("key/expression").res().await.unwrap();
publisher.write(SampleKind::Put, "value").res().await.unwrap();

pub fn put<IntoValue>(&self, value: IntoValue) -> Publication<'_>where
    IntoValue: Into<Value>,

Put data.

Examples

use zenoh::prelude::r#async::*;

let session = zenoh::open(config::peer()).res().await.unwrap().into_arc();
let publisher = session.declare_publisher("key/expression").res().await.unwrap();
publisher.put("value").res().await.unwrap();

Examples found in repository

src/publication.rs (line 473)

    fn start_send(self: Pin<&mut Self>, item: IntoValue) -> Result<(), Self::Error> {
        self.put(item.into()).res_sync()
    }

pub fn delete(&self) -> Publication<'_>

Delete data.

Examples

use zenoh::prelude::r#async::*;

let session = zenoh::open(config::peer()).res().await.unwrap().into_arc();
let publisher = session.declare_publisher("key/expression").res().await.unwrap();
publisher.delete().res().await.unwrap();

pub fn undeclare(self) -> impl Resolve<ZResult<()>> + 'a

Undeclares the Publisher, informing the network that it needn’t optimize publications for its key expression anymore.

Examples

use zenoh::prelude::r#async::*;

let session = zenoh::open(config::peer()).res().await.unwrap();
let publisher = session.declare_publisher("key/expression").res().await.unwrap();
publisher.undeclare().res().await.unwrap();

Trait Implementations

impl<'a> Clone for Publisher<'a>

fn clone(&self) -> Publisher<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Publisher<'a>

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

Formats the value using the given formatter.

impl Drop for Publisher<'_>

fn drop(&mut self)

Executes the destructor for this type.

impl<'a, IntoValue> Sink<IntoValue> for Publisher<'a>where
    IntoValue: Into<Value>,

type Error = Box<dyn Error + Sync + Send + 'static, Global>

The type of value produced by the sink when an error occurs.

fn poll_ready(
    self: Pin<&mut Self>,
    _cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

Attempts to prepare the Sink to receive a value.

fn start_send(self: Pin<&mut Self>, item: IntoValue) -> Result<(), Self::Error>

Begin the process of sending a value to the sink. Each call to this function must be preceded by a successful call to poll_ready which returned Poll::Ready(Ok(())).

fn poll_flush(
    self: Pin<&mut Self>,
    _cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

Flush any remaining output from this sink.

fn poll_close(
    self: Pin<&mut Self>,
    _cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

Flush any remaining output and close this sink, if necessary.

impl<'a> Undeclarable<(), PublisherUndeclaration<'a>, Result<(), Box<dyn Error + Sync + Send + 'static, Global>>> for Publisher<'a>

fn undeclare_inner(self, _: ()) -> PublisherUndeclaration<'a>