cidr 0.3.2

IP network and IP host within network types
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

#![cfg(any(feature = "serde", test))]

// formatting Cidr/Inet to str without std/alloc

use core::fmt;
#[cfg(not(feature = "no_unsafe"))]
use core::mem::MaybeUninit;

// from core::net, adapted to work with stable rust and `no_unsafe`
// https://github.com/rust-lang/rust/blob/d8d5732456d375f7c4bdc2f6ad771989a5e0ae02/library/core/src/net/display_buffer.rs
// https://github.com/rust-lang/rust/blob/master/COPYRIGHT

struct DisplayBuffer<const SIZE: usize> {
	#[cfg(not(feature = "no_unsafe"))]
	buf: [MaybeUninit<u8>; SIZE],
	#[cfg(feature = "no_unsafe")]
	buf: [u8; SIZE],
	len: usize,
}

impl<const SIZE: usize> DisplayBuffer<SIZE> {
	#[inline]
	pub fn new() -> Self {
		#[cfg(not(feature = "no_unsafe"))]
		{
			let buf = unsafe { MaybeUninit::<[MaybeUninit<u8>; SIZE]>::uninit().assume_init() };
			Self { buf, len: 0 }
		}
		#[cfg(feature = "no_unsafe")]
		{
			Self {
				buf: [0; SIZE],
				len: 0,
			}
		}
	}
}

impl<const SIZE: usize> core::ops::Deref for DisplayBuffer<SIZE> {
	type Target = str;

	#[inline]
	fn deref(&self) -> &Self::Target {
		// SAFETY: `buf` is only written to by the `fmt::Write::write_str` implementation
		// which writes a valid UTF-8 string to `buf` and correctly sets `len`.
		#[cfg(not(feature = "no_unsafe"))]
		unsafe {
			let written = &self.buf[..self.len];
			let s = &*(written as *const [_] as *const [u8]);
			core::str::from_utf8_unchecked(s)
		}
		#[cfg(feature = "no_unsafe")]
		{
			core::str::from_utf8(&self.buf[..self.len]).expect("proper string")
		}
	}
}

impl<const SIZE: usize> fmt::Write for DisplayBuffer<SIZE> {
	fn write_str(&mut self, s: &str) -> fmt::Result {
		let bytes = s.as_bytes();

		if let Some(buf) = self.buf.get_mut(self.len..(self.len + bytes.len())) {
			#[cfg(not(feature = "no_unsafe"))]
			buf.copy_from_slice(unsafe { core::mem::transmute(bytes) });
			#[cfg(feature = "no_unsafe")]
			buf.copy_from_slice(bytes);
			self.len += bytes.len();
			Ok(())
		} else {
			Err(fmt::Error)
		}
	}
}

const LONGEST_IPV6_CIDR: &str = "V6(ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128)";

pub fn format_cidr_fixed(args: fmt::Arguments<'_>) -> impl core::ops::Deref<Target = str> {
	let mut result = DisplayBuffer::<{ LONGEST_IPV6_CIDR.len() }>::new();
	fmt::write(&mut result, args).expect("format failed");
	result
}

macro_rules! format_cidr_fixed {
	($($tt:tt)*) => {
		&*crate::display_buffer::format_cidr_fixed(format_args!($($tt)*))
	};
}