iceoryx2-bb-elementary 0.8.1

iceoryx2: [internal] elementary constructs that have (almost) no dependencies at all
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

// Copyright (c) 2024 Contributors to the Eclipse Foundation
//
// See the NOTICE file(s) distributed with this work for additional
// information regarding copyright ownership.
//
// This program and the accompanying materials are made available under the
// terms of the Apache Software License 2.0 which is available at
// https://www.apache.org/licenses/LICENSE-2.0, or the MIT license
// which is available at https://opensource.org/licenses/MIT.
//
// SPDX-License-Identifier: Apache-2.0 OR MIT

//! Represents the alignment memory can have. Ensures that the content is always
//! a power of 2 and not zero.

/// Contains the alignment memory can have.
///
/// # Example
///
/// ```
/// use iceoryx2_bb_elementary::alignment::Alignment;
///
/// let my_alignment = Alignment::new(32).unwrap();
///
/// // zero is not a valid alignment
/// let broken_alignment = Alignment::new(0);
/// assert_eq!(broken_alignment, None);
///
/// // alignment must be a power of 2
/// let broken_alignment = Alignment::new(89);
/// assert_eq!(broken_alignment, None);
/// ```
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct Alignment(usize);

impl Alignment {
    pub const ALIGN_1: Alignment = Alignment(1);
    pub const ALIGN_2: Alignment = Alignment(2);
    pub const ALIGN_4: Alignment = Alignment(4);
    pub const ALIGN_8: Alignment = Alignment(8);
    pub const ALIGN_16: Alignment = Alignment(16);
    pub const ALIGN_32: Alignment = Alignment(32);
    pub const ALIGN_64: Alignment = Alignment(64);
    pub const ALIGN_128: Alignment = Alignment(128);
    pub const ALIGN_256: Alignment = Alignment(256);
    pub const ALIGN_512: Alignment = Alignment(512);
    pub const ALIGN_1024: Alignment = Alignment(1024);
    pub const ALIGN_2048: Alignment = Alignment(2048);
    pub const ALIGN_4096: Alignment = Alignment(4096);

    /// Creates a new [`Alignment`]. If the value is zero or not a power of 2
    /// it returns [`None`].
    pub fn new(value: usize) -> Option<Self> {
        (value.is_power_of_two()).then(|| unsafe { Self::new_unchecked(value) })
    }

    /// Creates a new [`Alignment`].
    ///
    /// # Safety
    ///
    ///  * The value must not be zero
    ///  * The value must be a power of 2
    ///
    pub const unsafe fn new_unchecked(value: usize) -> Self {
        Self(value)
    }

    /// Returns the value of the [`Alignment`]
    pub const fn value(&self) -> usize {
        self.0
    }
}