aligned-buffer 0.2.0

A buffer with controllable alignment, that can be sealed and shared by reference count.
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

use std::fmt;

#[repr(transparent)]
#[derive(Clone, Copy)]
pub struct TaggedCap {
	value: usize,
}

impl TaggedCap {
	const TAG: usize = !(usize::MAX >> 1);
	const TAG_MASK: usize = Self::TAG;
	const VALUE_MASK: usize = !Self::TAG_MASK;

	pub const MAX_VALUE: usize = Self::VALUE_MASK;

	pub const fn zero() -> Self {
		Self { value: 0 }
	}

	#[inline]
	pub const fn new(value: usize, tag: bool) -> Self {
		TaggedCap::zero().with_value(value).with_allocated(tag)
	}

	#[inline(always)]
	pub const fn value(self) -> usize {
		self.value & Self::VALUE_MASK
	}

	#[inline(always)]
	pub const fn is_allocated(self) -> bool {
		self.value & Self::TAG_MASK != 0
	}

	#[inline(always)]
	pub const fn with_value(self, value: usize) -> Self {
		debug_assert!(value <= Self::VALUE_MASK, "Value overflow");
		let value = (self.value & Self::TAG_MASK) | (value & Self::VALUE_MASK);
		Self { value }
	}

	#[inline(always)]
	pub const fn with_allocated(self, allocated: bool) -> Self {
		let value_part = self.value & Self::VALUE_MASK;
		let tag_part = ((Self::TAG - 1) + allocated as usize) & Self::TAG_MASK;
		let value = value_part | tag_part;
		Self { value }
	}
}

impl fmt::Debug for TaggedCap {
	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
		f.debug_struct("TaggedCap")
			.field("value", &self.value())
			.field("allocated", &self.is_allocated())
			.finish()
	}
}

static_assertions::const_assert!(TaggedCap::zero().value() == 0);
static_assertions::const_assert!(!TaggedCap::zero().is_allocated());