uord 0.1.0

An implementation of unordered pairs (or more generally, unordered sets)
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

use core::mem::ManuallyDrop;

macro_rules! assert_size_eq {
  ($Left:ty, $Right:ty) => (const {
    assert!(size_of::<$Left>() == size_of::<$Right>());
  });
}

macro_rules! assert_align_eq {
  ($Left:ty, $Right:ty) => (const {
    assert!(align_of::<$Left>() == align_of::<$Right>());
  });
}



pub(crate) const unsafe fn transmute_ref<T: ?Sized, U: ?Sized>(ptr: &T) -> &U {
  assert_size_eq!(*const T, *const U);

  unsafe { &*transmute::<*const T, *const U>(ptr as *const T) }
}

pub(crate) const unsafe fn transmute_ref_mut<T: ?Sized, U: ?Sized>(ptr: &mut T) -> &mut U {
  assert_size_eq!(*mut T, *mut U);

  unsafe { &mut *transmute::<*mut T, *mut U>(ptr as *mut T) }
}

pub(crate) const unsafe fn transmute_slice<T, U>(slice: &[T]) -> &[U] {
  assert_size_eq!(T, U);
  assert_align_eq!(T, U);

  unsafe { core::slice::from_raw_parts(slice.as_ptr() as *const U, slice.len()) }
}

pub(crate) const unsafe fn transmute_slice_mut<T, U>(slice: &mut [T]) -> &mut [U] {
  assert_size_eq!(T, U);
  assert_align_eq!(T, U);

  unsafe { core::slice::from_raw_parts_mut(slice.as_mut_ptr() as *mut U, slice.len()) }
}

pub(crate) const unsafe fn transmute<T, U>(value: T) -> U {
  assert_size_eq!(T, U);
  assert_align_eq!(T, U);

  #[repr(C)]
  union TransmuteCast<T, U> {
    t: ManuallyDrop<T>,
    u: ManuallyDrop<U>
  }

  let value = ManuallyDrop::new(value);
  ManuallyDrop::into_inner(unsafe {
    TransmuteCast { t: value }.u
  })
}