linearity 1.2.0

Library providing various operations commonly found in branchless programming
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

/*
    linearity: A library for branchless programming
    Copyright (C) 2024  advantageous-overtake

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU Affero General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Affero General Public License for more details.

    You should have received a copy of the GNU Affero General Public License
    along with this program.  If not, see <https://www.gnu.org/licenses/>.
*/

//! Module for blanket implementations and miscenalleous traits.

use crate::Linearity;

/// Extension trait for pointers.
pub trait PointerExt<T> {
    /// Selects between two pointers based on a predicate.
    ///
    /// # Safety
    ///
    /// Safety constrains are as per [`core::ptr::read`] for both inputs.
    unsafe fn select(self, target_other: Self, target_predicate: bool) -> Self;

    /// Selects between two pointers and dereferences the selected pointer.
    ///
    /// # Safety
    ///
    /// Safety constrains are as per [`core::ptr::read`] for both inputs.
    unsafe fn select_deref(self, target_other: Self, target_predicate: bool) -> T;
}

/// Extension trait for mutable pointers.
pub trait PointerMutExt<T>: PointerExt<T> {
    
}

impl<T> PointerExt<T> for *const T
where
    T: Copy,
    usize: Linearity,
{
    #[inline]
    unsafe fn select_deref(self, target_other: Self, target_predicate: bool) -> T {
        core::ptr::read(self.select(target_other, target_predicate))
    }

    #[inline]
    unsafe fn select(self, target_other: Self, target_dependence: bool) -> Self {
        let target_left = self as usize;
        let target_right = target_other as usize;

        let target_outcome = usize::select(target_left, target_right, target_dependence);

        target_outcome as Self
    }
}

impl<T> PointerExt<T> for *mut T {
    #[inline]
    unsafe fn select_deref(self, target_other: Self, target_predicate: bool) -> T {
        core::ptr::read(self.select(target_other, target_predicate))
    }

    #[inline]
    unsafe fn select(self, target_other: Self, target_dependence: bool) -> Self {
        let target_left = self as usize;
        let target_right = target_other as usize;

        let target_outcome =
            <usize as Linearity>::select(target_left, target_right, target_dependence);

        target_outcome as Self
    }
}

impl<T> PointerMutExt<T> for *mut T where *mut T: PointerExt<T> {}