File size: 4,677 Bytes
76f9669 | 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 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 | # SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE
from libc.stdint cimport int32_t, int64_t, intptr_t
from libcpp.vector cimport vector
from libcpp cimport bool as cppbool
from libcpp cimport nullptr_t, nullptr
from libcpp.memory cimport unique_ptr
cdef extern from * nogil:
"""
template<typename T>
class nullable_unique_ptr {
public:
nullable_unique_ptr() noexcept = default;
nullable_unique_ptr(std::nullptr_t) noexcept = delete;
explicit nullable_unique_ptr(T* data, bool own_data):
own_data_(own_data)
{
if (own_data)
manager_.reset(data);
else
raw_data_ = data;
}
nullable_unique_ptr(const nullable_unique_ptr&) = delete;
nullable_unique_ptr& operator=(const nullable_unique_ptr&) = delete;
nullable_unique_ptr(nullable_unique_ptr&& other) noexcept
{
own_data_ = other.own_data_;
other.own_data_ = false; // ownership is transferred
if (own_data_)
{
manager_ = std::move(other.manager_);
raw_data_ = nullptr; // just in case
}
else
{
manager_.reset(nullptr); // just in case
raw_data_ = other.raw_data_;
}
}
nullable_unique_ptr& operator=(nullable_unique_ptr&& other) noexcept
{
own_data_ = other.own_data_;
other.own_data_ = false; // ownership is transferred
if (own_data_)
{
manager_ = std::move(other.manager_);
raw_data_ = nullptr; // just in case
}
else
{
manager_.reset(nullptr); // just in case
raw_data_ = other.raw_data_;
}
return *this;
}
~nullable_unique_ptr() = default;
void reset(T* data, bool own_data)
{
own_data_ = own_data;
if (own_data_)
{
manager_.reset(data);
raw_data_ = nullptr;
}
else
{
manager_.reset(nullptr);
raw_data_ = data;
}
}
void swap(nullable_unique_ptr& other) noexcept
{
std::swap(manager_, other.manager_);
std::swap(raw_data_, other.raw_data_);
std::swap(own_data_, other.own_data_);
}
/*
* Get the pointer to the underlying object (this is different from data()!).
*/
T* get() const noexcept
{
if (own_data_)
return manager_.get();
else
return raw_data_;
}
/*
* Get the pointer to the underlying buffer (this is different from get()!).
*/
void* data() noexcept
{
if (own_data_)
return manager_.get()->data();
else
return raw_data_;
}
T& operator*()
{
if (own_data_)
return *manager_;
else
return *raw_data_;
}
private:
std::unique_ptr<T> manager_{};
T* raw_data_{nullptr};
bool own_data_{false};
};
"""
# xref: cython/Cython/Includes/libcpp/memory.pxd
cdef cppclass nullable_unique_ptr[T]:
nullable_unique_ptr()
nullable_unique_ptr(T*, cppbool)
nullable_unique_ptr(nullable_unique_ptr[T]&)
# Modifiers
void reset(T*, cppbool)
void swap(nullable_unique_ptr&)
# Observers
T* get()
T& operator*()
void* data()
ctypedef fused ResT:
int
int32_t
int64_t
char
float
double
ctypedef fused PtrT:
void
cdef cppclass nested_resource[T]:
nullable_unique_ptr[ vector[intptr_t] ] ptrs
nullable_unique_ptr[ vector[vector[T]] ] nested_resource_ptr
# accepts the output pointer as input to use the return value for exception propagation
cdef int get_resource_ptr(nullable_unique_ptr[vector[ResT]] &in_out_ptr, object obj, ResT* __unused) except 1
cdef int get_resource_ptrs(nullable_unique_ptr[ vector[PtrT*] ] &in_out_ptr, object obj, PtrT* __unused) except 1
cdef int get_nested_resource_ptr(nested_resource[ResT] &in_out_ptr, object obj, ResT* __unused) except 1
cdef bint is_nested_sequence(data)
cdef void* get_buffer_pointer(buf, Py_ssize_t size, readonly=*) except*
|