Struct ComponentMut 

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

A mutable component in an ICE Stream

Implementations

impl<'a> ComponentMut<'a>

pub fn gather_candidates( &mut self, sockets: &[(TransportType, SocketAddr)], stun_servers: &[(TransportType, SocketAddr)], turn_servers: &[(SocketAddr, &TurnConfig)], ) -> Result<(), AgentError>

Start gathering candidates for this component. The parent Agent::poll is used to progress the gathering.

Candidates will be generated as follows (if they succeed):

1. A host candidate for each sockets[i]. If TCP, then both an active and passive host candidate will be generated.
2. For each sockets[i] a reflexive candidate for each stun_server[i] if different from any other candidate produced. The local address for each STUN server connection will be one of the entries provided in sockets.
3. For each turn_servers[i] a TURN allocation will be attempted and a relayed candidate produced on success. If you would like multiple options for relayed candidates, e.g. UDP, TCP, TCP/TLS, then provide each option as different entries in the provided slice. The SocketAddr for each TURN server is the local address to communicate with the TURN server and should be different than any value provided through sockets.

pub fn set_selected_pair( &mut self, selected: CandidatePair, ) -> Result<(), AgentError>

Set the pair that will be used to send/receive data. This will override the ICE negotiation chosen value.

pub fn send<T: AsRef<[u8]> + Debug>( &mut self, data: T, now: Instant, ) -> Result<Transmit<Box<[u8]>>, AgentError>

Send data to the peer using the selected pair. This will not succeed until the Component has reached ComponentConnectionState::Connected

Methods from Deref<Target = Component<'a>>

pub fn id(&self) -> usize

The component identifier within a particular ICE Stream

pub fn stream(&self) -> Stream<'a>

Retrieve the Stream for this component.

Examples

let mut agent = Agent::default();
let stream_id = agent.add_stream();
let mut stream = agent.mut_stream(stream_id).unwrap();
let component_id = stream.add_component().unwrap();
let component = stream.component(component_id).unwrap();
assert_eq!(component.stream().id(), stream_id);

pub fn state(&self) -> ComponentConnectionState

Retrieve the current state of a Component

Examples

The initial state is ComponentState::New

let mut agent = Agent::default();
let stream_id = agent.add_stream();
let mut stream = agent.mut_stream(stream_id).unwrap();
let component_id = stream.add_component().unwrap();
let component = stream.component(component_id).unwrap();
assert_eq!(component.state(), ComponentConnectionState::New);

pub fn selected_pair(&self) -> Option<&CandidatePair>

The CandidatePair this component has selected to send/receive data with. This will not be valid until the Component has reached ComponentConnectionState::Connected

Trait Implementations

impl<'a> Debug for ComponentMut<'a>

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

Formats the value using the given formatter.

impl<'a> Deref for ComponentMut<'a>

type Target = Component<'a>

The resulting type after dereferencing.

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

Dereferences the value.