mirror of
https://github.com/fluencelabs/rust-libp2p
synced 2025-06-10 08:31:20 +00:00
ca58f8029c
The functionality is available through `Multiaddr::replace`. What we currently call "nat_traversal" is merley a replacement of an IP address prefix in a `Multiaddr`, hence it can be done directly on `Multiaddr` values instead of having to go through a `Transport`. In addition this PR consolidates changes made to `Multiaddr` in previous commits which resulted in lots of deprecations. It adds some more (see below for the complete list of API changes) and removes all deprecated functionality, requiring a minor version bump. Here are the changes to `multiaddr` compared to the currently published version: 1. Removed `into_bytes` (use `to_vec` instead). 2. Renamed `to_bytes` to `to_vec`. 3. Removed `from_bytes` (use the `TryFrom` impl instead). 4. Added `with_capacity`. 5. Added `len`. 6. Removed `as_slice` (use `AsRef` impl instead). 7. Removed `encapsulate` (use `push` or `with` instead). 8. Removed `decapsulate` (use `pop` instead). 9. Renamed `append` to `push`. 10. Added `with`. 11. Added `replace`. 12. Removed `ToMultiaddr` trait (use `TryFrom` instead).
39 lines
1.2 KiB
Rust
39 lines
1.2 KiB
Rust
use bytes::{BufMut, BytesMut};
|
|
|
|
/// An [`io::Write`] impl for [`BytesMut`].
|
|
///
|
|
/// In contrast to [`bytes::buf::Writer`] this [`io::Write] implementation
|
|
/// transparently reserves enough space for [`io::Write::write_all`] to
|
|
/// succeed, i.e. it does not require upfront reservation of space.
|
|
pub(crate) struct BytesWriter(pub(crate) BytesMut);
|
|
|
|
impl std::io::Write for BytesWriter {
|
|
fn write(&mut self, src: &[u8]) -> std::io::Result<usize> {
|
|
let n = std::cmp::min(self.0.remaining_mut(), src.len());
|
|
self.0.put(&src[.. n]);
|
|
Ok(n)
|
|
}
|
|
|
|
fn write_all(&mut self, mut buf: &[u8]) -> std::io::Result<()> {
|
|
if self.0.remaining_mut() < buf.len() {
|
|
self.0.reserve(buf.len() - self.0.remaining_mut());
|
|
}
|
|
while !buf.is_empty() {
|
|
match self.write(buf) {
|
|
Ok(0) => return Err(std::io::ErrorKind::WriteZero.into()),
|
|
Ok(n) => buf = &buf[n ..],
|
|
Err(e) => if e.kind() != std::io::ErrorKind::Interrupted {
|
|
return Err(e)
|
|
}
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn flush(&mut self) -> std::io::Result<()> {
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
|