104 lines
2.9 KiB
Zig
104 lines
2.9 KiB
Zig
const std = @import("std");
|
|
|
|
/// Deinitializes `resource` (allocator owner) only if it is still live.
|
|
///
|
|
/// Pass a pointer to the allocator owner, such as an `ArenaAllocator`.
|
|
///
|
|
/// If `live` is `true`, calls `resource.deinit()` and then sets
|
|
/// `live` to `false`, preventing a later cleanup path from attempting
|
|
/// to deinitialize the same resource again.
|
|
///
|
|
/// The return value of `resource.deinit()` is returned from the function.
|
|
pub fn deinitIfLive(resource: anytype, live: *bool) ?LiveDeinitReturn(@TypeOf(resource))
|
|
{
|
|
if (!live.*) return null;
|
|
|
|
live.* = false;
|
|
return resource.deinit();
|
|
}
|
|
|
|
/// Deinitializes the resources stored in `resource`
|
|
/// (allocator owner) only if still exists.
|
|
///
|
|
/// Pass a pointer to an optional allocator owner, such as
|
|
/// `*?std.heap.ArenaAllocator`.
|
|
///
|
|
/// If `resource.*` is non-null, calls `deinit()` on the payload
|
|
/// and then sets `resource.* = null`, preventing a later cleanup
|
|
/// path from attempting to deinitialize the same resource again.
|
|
///
|
|
/// The return value of `resource.*.?.deinit()` is returned
|
|
/// from the function.
|
|
pub fn deinitIfExists(resource: anytype) ?ExistsDeinitReturn(@TypeOf(resource))
|
|
{
|
|
if (resource.*) |*payload|
|
|
{
|
|
const result = payload.deinit();
|
|
resource.* = null;
|
|
return result;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
//
|
|
|
|
fn Payload(comptime Pointer: type) type
|
|
{
|
|
const Child = ValidatedChild(Pointer);
|
|
|
|
if (@typeInfo(Child) != .optional)
|
|
@compileError("Expected a pointer to an optional resource (*?T)!");
|
|
|
|
return @typeInfo(Child).optional.child;
|
|
}
|
|
|
|
fn ValidatedChild(comptime Pointer: type) type
|
|
{
|
|
if (@typeInfo(Pointer) != .pointer)
|
|
@compileError("Expected a pointer!");
|
|
|
|
if (@typeInfo(Pointer).pointer.size != .one)
|
|
@compileError("Expected a single-item pointer!");
|
|
|
|
return @typeInfo(Pointer).pointer.child;
|
|
}
|
|
|
|
fn LiveDeinitReturn(comptime Pointer: type) type {
|
|
const Child = ValidatedChild(Pointer);
|
|
return @typeInfo(@TypeOf(Child.deinit)).@"fn".return_type.?;
|
|
}
|
|
|
|
fn ExistsDeinitReturn(comptime Pointer: type) type {
|
|
return @typeInfo(@TypeOf(Payload(Pointer).deinit)).@"fn".return_type.?;
|
|
}
|
|
|
|
//
|
|
|
|
test "deinitIfLive deinitializes an ArenaAllocator once" {
|
|
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
|
|
var live = true;
|
|
|
|
const alloc = arena.allocator();
|
|
_ = try alloc.alloc(u8, 1);
|
|
|
|
_ = deinitIfLive(&arena, &live);
|
|
try std.testing.expect(!live);
|
|
|
|
// Must not deinitialize it again.
|
|
try std.testing.expect(deinitIfLive(&arena, &live) == null);
|
|
}
|
|
|
|
test "deinitIfExists deinitializes an optional ArenaAllocator once" {
|
|
var arena: ?std.heap.ArenaAllocator = .init(std.testing.allocator);
|
|
|
|
const alloc = arena.?.allocator();
|
|
_ = try alloc.alloc(u8, 1);
|
|
|
|
_ = deinitIfExists(&arena);
|
|
try std.testing.expect(arena == null);
|
|
|
|
// Must not deinitialize it again.
|
|
try std.testing.expect(deinitIfExists(&arena) == null);
|
|
}
|