alloc_observe.debug

1const std = @import("std");2const adapter = @import("allocator.zig");3const protocol = @import("protocol.zig");45/// A generic debugging allocator type that forwards configured options to6/// `std.heap.DebugAllocator`, providing common `init`, `allocator`, and7/// `deinit` methods in both enabled and disabled builds. Only `deinit` returns8/// `std.heap.Check`. In enabled builds, virtual table operations forward9/// through an embedded adapter tagged with the `debug` producer kind.10/// Observation captures raw allocator virtual table calls only and adds no11/// lifecycle records.12pub fn Allocator(comptime options: std.heap.DebugAllocatorConfig) type {13    return if (protocol.enabled) Observed(options) else Unobserved(options);14}1516fn Unobserved(comptime options: std.heap.DebugAllocatorConfig) type {17    return struct {18        inner: std.heap.DebugAllocator(options),1920        const Self = @This();2122        /// Initializes the underlying debug allocator with the supplied backing23        /// allocator, assigning a producer identifier when observation is24        /// enabled. The constructor forwards configuration options directly to25        /// the underlying implementation without introducing new tracking26        /// policies or altering memory validation behavior.27        pub fn init(backing: std.mem.Allocator) Self {28            return .{ .inner = .{ .backing_allocator = backing } };29        }3031        /// Returns an allocator handle borrowing the instance, routing through32        /// an embedded adapter tagged with the debug producer kind when33        /// observation is enabled. The owning instance and its backing34        /// allocator must remain stable and valid throughout use. The method35        /// provides no thread-safety guarantee for concurrent invocations on36        /// the same instance.37        pub fn allocator(self: *Self) std.mem.Allocator {38            return self.inner.allocator();39        }4041        /// Deinitializes the underlying debug allocator and returns its42        /// underlying `std.heap.Check` status. Teardown emits no observation43        /// lifecycle events. All standard ownership and lifetime prerequisites44        /// of the underlying debug allocator apply to this call.45        pub fn deinit(self: *Self) std.heap.Check {46            return self.inner.deinit();47        }48    };49}5051fn Observed(comptime options: std.heap.DebugAllocatorConfig) type {52    return struct {53        inner: std.heap.DebugAllocator(options),54        observed: adapter.ObservedAllocator = undefined,55        producer_id: u64,5657        const Self = @This();5859        /// Initializes the underlying debug allocator with the supplied backing60        /// allocator, assigning a producer identifier when observation is61        /// enabled. The constructor forwards configuration options directly to62        /// the underlying implementation without introducing new tracking63        /// policies or altering memory validation behavior.64        pub fn init(backing: std.mem.Allocator) Self {65            return .{66                .inner = .{ .backing_allocator = backing },67                .producer_id = protocol.producerId(),68            };69        }7071        /// Returns an allocator handle borrowing the instance, routing through72        /// an embedded adapter tagged with the debug producer kind when73        /// observation is enabled. The owning instance and its backing74        /// allocator must remain stable and valid throughout use. The method75        /// provides no thread-safety guarantee for concurrent invocations on76        /// the same instance.77        pub fn allocator(self: *Self) std.mem.Allocator {78            self.observed = adapter.ObservedAllocator.init(79                self.inner.allocator(),80                self.producer_id,81                .debug,82            );83            return self.observed.allocator();84        }8586        /// Deinitializes the underlying debug allocator and returns its87        /// underlying `std.heap.Check` status. Teardown emits no observation88        /// lifecycle events. All standard ownership and lifetime prerequisites89        /// of the underlying debug allocator apply to this call.90        pub fn deinit(self: *Self) std.heap.Check {91            return self.inner.deinit();92        }93    };94}

1pub const debug = @import("debug.zig");