phper 0.17.2

The framework that allows us to write PHP extensions using pure and safe Rust whenever possible.
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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

// Copyright (c) 2025 PHPER Framework Team
// PHPER is licensed under Mulan PSL v2.
// You can use this software according to the terms and conditions of the Mulan
// PSL v2. You may obtain a copy of Mulan PSL v2 at:
//          http://license.coscl.org.cn/MulanPSL2
// THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY
// KIND, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
// NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
// See the Mulan PSL v2 for more details.

//! Memory allocation utilities and boxed types for PHP values.

pub use phper_alloc::{RefClone, ToRefOwned};
use std::{
    borrow::{Borrow, BorrowMut},
    fmt::{self},
    mem::ManuallyDrop,
    ops::{Deref, DerefMut},
};

/// A smart pointer for PHP values allocated in the Zend Engine memory.
///
/// `EBox<T>` provides owned access to values allocated in PHP's memory
/// management system. It automatically handles deallocation when dropped,
/// ensuring proper cleanup of PHP resources.
pub struct EBox<T> {
    ptr: *mut T,
}

impl<T> EBox<T> {
    /// Constructs from a raw pointer.
    ///
    /// # Safety
    ///
    /// Make sure the pointer is from `into_raw`, or created from `emalloc`.
    pub unsafe fn from_raw(raw: *mut T) -> Self {
        Self { ptr: raw }
    }

    /// Constructs from a raw pointer with cast.
    ///
    /// # Safety
    ///
    /// Make sure the pointer is from `into_raw`, or created from `emalloc`.
    pub(crate) unsafe fn from_raw_cast<U>(raw: *mut U) -> Self {
        const {
            assert!(size_of::<U>() == size_of::<T>());
        }
        Self { ptr: raw.cast() }
    }

    /// Consumes and returning a wrapped raw pointer.
    ///
    /// Will leak memory.
    pub fn into_raw(b: EBox<T>) -> *mut T {
        ManuallyDrop::new(b).ptr
    }

    /// Consumes and returning a wrapped raw pointer with cast.
    ///
    /// Will leak memory.
    pub(crate) fn into_raw_cast<U>(b: EBox<T>) -> *mut U {
        const {
            assert!(size_of::<U>() == size_of::<T>());
        }
        ManuallyDrop::new(b).ptr.cast()
    }
}

impl<T: fmt::Debug> fmt::Debug for EBox<T> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt::Debug::fmt(&**self, f)
    }
}

impl<T> Deref for EBox<T> {
    type Target = T;

    fn deref(&self) -> &Self::Target {
        unsafe { self.ptr.as_ref().unwrap() }
    }
}

impl<T> DerefMut for EBox<T> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        unsafe { self.ptr.as_mut().unwrap() }
    }
}

impl<T> Drop for EBox<T> {
    fn drop(&mut self) {
        unsafe {
            self.ptr.drop_in_place();
        }
    }
}

impl<T> Borrow<T> for EBox<T> {
    fn borrow(&self) -> &T {
        unsafe { self.ptr.as_ref().unwrap() }
    }
}

impl<T> BorrowMut<T> for EBox<T> {
    fn borrow_mut(&mut self) -> &mut T {
        unsafe { self.ptr.as_mut().unwrap() }
    }
}

impl<T> AsRef<T> for EBox<T> {
    fn as_ref(&self) -> &T {
        unsafe { self.ptr.as_ref().unwrap() }
    }
}

impl<T> AsMut<T> for EBox<T> {
    fn as_mut(&mut self) -> &mut T {
        unsafe { self.ptr.as_mut().unwrap() }
    }
}