peckr 0.6.1

Rust pointer type that allows packing additional data along with the underlying memory offset.
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
89
90
91
92
93
94
95
96
97
98
99
100
101

// inspired by: https://github.com/antirez/rax

#![allow(dead_code)]

use std::mem::ManuallyDrop;
use std::ops::Drop;

use peckr::alloc::boxed::PackedBox;

union EitherUnion<L, R> {
    left: ManuallyDrop<L>,
    right: ManuallyDrop<R>,
}

#[derive(Debug)]
enum Either<L, R> {
    Left(L),
    Right(R),
}

struct EitherBox<L, R> {
    inner: PackedBox<1, EitherUnion<L, R>>,
}

fn main() {
    let mut either: EitherBox<i32, String> =
        EitherBox::right("ganda cena mano de broa velho".into());
    println!("init value: {:#?}", either.get_ref());

    let old_val = either.set(Either::Left(1234));
    println!("old value: {old_val:#?}");
    println!("new value: {:#?}", either.get_ref());

    println!("pointer: {:p}", either.inner.as_ref());
}

impl<L, R> EitherBox<L, R> {
    fn left(value: L) -> Self {
        let inner = PackedBox::new(EitherUnion {
            left: ManuallyDrop::new(value),
        })
        .unwrap();
        Self { inner }
    }

    fn right(value: R) -> Self {
        let mut inner = PackedBox::new(EitherUnion {
            right: ManuallyDrop::new(value),
        })
        .unwrap();
        inner.set_bit_high(0);
        Self { inner }
    }

    fn set(&mut self, value: Either<L, R>) -> Either<L, R> {
        let old_value = match self.inner.get_bit(0) {
            false => Either::Left(unsafe { ManuallyDrop::take(&mut self.inner.as_mut().left) }),
            true => Either::Right(unsafe { ManuallyDrop::take(&mut self.inner.as_mut().right) }),
        };
        match value {
            Either::Left(value) => {
                self.inner.set_bit_low(0);
                unsafe {
                    *self.inner.as_mut().left = value;
                }
            }
            Either::Right(value) => {
                self.inner.set_bit_high(0);
                unsafe {
                    *self.inner.as_mut().right = value;
                }
            }
        }
        old_value
    }

    fn get_ref(&self) -> Either<&L, &R> {
        match self.inner.get_bit(0) {
            false => Either::Left(unsafe { &self.inner.as_ref().left }),
            true => Either::Right(unsafe { &self.inner.as_ref().right }),
        }
    }

    fn get_mut(&mut self) -> Either<&mut L, &mut R> {
        match self.inner.get_bit(0) {
            false => Either::Left(unsafe { &mut self.inner.as_mut().left }),
            true => Either::Right(unsafe { &mut self.inner.as_mut().right }),
        }
    }
}

impl<L, R> Drop for EitherBox<L, R> {
    fn drop(&mut self) {
        match self.inner.get_bit(0) {
            // left
            false => unsafe { ManuallyDrop::drop(&mut self.inner.as_mut().left) },
            // right
            true => unsafe { ManuallyDrop::drop(&mut self.inner.as_mut().right) },
        }
    }
}