Peer

webrtc_p2p::peer

Struct Peer 

Source 
pub struct Peer { /* private fields */ }

Implementations§

Source§

impl Peer

Source

pub fn new(api: Arc<API>, options: PeerOptions) -> Self

Examples found in repository?
examples/p2p.rs (lines 35-41)
14async fn main() -> Result<(), webrtc::Error> {
15  let mut m = MediaEngine::default();
16  let registry = register_default_interceptors(Registry::new(), &mut m)?;
17
18  let api = Arc::new(
19    APIBuilder::new()
20      .with_media_engine(m)
21      .with_interceptor_registry(registry)
22      .build(),
23  );
24
25  let options = PeerOptions {
26    connection_config: Some(RTCConfiguration {
27      ice_servers: vec![RTCIceServer {
28        ..Default::default()
29      }],
30      ..Default::default()
31    }),
32    ..Default::default()
33  };
34
35  let peer1 = Peer::new(
36    api.clone(),
37    PeerOptions {
38      id: Some("peer1".to_string()),
39      ..options.clone()
40    },
41  );
42  let peer2 = Peer::new(
43    api,
44    PeerOptions {
45      id: Some("peer2".to_string()),
46      ..options
47    },
48  );
49
50  let on_signal_peer2 = peer2.clone();
51  peer1.on_signal(Box::new(move |singal| {
52    let pinned_peer2 = on_signal_peer2.clone();
53    Box::pin(async move {
54      pinned_peer2
55        .signal(singal)
56        .await
57        .expect("failed to signal peer2");
58    })
59  }));
60
61  let on_signal_peer1 = peer1.clone();
62  peer2.on_signal(Box::new(move |singal| {
63    let pinned_peer1 = on_signal_peer1.clone();
64    Box::pin(async move {
65      pinned_peer1
66        .signal(singal)
67        .await
68        .expect("failed to signal peer1");
69    })
70  }));
71
72  let (connect_sender, mut connect_receiver) = tokio::sync::mpsc::channel::<()>(1);
73  peer2.on_connect(Box::new(move || {
74    let pinned_connect_sender = connect_sender.clone();
75    Box::pin(async move {
76      pinned_connect_sender
77        .send(())
78        .await
79        .expect("failed to send connect");
80    })
81  }));
82
83  let (message_sender, mut message_receiver) = tokio::sync::mpsc::channel::<Vec<u8>>(1);
84  peer1.on_data(Box::new(move |data| {
85    let pinned_message_sender = message_sender.clone();
86    Box::pin(async move {
87      pinned_message_sender
88        .send(data)
89        .await
90        .expect("failed to send connect");
91    })
92  }));
93
94  peer1.init().await?;
95
96  let _ = connect_receiver.recv().await;
97  if let Some(data_channel) = peer2.get_data_channel() {
98    data_channel.send_text("Hello, world!").await?;
99  }
100
101  let data = message_receiver
102    .recv()
103    .await
104    .expect("failed to receive message from peer2");
105
106  assert_eq!(String::from_utf8_lossy(data.as_ref()), "Hello, world!");
107
108  peer1.close().await?;
109  peer2.close().await?;
110
111  Ok(())
112}
Source

pub fn get_id(&self) -> &str

Source

pub fn get_data_channel(&self) -> Option<Arc<RTCDataChannel>>

Examples found in repository?
examples/p2p.rs (line 97)
14async fn main() -> Result<(), webrtc::Error> {
15  let mut m = MediaEngine::default();
16  let registry = register_default_interceptors(Registry::new(), &mut m)?;
17
18  let api = Arc::new(
19    APIBuilder::new()
20      .with_media_engine(m)
21      .with_interceptor_registry(registry)
22      .build(),
23  );
24
25  let options = PeerOptions {
26    connection_config: Some(RTCConfiguration {
27      ice_servers: vec![RTCIceServer {
28        ..Default::default()
29      }],
30      ..Default::default()
31    }),
32    ..Default::default()
33  };
34
35  let peer1 = Peer::new(
36    api.clone(),
37    PeerOptions {
38      id: Some("peer1".to_string()),
39      ..options.clone()
40    },
41  );
42  let peer2 = Peer::new(
43    api,
44    PeerOptions {
45      id: Some("peer2".to_string()),
46      ..options
47    },
48  );
49
50  let on_signal_peer2 = peer2.clone();
51  peer1.on_signal(Box::new(move |singal| {
52    let pinned_peer2 = on_signal_peer2.clone();
53    Box::pin(async move {
54      pinned_peer2
55        .signal(singal)
56        .await
57        .expect("failed to signal peer2");
58    })
59  }));
60
61  let on_signal_peer1 = peer1.clone();
62  peer2.on_signal(Box::new(move |singal| {
63    let pinned_peer1 = on_signal_peer1.clone();
64    Box::pin(async move {
65      pinned_peer1
66        .signal(singal)
67        .await
68        .expect("failed to signal peer1");
69    })
70  }));
71
72  let (connect_sender, mut connect_receiver) = tokio::sync::mpsc::channel::<()>(1);
73  peer2.on_connect(Box::new(move || {
74    let pinned_connect_sender = connect_sender.clone();
75    Box::pin(async move {
76      pinned_connect_sender
77        .send(())
78        .await
79        .expect("failed to send connect");
80    })
81  }));
82
83  let (message_sender, mut message_receiver) = tokio::sync::mpsc::channel::<Vec<u8>>(1);
84  peer1.on_data(Box::new(move |data| {
85    let pinned_message_sender = message_sender.clone();
86    Box::pin(async move {
87      pinned_message_sender
88        .send(data)
89        .await
90        .expect("failed to send connect");
91    })
92  }));
93
94  peer1.init().await?;
95
96  let _ = connect_receiver.recv().await;
97  if let Some(data_channel) = peer2.get_data_channel() {
98    data_channel.send_text("Hello, world!").await?;
99  }
100
101  let data = message_receiver
102    .recv()
103    .await
104    .expect("failed to receive message from peer2");
105
106  assert_eq!(String::from_utf8_lossy(data.as_ref()), "Hello, world!");
107
108  peer1.close().await?;
109  peer2.close().await?;
110
111  Ok(())
112}
Source

pub fn get_connection(&self) -> Option<&RTCPeerConnection>

Source

pub async fn init(&self) -> Result<(), Error>

Examples found in repository?
examples/p2p.rs (line 94)
14async fn main() -> Result<(), webrtc::Error> {
15  let mut m = MediaEngine::default();
16  let registry = register_default_interceptors(Registry::new(), &mut m)?;
17
18  let api = Arc::new(
19    APIBuilder::new()
20      .with_media_engine(m)
21      .with_interceptor_registry(registry)
22      .build(),
23  );
24
25  let options = PeerOptions {
26    connection_config: Some(RTCConfiguration {
27      ice_servers: vec![RTCIceServer {
28        ..Default::default()
29      }],
30      ..Default::default()
31    }),
32    ..Default::default()
33  };
34
35  let peer1 = Peer::new(
36    api.clone(),
37    PeerOptions {
38      id: Some("peer1".to_string()),
39      ..options.clone()
40    },
41  );
42  let peer2 = Peer::new(
43    api,
44    PeerOptions {
45      id: Some("peer2".to_string()),
46      ..options
47    },
48  );
49
50  let on_signal_peer2 = peer2.clone();
51  peer1.on_signal(Box::new(move |singal| {
52    let pinned_peer2 = on_signal_peer2.clone();
53    Box::pin(async move {
54      pinned_peer2
55        .signal(singal)
56        .await
57        .expect("failed to signal peer2");
58    })
59  }));
60
61  let on_signal_peer1 = peer1.clone();
62  peer2.on_signal(Box::new(move |singal| {
63    let pinned_peer1 = on_signal_peer1.clone();
64    Box::pin(async move {
65      pinned_peer1
66        .signal(singal)
67        .await
68        .expect("failed to signal peer1");
69    })
70  }));
71
72  let (connect_sender, mut connect_receiver) = tokio::sync::mpsc::channel::<()>(1);
73  peer2.on_connect(Box::new(move || {
74    let pinned_connect_sender = connect_sender.clone();
75    Box::pin(async move {
76      pinned_connect_sender
77        .send(())
78        .await
79        .expect("failed to send connect");
80    })
81  }));
82
83  let (message_sender, mut message_receiver) = tokio::sync::mpsc::channel::<Vec<u8>>(1);
84  peer1.on_data(Box::new(move |data| {
85    let pinned_message_sender = message_sender.clone();
86    Box::pin(async move {
87      pinned_message_sender
88        .send(data)
89        .await
90        .expect("failed to send connect");
91    })
92  }));
93
94  peer1.init().await?;
95
96  let _ = connect_receiver.recv().await;
97  if let Some(data_channel) = peer2.get_data_channel() {
98    data_channel.send_text("Hello, world!").await?;
99  }
100
101  let data = message_receiver
102    .recv()
103    .await
104    .expect("failed to receive message from peer2");
105
106  assert_eq!(String::from_utf8_lossy(data.as_ref()), "Hello, world!");
107
108  peer1.close().await?;
109  peer2.close().await?;
110
111  Ok(())
112}
Source

pub fn on_signal(&self, callback: OnSignal)

Examples found in repository?
examples/p2p.rs (lines 51-59)
14async fn main() -> Result<(), webrtc::Error> {
15  let mut m = MediaEngine::default();
16  let registry = register_default_interceptors(Registry::new(), &mut m)?;
17
18  let api = Arc::new(
19    APIBuilder::new()
20      .with_media_engine(m)
21      .with_interceptor_registry(registry)
22      .build(),
23  );
24
25  let options = PeerOptions {
26    connection_config: Some(RTCConfiguration {
27      ice_servers: vec![RTCIceServer {
28        ..Default::default()
29      }],
30      ..Default::default()
31    }),
32    ..Default::default()
33  };
34
35  let peer1 = Peer::new(
36    api.clone(),
37    PeerOptions {
38      id: Some("peer1".to_string()),
39      ..options.clone()
40    },
41  );
42  let peer2 = Peer::new(
43    api,
44    PeerOptions {
45      id: Some("peer2".to_string()),
46      ..options
47    },
48  );
49
50  let on_signal_peer2 = peer2.clone();
51  peer1.on_signal(Box::new(move |singal| {
52    let pinned_peer2 = on_signal_peer2.clone();
53    Box::pin(async move {
54      pinned_peer2
55        .signal(singal)
56        .await
57        .expect("failed to signal peer2");
58    })
59  }));
60
61  let on_signal_peer1 = peer1.clone();
62  peer2.on_signal(Box::new(move |singal| {
63    let pinned_peer1 = on_signal_peer1.clone();
64    Box::pin(async move {
65      pinned_peer1
66        .signal(singal)
67        .await
68        .expect("failed to signal peer1");
69    })
70  }));
71
72  let (connect_sender, mut connect_receiver) = tokio::sync::mpsc::channel::<()>(1);
73  peer2.on_connect(Box::new(move || {
74    let pinned_connect_sender = connect_sender.clone();
75    Box::pin(async move {
76      pinned_connect_sender
77        .send(())
78        .await
79        .expect("failed to send connect");
80    })
81  }));
82
83  let (message_sender, mut message_receiver) = tokio::sync::mpsc::channel::<Vec<u8>>(1);
84  peer1.on_data(Box::new(move |data| {
85    let pinned_message_sender = message_sender.clone();
86    Box::pin(async move {
87      pinned_message_sender
88        .send(data)
89        .await
90        .expect("failed to send connect");
91    })
92  }));
93
94  peer1.init().await?;
95
96  let _ = connect_receiver.recv().await;
97  if let Some(data_channel) = peer2.get_data_channel() {
98    data_channel.send_text("Hello, world!").await?;
99  }
100
101  let data = message_receiver
102    .recv()
103    .await
104    .expect("failed to receive message from peer2");
105
106  assert_eq!(String::from_utf8_lossy(data.as_ref()), "Hello, world!");
107
108  peer1.close().await?;
109  peer2.close().await?;
110
111  Ok(())
112}
Source

pub fn on_data(&self, callback: OnData)

Examples found in repository?
examples/p2p.rs (lines 84-92)
14async fn main() -> Result<(), webrtc::Error> {
15  let mut m = MediaEngine::default();
16  let registry = register_default_interceptors(Registry::new(), &mut m)?;
17
18  let api = Arc::new(
19    APIBuilder::new()
20      .with_media_engine(m)
21      .with_interceptor_registry(registry)
22      .build(),
23  );
24
25  let options = PeerOptions {
26    connection_config: Some(RTCConfiguration {
27      ice_servers: vec![RTCIceServer {
28        ..Default::default()
29      }],
30      ..Default::default()
31    }),
32    ..Default::default()
33  };
34
35  let peer1 = Peer::new(
36    api.clone(),
37    PeerOptions {
38      id: Some("peer1".to_string()),
39      ..options.clone()
40    },
41  );
42  let peer2 = Peer::new(
43    api,
44    PeerOptions {
45      id: Some("peer2".to_string()),
46      ..options
47    },
48  );
49
50  let on_signal_peer2 = peer2.clone();
51  peer1.on_signal(Box::new(move |singal| {
52    let pinned_peer2 = on_signal_peer2.clone();
53    Box::pin(async move {
54      pinned_peer2
55        .signal(singal)
56        .await
57        .expect("failed to signal peer2");
58    })
59  }));
60
61  let on_signal_peer1 = peer1.clone();
62  peer2.on_signal(Box::new(move |singal| {
63    let pinned_peer1 = on_signal_peer1.clone();
64    Box::pin(async move {
65      pinned_peer1
66        .signal(singal)
67        .await
68        .expect("failed to signal peer1");
69    })
70  }));
71
72  let (connect_sender, mut connect_receiver) = tokio::sync::mpsc::channel::<()>(1);
73  peer2.on_connect(Box::new(move || {
74    let pinned_connect_sender = connect_sender.clone();
75    Box::pin(async move {
76      pinned_connect_sender
77        .send(())
78        .await
79        .expect("failed to send connect");
80    })
81  }));
82
83  let (message_sender, mut message_receiver) = tokio::sync::mpsc::channel::<Vec<u8>>(1);
84  peer1.on_data(Box::new(move |data| {
85    let pinned_message_sender = message_sender.clone();
86    Box::pin(async move {
87      pinned_message_sender
88        .send(data)
89        .await
90        .expect("failed to send connect");
91    })
92  }));
93
94  peer1.init().await?;
95
96  let _ = connect_receiver.recv().await;
97  if let Some(data_channel) = peer2.get_data_channel() {
98    data_channel.send_text("Hello, world!").await?;
99  }
100
101  let data = message_receiver
102    .recv()
103    .await
104    .expect("failed to receive message from peer2");
105
106  assert_eq!(String::from_utf8_lossy(data.as_ref()), "Hello, world!");
107
108  peer1.close().await?;
109  peer2.close().await?;
110
111  Ok(())
112}
Source

pub fn on_connect(&self, callback: OnConnect)

Examples found in repository?
examples/p2p.rs (lines 73-81)
14async fn main() -> Result<(), webrtc::Error> {
15  let mut m = MediaEngine::default();
16  let registry = register_default_interceptors(Registry::new(), &mut m)?;
17
18  let api = Arc::new(
19    APIBuilder::new()
20      .with_media_engine(m)
21      .with_interceptor_registry(registry)
22      .build(),
23  );
24
25  let options = PeerOptions {
26    connection_config: Some(RTCConfiguration {
27      ice_servers: vec![RTCIceServer {
28        ..Default::default()
29      }],
30      ..Default::default()
31    }),
32    ..Default::default()
33  };
34
35  let peer1 = Peer::new(
36    api.clone(),
37    PeerOptions {
38      id: Some("peer1".to_string()),
39      ..options.clone()
40    },
41  );
42  let peer2 = Peer::new(
43    api,
44    PeerOptions {
45      id: Some("peer2".to_string()),
46      ..options
47    },
48  );
49
50  let on_signal_peer2 = peer2.clone();
51  peer1.on_signal(Box::new(move |singal| {
52    let pinned_peer2 = on_signal_peer2.clone();
53    Box::pin(async move {
54      pinned_peer2
55        .signal(singal)
56        .await
57        .expect("failed to signal peer2");
58    })
59  }));
60
61  let on_signal_peer1 = peer1.clone();
62  peer2.on_signal(Box::new(move |singal| {
63    let pinned_peer1 = on_signal_peer1.clone();
64    Box::pin(async move {
65      pinned_peer1
66        .signal(singal)
67        .await
68        .expect("failed to signal peer1");
69    })
70  }));
71
72  let (connect_sender, mut connect_receiver) = tokio::sync::mpsc::channel::<()>(1);
73  peer2.on_connect(Box::new(move || {
74    let pinned_connect_sender = connect_sender.clone();
75    Box::pin(async move {
76      pinned_connect_sender
77        .send(())
78        .await
79        .expect("failed to send connect");
80    })
81  }));
82
83  let (message_sender, mut message_receiver) = tokio::sync::mpsc::channel::<Vec<u8>>(1);
84  peer1.on_data(Box::new(move |data| {
85    let pinned_message_sender = message_sender.clone();
86    Box::pin(async move {
87      pinned_message_sender
88        .send(data)
89        .await
90        .expect("failed to send connect");
91    })
92  }));
93
94  peer1.init().await?;
95
96  let _ = connect_receiver.recv().await;
97  if let Some(data_channel) = peer2.get_data_channel() {
98    data_channel.send_text("Hello, world!").await?;
99  }
100
101  let data = message_receiver
102    .recv()
103    .await
104    .expect("failed to receive message from peer2");
105
106  assert_eq!(String::from_utf8_lossy(data.as_ref()), "Hello, world!");
107
108  peer1.close().await?;
109  peer2.close().await?;
110
111  Ok(())
112}
Source

pub fn on_close(&self, callback: OnClose)

Source

pub fn on_negotiated(&self, callback: OnNegotiated)

Source

pub async fn close(&self) -> Result<(), Error>

Examples found in repository?
examples/p2p.rs (line 108)
14async fn main() -> Result<(), webrtc::Error> {
15  let mut m = MediaEngine::default();
16  let registry = register_default_interceptors(Registry::new(), &mut m)?;
17
18  let api = Arc::new(
19    APIBuilder::new()
20      .with_media_engine(m)
21      .with_interceptor_registry(registry)
22      .build(),
23  );
24
25  let options = PeerOptions {
26    connection_config: Some(RTCConfiguration {
27      ice_servers: vec![RTCIceServer {
28        ..Default::default()
29      }],
30      ..Default::default()
31    }),
32    ..Default::default()
33  };
34
35  let peer1 = Peer::new(
36    api.clone(),
37    PeerOptions {
38      id: Some("peer1".to_string()),
39      ..options.clone()
40    },
41  );
42  let peer2 = Peer::new(
43    api,
44    PeerOptions {
45      id: Some("peer2".to_string()),
46      ..options
47    },
48  );
49
50  let on_signal_peer2 = peer2.clone();
51  peer1.on_signal(Box::new(move |singal| {
52    let pinned_peer2 = on_signal_peer2.clone();
53    Box::pin(async move {
54      pinned_peer2
55        .signal(singal)
56        .await
57        .expect("failed to signal peer2");
58    })
59  }));
60
61  let on_signal_peer1 = peer1.clone();
62  peer2.on_signal(Box::new(move |singal| {
63    let pinned_peer1 = on_signal_peer1.clone();
64    Box::pin(async move {
65      pinned_peer1
66        .signal(singal)
67        .await
68        .expect("failed to signal peer1");
69    })
70  }));
71
72  let (connect_sender, mut connect_receiver) = tokio::sync::mpsc::channel::<()>(1);
73  peer2.on_connect(Box::new(move || {
74    let pinned_connect_sender = connect_sender.clone();
75    Box::pin(async move {
76      pinned_connect_sender
77        .send(())
78        .await
79        .expect("failed to send connect");
80    })
81  }));
82
83  let (message_sender, mut message_receiver) = tokio::sync::mpsc::channel::<Vec<u8>>(1);
84  peer1.on_data(Box::new(move |data| {
85    let pinned_message_sender = message_sender.clone();
86    Box::pin(async move {
87      pinned_message_sender
88        .send(data)
89        .await
90        .expect("failed to send connect");
91    })
92  }));
93
94  peer1.init().await?;
95
96  let _ = connect_receiver.recv().await;
97  if let Some(data_channel) = peer2.get_data_channel() {
98    data_channel.send_text("Hello, world!").await?;
99  }
100
101  let data = message_receiver
102    .recv()
103    .await
104    .expect("failed to receive message from peer2");
105
106  assert_eq!(String::from_utf8_lossy(data.as_ref()), "Hello, world!");
107
108  peer1.close().await?;
109  peer2.close().await?;
110
111  Ok(())
112}
Source

pub async fn signal(&self, msg: SignalMessage) -> Result<(), Error>

Examples found in repository?
examples/p2p.rs (line 55)
14async fn main() -> Result<(), webrtc::Error> {
15  let mut m = MediaEngine::default();
16  let registry = register_default_interceptors(Registry::new(), &mut m)?;
17
18  let api = Arc::new(
19    APIBuilder::new()
20      .with_media_engine(m)
21      .with_interceptor_registry(registry)
22      .build(),
23  );
24
25  let options = PeerOptions {
26    connection_config: Some(RTCConfiguration {
27      ice_servers: vec![RTCIceServer {
28        ..Default::default()
29      }],
30      ..Default::default()
31    }),
32    ..Default::default()
33  };
34
35  let peer1 = Peer::new(
36    api.clone(),
37    PeerOptions {
38      id: Some("peer1".to_string()),
39      ..options.clone()
40    },
41  );
42  let peer2 = Peer::new(
43    api,
44    PeerOptions {
45      id: Some("peer2".to_string()),
46      ..options
47    },
48  );
49
50  let on_signal_peer2 = peer2.clone();
51  peer1.on_signal(Box::new(move |singal| {
52    let pinned_peer2 = on_signal_peer2.clone();
53    Box::pin(async move {
54      pinned_peer2
55        .signal(singal)
56        .await
57        .expect("failed to signal peer2");
58    })
59  }));
60
61  let on_signal_peer1 = peer1.clone();
62  peer2.on_signal(Box::new(move |singal| {
63    let pinned_peer1 = on_signal_peer1.clone();
64    Box::pin(async move {
65      pinned_peer1
66        .signal(singal)
67        .await
68        .expect("failed to signal peer1");
69    })
70  }));
71
72  let (connect_sender, mut connect_receiver) = tokio::sync::mpsc::channel::<()>(1);
73  peer2.on_connect(Box::new(move || {
74    let pinned_connect_sender = connect_sender.clone();
75    Box::pin(async move {
76      pinned_connect_sender
77        .send(())
78        .await
79        .expect("failed to send connect");
80    })
81  }));
82
83  let (message_sender, mut message_receiver) = tokio::sync::mpsc::channel::<Vec<u8>>(1);
84  peer1.on_data(Box::new(move |data| {
85    let pinned_message_sender = message_sender.clone();
86    Box::pin(async move {
87      pinned_message_sender
88        .send(data)
89        .await
90        .expect("failed to send connect");
91    })
92  }));
93
94  peer1.init().await?;
95
96  let _ = connect_receiver.recv().await;
97  if let Some(data_channel) = peer2.get_data_channel() {
98    data_channel.send_text("Hello, world!").await?;
99  }
100
101  let data = message_receiver
102    .recv()
103    .await
104    .expect("failed to receive message from peer2");
105
106  assert_eq!(String::from_utf8_lossy(data.as_ref()), "Hello, world!");
107
108  peer1.close().await?;
109  peer2.close().await?;
110
111  Ok(())
112}

Trait Implementations§

Source§

impl Clone for Peer

Source§

fn clone(&self) -> Peer

Returns a duplicate of the value. Read more
1.0.0 · Source§

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

Performs copy-assignment from source. Read more
Source§

impl Send for Peer

Source§

impl Sync for Peer

Auto Trait Implementations§

§

impl Freeze for Peer

§

impl !RefUnwindSafe for Peer

§

impl Unpin for Peer

§

impl !UnwindSafe for Peer

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<'a, T, E> AsTaggedExplicit<'a, E> for T
where T: 'a,

Source§

fn explicit(self, class: Class, tag: u32) -> TaggedParser<'a, Explicit, Self, E>

Source§

impl<'a, T, E> AsTaggedImplicit<'a, E> for T
where T: 'a,

Source§

fn implicit( self, class: Class, constructed: bool, tag: u32, ) -> TaggedParser<'a, Implicit, Self, E>

Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> CloneToUninit for T
where T: Clone,

Source§

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dest. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> Same for T

Source§

type Output = T

Should always be Self
Source§

impl<T> ToOwned for T
where T: Clone,

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
Source§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

Source§

fn vzip(self) -> V

Source§

impl<T> ErasedDestructor for T
where T: 'static,