Module pipes

Type RecvPacket

type RecvPacket<T> = RecvPacketBuffered<T, Packet<T>>

Represents the receive end of a pipe. It can receive exactly one message.

Type SendPacket

type SendPacket<T> = SendPacketBuffered<T, Packet<T>>

The sending end of a pipe. It can be used to send exactly one message.

Struct BufferHeader

pub struct BufferHeader {
    mut ref_count: int,
}

Struct PacketHeader

pub struct PacketHeader {
    mut state: State,
    mut blocked_task: *rust_task,
    mut buffer: *libc::c_void,
}

Struct RecvPacketBuffered

pub struct RecvPacketBuffered<T, Tbuffer> {
    mut p: Option<*Packet<T>>,
    mut buffer: Option<BufferResource<Tbuffer>>,
}

Struct SendPacketBuffered

pub struct SendPacketBuffered<T, Tbuffer> {
    mut p: Option<*Packet<T>>,
    mut buffer: Option<BufferResource<Tbuffer>>,
}

Implementation of ::core::cmp::Eq for State

fn eq(&self, __other: &State) -> bool

fn ne(&self, __other: &State) -> bool

Implementation for PacketHeader

unsafe fn mark_blocked(&self, this: *rust_task) -> State

unsafe fn unblock(&self)

unsafe fn buf_header(&self) -> ~BufferHeader

fn set_buffer<T: Owned>(&self, b: ~Buffer<T>)

Implementation of HasBuffer for Packet<T> where <T: Owned>

fn set_buffer(&self, b: *libc::c_void)

Implementation of ::ops::Drop for BufferResource<T> where <T>

fn finalize(&self)

Implementation of Selectable for *PacketHeader

fn header(&self) -> *PacketHeader

Implementation of ::ops::Drop for SendPacketBuffered<T, Tbuffer> where <T: Owned, Tbuffer: Owned>

fn finalize(&self)

Implementation for SendPacketBuffered<T, Tbuffer> where <T, Tbuffer>

fn unwrap(&self) -> *Packet<T>

fn header(&self) -> *PacketHeader

fn reuse_buffer(&self) -> BufferResource<Tbuffer>

Implementation of ::ops::Drop for RecvPacketBuffered<T, Tbuffer> where <T: Owned, Tbuffer: Owned>

fn finalize(&self)

Implementation for RecvPacketBuffered<T, Tbuffer> where <T: Owned, Tbuffer: Owned>

fn unwrap(&self) -> *Packet<T>

fn reuse_buffer(&self) -> BufferResource<Tbuffer>

Implementation of Selectable for RecvPacketBuffered<T, Tbuffer> where <T: Owned, Tbuffer: Owned>

fn header(&self) -> *PacketHeader

Function BufferHeader

fn BufferHeader() -> BufferHeader

Function PacketHeader

fn PacketHeader() -> PacketHeader

Function RecvPacketBuffered

fn RecvPacketBuffered<T, Tbuffer>(p: *Packet<T>) ->
 RecvPacketBuffered<T, Tbuffer>

Function SendPacketBuffered

fn SendPacketBuffered<T, Tbuffer>(p: *Packet<T>) ->
 SendPacketBuffered<T, Tbuffer>

Function peek

fn peek<T: Owned, Tb: Owned>(p: &RecvPacketBuffered<T, Tb>) -> bool

Returns true if messages are available.

Function recv

fn recv<T: Owned, Tbuffer: Owned>(p: RecvPacketBuffered<T, Tbuffer>) -> T

Receives a message from a pipe.

Fails if the sender closes the connection.

Function select

fn select<T: Owned, Tb: Owned>(endpoints: ~[RecvPacketBuffered<T, Tb>]) ->
 (uint, Option<T>, ~[RecvPacketBuffered<T, Tb>])

Waits on a set of endpoints. Returns a message, its index, and a list of the remaining endpoints.

Function select2

fn select2<A: Owned, Ab: Owned, B: Owned,
           Bb: Owned>(a: RecvPacketBuffered<A, Ab>,
                      b: RecvPacketBuffered<B, Bb>) ->
 Either<(Option<A>, RecvPacketBuffered<B, Bb>),
        (RecvPacketBuffered<A, Ab>, Option<B>)>

Receives a message from one of two endpoints.

The return value is left if the first endpoint received something, or right if the second endpoint receives something. In each case, the result includes the other endpoint as well so it can be used again. Below is an example of using select2.

match select2(a, b) {
  left((none, b)) {
    // endpoint a was closed.
  }
  right((a, none)) {
    // endpoint b was closed.
  }
  left((Some(_), b)) {
    // endpoint a received a message
  }
  right(a, Some(_)) {
    // endpoint b received a message.
  }
}

Sometimes messages will be available on both endpoints at once. In this case, select2 may return either left or right.

Function select2i

fn select2i<A: Selectable, B: Selectable>(a: &A, b: &B) -> Either<(), ()>

Returns 0 or 1 depending on which endpoint is ready to receive

Function selecti

fn selecti<T: Selectable>(endpoints: &[T]) -> uint

Returns the index of an endpoint that is ready to receive.

Function spawn_service

fn spawn_service<T: Owned,
                 Tb: Owned>(init:
                                extern "Rust" fn()
                                    ->
                                        (SendPacketBuffered<T, Tb>,
                                         RecvPacketBuffered<T, Tb>),
                            service: ~fn(v: RecvPacketBuffered<T, Tb>)) ->
 SendPacketBuffered<T, Tb>

Spawn a task to provide a service.

It takes an initialization function that produces a send and receive endpoint. The send endpoint is returned to the caller and the receive endpoint is passed to the new task.

Function spawn_service_recv

fn spawn_service_recv<T: Owned,
                      Tb: Owned>(init:
                                     extern "Rust" fn()
                                         ->
                                             (RecvPacketBuffered<T, Tb>,
                                              SendPacketBuffered<T, Tb>),
                                 service: ~fn(v: SendPacketBuffered<T, Tb>))
 -> RecvPacketBuffered<T, Tb>

Like spawn_service_recv, but for protocols that start in the receive state.

Function try_recv

fn try_recv<T: Owned, Tbuffer: Owned>(p: RecvPacketBuffered<T, Tbuffer>) ->
 Option<T>

Attempts to receive a message from a pipe.

Returns None if the sender has closed the connection without sending a message, or Some(T) if a message was received.

Function wait_many

fn wait_many<T: Selectable>(pkts: &[T]) -> uint

Returns when one of the packet headers reports data is available.

This function is primarily intended for building higher level waiting functions, such as select, select2, etc.

It takes a vector slice of packet_headers and returns an index into that vector. The index points to an endpoint that has either been closed by the sender or has a message waiting to be received.