/rust/registry/src/index.crates.io-1949cf8c6b5b557f/bitvec-1.0.1/src/boxed/traits.rs

Source
//! General trait implementations for boxed bit-slices.

use alloc::{
  borrow::Cow,
  boxed::Box,
};
use core::{
  borrow::{
    Borrow,
    BorrowMut,
  },
  cmp,
  convert::TryFrom,
  fmt::{
    self,
    Debug,
    Display,
    Formatter,
  },
  hash::{
    Hash,
    Hasher,
  },
  iter::FromIterator,
};

use tap::Pipe;

use super::BitBox;
use crate::{
  array::BitArray,
  order::BitOrder,
  slice::BitSlice,
  store::BitStore,
  vec::BitVec,
  view::BitViewSized,
};

#[cfg(not(tarpaulin_include))]
impl<T, O> Borrow<BitSlice<T, O>> for BitBox<T, O>
where
  T: BitStore,
  O: BitOrder,
{
  #[inline]
  fn borrow(&self) -> &BitSlice<T, O> {
    self.as_bitslice()
  }
}

#[cfg(not(tarpaulin_include))]
impl<T, O> BorrowMut<BitSlice<T, O>> for BitBox<T, O>
where
  T: BitStore,
  O: BitOrder,
{
  #[inline]
  fn borrow_mut(&mut self) -> &mut BitSlice<T, O> {
    self.as_mut_bitslice()
  }
}

#[cfg(not(tarpaulin_include))]
impl<T, O> Clone for BitBox<T, O>
where
  T: BitStore,
  O: BitOrder,
{
  #[inline]
  fn clone(&self) -> Self {
    self.as_bitslice().pipe(Self::from_bitslice)
  }
}

#[cfg(not(tarpaulin_include))]
impl<T, O> Eq for BitBox<T, O>
where
  T: BitStore,
  O: BitOrder,
{
}

#[cfg(not(tarpaulin_include))]
impl<T, O> Ord for BitBox<T, O>
where
  T: BitStore,
  O: BitOrder,
{
  #[inline]
  fn cmp(&self, other: &Self) -> cmp::Ordering {
    self.as_bitslice().cmp(other.as_bitslice())
  }
}

#[cfg(not(tarpaulin_include))]
impl<O1, O2, T1, T2> PartialEq<BitBox<T2, O2>> for BitSlice<T1, O1>
where
  O1: BitOrder,
  O2: BitOrder,
  T1: BitStore,
  T2: BitStore,
{
  #[inline]
  fn eq(&self, other: &BitBox<T2, O2>) -> bool {
    self == other.as_bitslice()
  }
}

#[cfg(not(tarpaulin_include))]
impl<O1, O2, T1, T2> PartialEq<BitBox<T2, O2>> for &BitSlice<T1, O1>
where
  O1: BitOrder,
  O2: BitOrder,
  T1: BitStore,
  T2: BitStore,
{
  #[inline]
  fn eq(&self, other: &BitBox<T2, O2>) -> bool {
    *self == other.as_bitslice()
  }
}

#[cfg(not(tarpaulin_include))]
impl<O1, O2, T1, T2> PartialEq<BitBox<T2, O2>> for &mut BitSlice<T1, O1>
where
  O1: BitOrder,
  O2: BitOrder,
  T1: BitStore,
  T2: BitStore,
{
  #[inline]
  fn eq(&self, other: &BitBox<T2, O2>) -> bool {
    **self == other.as_bitslice()
  }
}

#[cfg(not(tarpaulin_include))]
impl<T, O, Rhs> PartialEq<Rhs> for BitBox<T, O>
where
  T: BitStore,
  O: BitOrder,
  Rhs: ?Sized + PartialEq<BitSlice<T, O>>,
{
  #[inline]
  fn eq(&self, other: &Rhs) -> bool {
    other == self.as_bitslice()
  }
}

#[cfg(not(tarpaulin_include))]
impl<O1, O2, T1, T2> PartialOrd<BitBox<T2, O2>> for BitSlice<T1, O1>
where
  O1: BitOrder,
  O2: BitOrder,
  T1: BitStore,
  T2: BitStore,
{
  #[inline]
  fn partial_cmp(&self, other: &BitBox<T2, O2>) -> Option<cmp::Ordering> {
    self.partial_cmp(other.as_bitslice())
  }
}

#[cfg(not(tarpaulin_include))]
impl<T, O, Rhs> PartialOrd<Rhs> for BitBox<T, O>
where
  T: BitStore,
  O: BitOrder,
  Rhs: ?Sized + PartialOrd<BitSlice<T, O>>,
{
  #[inline]
  fn partial_cmp(&self, other: &Rhs) -> Option<cmp::Ordering> {
    other.partial_cmp(self.as_bitslice())
  }
}

#[cfg(not(tarpaulin_include))]
impl<'a, O1, O2, T1, T2> PartialOrd<BitBox<T2, O2>> for &'a BitSlice<T1, O1>
where
  O1: BitOrder,
  O2: BitOrder,
  T1: BitStore,
  T2: BitStore,
{
  #[inline]
  fn partial_cmp(&self, other: &BitBox<T2, O2>) -> Option<cmp::Ordering> {
    self.partial_cmp(other.as_bitslice())
  }
}

#[cfg(not(tarpaulin_include))]
impl<'a, O1, O2, T1, T2> PartialOrd<BitBox<T2, O2>> for &'a mut BitSlice<T1, O1>
where
  O1: BitOrder,
  O2: BitOrder,
  T1: BitStore,
  T2: BitStore,
{
  #[inline]
  fn partial_cmp(&self, other: &BitBox<T2, O2>) -> Option<cmp::Ordering> {
    self.partial_cmp(other.as_bitslice())
  }
}

#[cfg(not(tarpaulin_include))]
impl<T, O> AsRef<BitSlice<T, O>> for BitBox<T, O>
where
  T: BitStore,
  O: BitOrder,
{
  #[inline]
  fn as_ref(&self) -> &BitSlice<T, O> {
    self.as_bitslice()
  }
}

#[cfg(not(tarpaulin_include))]
impl<T, O> AsMut<BitSlice<T, O>> for BitBox<T, O>
where
  T: BitStore,
  O: BitOrder,
{
  #[inline]
  fn as_mut(&mut self) -> &mut BitSlice<T, O> {
    self.as_mut_bitslice()
  }
}

impl<T, O> From<&'_ BitSlice<T, O>> for BitBox<T, O>
where
  T: BitStore,
  O: BitOrder,
{
  #[inline]
  fn from(slice: &BitSlice<T, O>) -> Self {
    slice.pipe(Self::from_bitslice)
  }
}

impl<A, O> From<BitArray<A, O>> for BitBox<A::Store, O>
where
  A: BitViewSized,
  O: BitOrder,
{
  #[inline]
  fn from(array: BitArray<A, O>) -> Self {
    array.as_bitslice().pipe(Self::from_bitslice)
  }
}

impl<T, O> From<Box<T>> for BitBox<T, O>
where
  T: BitStore,
  O: BitOrder,
{
  #[inline]
  fn from(elem: Box<T>) -> Self {
    unsafe {
      Box::from_raw(Box::into_raw(elem).cast::<[T; 1]>() as *mut [T])
    }
    .pipe(Self::from_boxed_slice)
  }
}

impl<'a, T, O> From<Cow<'a, BitSlice<T, O>>> for BitBox<T, O>
where
  T: BitStore,
  O: BitOrder,
{
  #[inline]
  fn from(cow: Cow<'a, BitSlice<T, O>>) -> Self {
    cow.into_owned().into_boxed_bitslice()
  }
}

impl<T, O> From<BitVec<T, O>> for BitBox<T, O>
where
  T: BitStore,
  O: BitOrder,
{
  #[inline]
  fn from(bv: BitVec<T, O>) -> Self {
    bv.into_boxed_bitslice()
  }
}

impl<T, O> From<BitBox<T, O>> for Box<[T]>
where
  T: BitStore,
  O: BitOrder,
{
  #[inline]
  fn from(bb: BitBox<T, O>) -> Self {
    bb.into_boxed_slice()
  }
}

impl<T, O> TryFrom<Box<[T]>> for BitBox<T, O>
where
  T: BitStore,
  O: BitOrder,
{
  type Error = Box<[T]>;

  #[inline]
  fn try_from(boxed: Box<[T]>) -> Result<Self, Self::Error> {
    Self::try_from_boxed_slice(boxed)
  }
}

impl<T, O> Default for BitBox<T, O>
where
  T: BitStore,
  O: BitOrder,
{
  #[inline]
  fn default() -> Self {
    Self::from_bitslice(BitSlice::<T, O>::empty())
  }
}

impl<T, O> Debug for BitBox<T, O>
where
  T: BitStore,
  O: BitOrder,
{
  #[inline]
  fn fmt(&self, fmt: &mut Formatter) -> fmt::Result {
    self.bitspan.render(fmt, "Box", None)?;
    fmt.write_str(" ")?;
    Display::fmt(self, fmt)
  }
}

easy_fmt! {
  impl Binary
  impl Display
  impl LowerHex
  impl Octal
  impl Pointer
  impl UpperHex
  for BitBox
}

#[cfg(not(tarpaulin_include))]
impl<T, O, I> FromIterator<I> for BitBox<T, O>
where
  T: BitStore,
  O: BitOrder,
  BitVec<T, O>: FromIterator<I>,
{
  #[inline]
  fn from_iter<II>(iter: II) -> Self
  where II: IntoIterator<Item = I> {
    BitVec::from_iter(iter).into_boxed_bitslice()
  }
}

#[cfg(not(tarpaulin_include))]
impl<T, O> Hash for BitBox<T, O>
where
  T: BitStore,
  O: BitOrder,
{
  #[inline]
  fn hash<H>(&self, state: &mut H)
  where H: Hasher {
    self.as_bitslice().hash(state)
  }
}

unsafe impl<T, O> Send for BitBox<T, O>
where
  T: BitStore,
  O: BitOrder,
{
}

unsafe impl<T, O> Sync for BitBox<T, O>
where
  T: BitStore,
  O: BitOrder,
{
}

impl<T, O> Unpin for BitBox<T, O>
where
  T: BitStore,
  O: BitOrder,
{
}

Coverage Report

Created: 2025-10-21 06:22

Line	Count	Source
1		//! General trait implementations for boxed bit-slices.
2
3		use alloc::{
4		borrow::Cow,
5		boxed::Box,
6		};
7		use core::{
8		borrow::{
9		Borrow,
10		BorrowMut,
11		},
12		cmp,
13		convert::TryFrom,
14		fmt::{
15		self,
16		Debug,
17		Display,
18		Formatter,
19		},
20		hash::{
21		Hash,
22		Hasher,
23		},
24		iter::FromIterator,
25		};
26
27		use tap::Pipe;
28
29		use super::BitBox;
30		use crate::{
31		array::BitArray,
32		order::BitOrder,
33		slice::BitSlice,
34		store::BitStore,
35		vec::BitVec,
36		view::BitViewSized,
37		};
38
39		#[cfg(not(tarpaulin_include))]
40		impl<T, O> Borrow<BitSlice<T, O>> for BitBox<T, O>
41		where
42		T: BitStore,
43		O: BitOrder,
44		{
45		#[inline]
46	0	fn borrow(&self) -> &BitSlice<T, O> {
47	0	self.as_bitslice()
48	0	}
49		}
50
51		#[cfg(not(tarpaulin_include))]
52		impl<T, O> BorrowMut<BitSlice<T, O>> for BitBox<T, O>
53		where
54		T: BitStore,
55		O: BitOrder,
56		{
57		#[inline]
58	0	fn borrow_mut(&mut self) -> &mut BitSlice<T, O> {
59	0	self.as_mut_bitslice()
60	0	}
61		}
62
63		#[cfg(not(tarpaulin_include))]
64		impl<T, O> Clone for BitBox<T, O>
65		where
66		T: BitStore,
67		O: BitOrder,
68		{
69		#[inline]
70	0	fn clone(&self) -> Self {
71	0	self.as_bitslice().pipe(Self::from_bitslice)
72	0	}
73		}
74
75		#[cfg(not(tarpaulin_include))]
76		impl<T, O> Eq for BitBox<T, O>
77		where
78		T: BitStore,
79		O: BitOrder,
80		{
81		}
82
83		#[cfg(not(tarpaulin_include))]
84		impl<T, O> Ord for BitBox<T, O>
85		where
86		T: BitStore,
87		O: BitOrder,
88		{
89		#[inline]
90	0	fn cmp(&self, other: &Self) -> cmp::Ordering {
91	0	self.as_bitslice().cmp(other.as_bitslice())
92	0	}
93		}
94
95		#[cfg(not(tarpaulin_include))]
96		impl<O1, O2, T1, T2> PartialEq<BitBox<T2, O2>> for BitSlice<T1, O1>
97		where
98		O1: BitOrder,
99		O2: BitOrder,
100		T1: BitStore,
101		T2: BitStore,
102		{
103		#[inline]
104	0	fn eq(&self, other: &BitBox<T2, O2>) -> bool {
105	0	self == other.as_bitslice()
106	0	}
107		}
108
109		#[cfg(not(tarpaulin_include))]
110		impl<O1, O2, T1, T2> PartialEq<BitBox<T2, O2>> for &BitSlice<T1, O1>
111		where
112		O1: BitOrder,
113		O2: BitOrder,
114		T1: BitStore,
115		T2: BitStore,
116		{
117		#[inline]
118	0	fn eq(&self, other: &BitBox<T2, O2>) -> bool {
119	0	*self == other.as_bitslice()
120	0	}
121		}
122
123		#[cfg(not(tarpaulin_include))]
124		impl<O1, O2, T1, T2> PartialEq<BitBox<T2, O2>> for &mut BitSlice<T1, O1>
125		where
126		O1: BitOrder,
127		O2: BitOrder,
128		T1: BitStore,
129		T2: BitStore,
130		{
131		#[inline]
132	0	fn eq(&self, other: &BitBox<T2, O2>) -> bool {
133	0	**self == other.as_bitslice()
134	0	}
135		}
136
137		#[cfg(not(tarpaulin_include))]
138		impl<T, O, Rhs> PartialEq<Rhs> for BitBox<T, O>
139		where
140		T: BitStore,
141		O: BitOrder,
142		Rhs: ?Sized + PartialEq<BitSlice<T, O>>,
143		{
144		#[inline]
145	0	fn eq(&self, other: &Rhs) -> bool {
146	0	other == self.as_bitslice()
147	0	}
148		}
149
150		#[cfg(not(tarpaulin_include))]
151		impl<O1, O2, T1, T2> PartialOrd<BitBox<T2, O2>> for BitSlice<T1, O1>
152		where
153		O1: BitOrder,
154		O2: BitOrder,
155		T1: BitStore,
156		T2: BitStore,
157		{
158		#[inline]
159	0	fn partial_cmp(&self, other: &BitBox<T2, O2>) -> Option<cmp::Ordering> {
160	0	self.partial_cmp(other.as_bitslice())
161	0	}
162		}
163
164		#[cfg(not(tarpaulin_include))]
165		impl<T, O, Rhs> PartialOrd<Rhs> for BitBox<T, O>
166		where
167		T: BitStore,
168		O: BitOrder,
169		Rhs: ?Sized + PartialOrd<BitSlice<T, O>>,
170		{
171		#[inline]
172	0	fn partial_cmp(&self, other: &Rhs) -> Option<cmp::Ordering> {
173	0	other.partial_cmp(self.as_bitslice())
174	0	}
175		}
176
177		#[cfg(not(tarpaulin_include))]
178		impl<'a, O1, O2, T1, T2> PartialOrd<BitBox<T2, O2>> for &'a BitSlice<T1, O1>
179		where
180		O1: BitOrder,
181		O2: BitOrder,
182		T1: BitStore,
183		T2: BitStore,
184		{
185		#[inline]
186	0	fn partial_cmp(&self, other: &BitBox<T2, O2>) -> Option<cmp::Ordering> {
187	0	self.partial_cmp(other.as_bitslice())
188	0	}
189		}
190
191		#[cfg(not(tarpaulin_include))]
192		impl<'a, O1, O2, T1, T2> PartialOrd<BitBox<T2, O2>> for &'a mut BitSlice<T1, O1>
193		where
194		O1: BitOrder,
195		O2: BitOrder,
196		T1: BitStore,
197		T2: BitStore,
198		{
199		#[inline]
200	0	fn partial_cmp(&self, other: &BitBox<T2, O2>) -> Option<cmp::Ordering> {
201	0	self.partial_cmp(other.as_bitslice())
202	0	}
203		}
204
205		#[cfg(not(tarpaulin_include))]
206		impl<T, O> AsRef<BitSlice<T, O>> for BitBox<T, O>
207		where
208		T: BitStore,
209		O: BitOrder,
210		{
211		#[inline]
212	0	fn as_ref(&self) -> &BitSlice<T, O> {
213	0	self.as_bitslice()
214	0	}
215		}
216
217		#[cfg(not(tarpaulin_include))]
218		impl<T, O> AsMut<BitSlice<T, O>> for BitBox<T, O>
219		where
220		T: BitStore,
221		O: BitOrder,
222		{
223		#[inline]
224	0	fn as_mut(&mut self) -> &mut BitSlice<T, O> {
225	0	self.as_mut_bitslice()
226	0	}
227		}
228
229		impl<T, O> From<&'_ BitSlice<T, O>> for BitBox<T, O>
230		where
231		T: BitStore,
232		O: BitOrder,
233		{
234		#[inline]
235	0	fn from(slice: &BitSlice<T, O>) -> Self {
236	0	slice.pipe(Self::from_bitslice)
237	0	}
238		}
239
240		impl<A, O> From<BitArray<A, O>> for BitBox<A::Store, O>
241		where
242		A: BitViewSized,
243		O: BitOrder,
244		{
245		#[inline]
246	0	fn from(array: BitArray<A, O>) -> Self {
247	0	array.as_bitslice().pipe(Self::from_bitslice)
248	0	}
249		}
250
251		impl<T, O> From<Box<T>> for BitBox<T, O>
252		where
253		T: BitStore,
254		O: BitOrder,
255		{
256		#[inline]
257	0	fn from(elem: Box<T>) -> Self {
258		unsafe {
259	0	Box::from_raw(Box::into_raw(elem).cast::<[T; 1]>() as *mut [T])
260		}
261	0	.pipe(Self::from_boxed_slice)
262	0	}
263		}
264
265		impl<'a, T, O> From<Cow<'a, BitSlice<T, O>>> for BitBox<T, O>
266		where
267		T: BitStore,
268		O: BitOrder,
269		{
270		#[inline]
271	0	fn from(cow: Cow<'a, BitSlice<T, O>>) -> Self {
272	0	cow.into_owned().into_boxed_bitslice()
273	0	}
274		}
275
276		impl<T, O> From<BitVec<T, O>> for BitBox<T, O>
277		where
278		T: BitStore,
279		O: BitOrder,
280		{
281		#[inline]
282	0	fn from(bv: BitVec<T, O>) -> Self {
283	0	bv.into_boxed_bitslice()
284	0	}
285		}
286
287		impl<T, O> From<BitBox<T, O>> for Box<[T]>
288		where
289		T: BitStore,
290		O: BitOrder,
291		{
292		#[inline]
293	0	fn from(bb: BitBox<T, O>) -> Self {
294	0	bb.into_boxed_slice()
295	0	}
296		}
297
298		impl<T, O> TryFrom<Box<[T]>> for BitBox<T, O>
299		where
300		T: BitStore,
301		O: BitOrder,
302		{
303		type Error = Box<[T]>;
304
305		#[inline]
306	0	fn try_from(boxed: Box<[T]>) -> Result<Self, Self::Error> {
307	0	Self::try_from_boxed_slice(boxed)
308	0	}
309		}
310
311		impl<T, O> Default for BitBox<T, O>
312		where
313		T: BitStore,
314		O: BitOrder,
315		{
316		#[inline]
317	0	fn default() -> Self {
318	0	Self::from_bitslice(BitSlice::<T, O>::empty())
319	0	}
320		}
321
322		impl<T, O> Debug for BitBox<T, O>
323		where
324		T: BitStore,
325		O: BitOrder,
326		{
327		#[inline]
328	0	fn fmt(&self, fmt: &mut Formatter) -> fmt::Result {
329	0	self.bitspan.render(fmt, "Box", None)?;
330	0	fmt.write_str(" ")?;
331	0	Display::fmt(self, fmt)
332	0	}
333		}
334
335		easy_fmt! {
336		impl Binary
337		impl Display
338		impl LowerHex
339		impl Octal
340		impl Pointer
341		impl UpperHex
342		for BitBox
343		}
344
345		#[cfg(not(tarpaulin_include))]
346		impl<T, O, I> FromIterator<I> for BitBox<T, O>
347		where
348		T: BitStore,
349		O: BitOrder,
350		BitVec<T, O>: FromIterator<I>,
351		{
352		#[inline]
353	0	fn from_iter<II>(iter: II) -> Self
354	0	where II: IntoIterator<Item = I> {
355	0	BitVec::from_iter(iter).into_boxed_bitslice()
356	0	}
357		}
358
359		#[cfg(not(tarpaulin_include))]
360		impl<T, O> Hash for BitBox<T, O>
361		where
362		T: BitStore,
363		O: BitOrder,
364		{
365		#[inline]
366	0	fn hash<H>(&self, state: &mut H)
367	0	where H: Hasher {
368	0	self.as_bitslice().hash(state)
369	0	}
370		}
371
372		unsafe impl<T, O> Send for BitBox<T, O>
373		where
374		T: BitStore,
375		O: BitOrder,
376		{
377		}
378
379		unsafe impl<T, O> Sync for BitBox<T, O>
380		where
381		T: BitStore,
382		O: BitOrder,
383		{
384		}
385
386		impl<T, O> Unpin for BitBox<T, O>
387		where
388		T: BitStore,
389		O: BitOrder,
390		{
391		}