tiny.preserves.CowSignedInteger

1/// An integer with a tag that says whether its holder owns the integer's heap digits. Code that2/// keeps an integer apart from its value holds it in this type, so the ownership of its digits3/// travels with it. A new one borrows unless its builder says otherwise.4pub const CowSignedInteger = struct {5    /// The integer.6    value: SignedInteger,7    /// Whether the holder owns the digits of `value`. It defaults to borrowed, so a struct written8    /// by hand never frees digits it did not allocate.9    ownership: Ownership = .borrowed,1011    /// Wraps `value` as borrowed. Code that wraps an integer whose digits live elsewhere calls it.12    /// `deinit` leaves its digits alone.13    pub fn borrow(value: SignedInteger) CowSignedInteger {14        return .{ .value = value, .ownership = .borrowed };15    }1617    /// Wraps `value` as owned. Code that wraps an integer it built calls it. `deinit` frees its18    /// digits with the allocator it is given, so they have to come from that allocator.19    pub fn own(value: SignedInteger) CowSignedInteger {20        return .{ .value = value, .ownership = .owned };21    }2223    /// Frees the integer's heap digits with `allocator` when they are owned, and leaves them when24    /// they are borrowed. Code that holds the integer calls it when it is done with it. Only an25    /// integer too large for 128 bits has heap digits. The struct is undefined afterward.26    pub fn deinit(self: *CowSignedInteger, allocator: Allocator) void {27        if (self.ownership == .owned) self.value.deinit(allocator);28        self.* = undefined;29    }3031    /// Returns a copy that owns its digits. Code that must keep the integer after its owner goes32    /// calls it. A borrowed integer is copied into storage from `allocator`. An owned integer comes33    /// back as the same struct with no copy, so the result and the original share its digits and34    /// only one of the two may be freed.35    pub fn intoOwned(self: CowSignedInteger, allocator: Allocator) !CowSignedInteger {36        return switch (self.ownership) {37            .owned => self,38            .borrowed => CowSignedInteger.own(try self.value.clone(allocator)),39        };40    }41};

1pub const CowSignedInteger = atom.CowSignedInteger;