Struct Message

pub struct Message<T> { /* private fields */ }

A wrapped message which may be either typed or binary data.

Implementations

impl<T> Message<T>

pub fn from_typed(typed: T) -> Self

Wrap a typed item as a message.

Examples found in repository

examples/comm_hello.rs (line 19)

fn main() {

    // extract the configuration from user-supplied arguments, initialize the computation.
    let config = timely_communication::Config::from_args(std::env::args()).unwrap();
    let guards = timely_communication::initialize(config, |mut allocator| {

        println!("worker {} of {} started", allocator.index(), allocator.peers());

        // allocates a pair of senders list and one receiver.
        let (mut senders, mut receiver) = allocator.allocate(0);

        // send typed data along each channel
        for i in 0 .. allocator.peers() {
            senders[i].send(Message::from_typed(format!("hello, {}", i)));
            senders[i].done();
        }

        // no support for termination notification,
        // we have to count down ourselves.
        let mut received = 0;
        while received < allocator.peers() {

            allocator.receive();

            if let Some(message) = receiver.recv() {
                println!("worker {}: received: <{}>", allocator.index(), message.deref());
                received += 1;
            }

            allocator.release();
        }

        allocator.index()
    });

    // computation runs until guards are joined or dropped.
    if let Ok(guards) = guards {
        for guard in guards.join() {
            println!("result: {:?}", guard);
        }
    }
    else { println!("error in computation"); }
}

pub fn from_arc(typed: Arc<T>) -> Self

Wrap a shared typed item as a message.

pub fn if_typed(self) -> Option<T>

Destructures and returns any typed data.

pub fn if_mut(&mut self) -> Option<&mut T>

Returns a mutable reference, if typed.

pub fn as_ref_or_mut(&mut self) -> RefOrMut<'_, T>

Returns an immutable or mutable typed reference.

This method returns a mutable reference if the underlying data are typed Rust instances, which admit mutation, and it returns an immutable reference if the data are serialized binary data.

impl<T: Data> Message<T>

pub unsafe fn from_bytes(bytes: Bytes) -> Self

Wrap bytes as a message.

Safety

This method is unsafe, in that Abomonated::new() is unsafe: it presumes that the binary data can be safely decoded, which is unsafe for e.g. UTF8 data and enumerations (perhaps among many other types).

pub fn length_in_bytes(&self) -> usize

The number of bytes required to serialize the data.

pub fn into_bytes<W: Write>(&self, writer: &mut W)

Writes the binary representation into writer.

impl<T: Clone> Message<T>

pub fn into_typed(self) -> T

Produces a typed instance of the wrapped element.

pub fn as_mut(&mut self) -> &mut T

Ensures the message is typed data and returns a mutable reference to it.

Trait Implementations

impl<T> Deref for Message<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T: Data> Pull<Message<T>> for Puller<T>

fn pull(&mut self) -> &mut Option<Message<T>>

Pulls an element and provides the opportunity to take ownership.

fn recv(&mut self) -> Option<T>

Takes an Option<T> and leaves None behind.

impl<T: Data> Pull<Message<T>> for PullerInner<T>

fn pull(&mut self) -> &mut Option<Message<T>>

Pulls an element and provides the opportunity to take ownership.

fn recv(&mut self) -> Option<T>

Takes an Option<T> and leaves None behind.

impl<T: Data, P: BytesPush> Push<Message<T>> for Pusher<T, P>

fn push(&mut self, element: &mut Option<Message<T>>)

Pushes element with the opportunity to take ownership.

fn send(&mut self, element: T)

Pushes element and drops any resulting resources.

fn done(&mut self)

Pushes None, conventionally signalling a flush.