structstd.debug.SafetyLock[src]

Types

TypeState[src]

Source Code

Source code
pub const State = if (runtime_safety) enum { unlocked, locked } else enum { unknown }

Fields

state: State = if (runtime_safety) .unlocked else .unknown

Functions

Functionlock[src]

pub fn lock(l: *SafetyLock) void

Parameters

Source Code

Source code
pub fn lock(l: *SafetyLock) void {
    if (!runtime_safety) return;
    assert(l.state == .unlocked);
    l.state = .locked;
}

Functionunlock[src]

pub fn unlock(l: *SafetyLock) void

Parameters

Source Code

Source code
pub fn unlock(l: *SafetyLock) void {
    if (!runtime_safety) return;
    assert(l.state == .locked);
    l.state = .unlocked;
}

FunctionassertUnlocked[src]

pub fn assertUnlocked(l: SafetyLock) void

Parameters

Source Code

Source code
pub fn assertUnlocked(l: SafetyLock) void {
    if (!runtime_safety) return;
    assert(l.state == .unlocked);
}

FunctionassertLocked[src]

pub fn assertLocked(l: SafetyLock) void

Parameters

Source Code

Source code
pub fn assertLocked(l: SafetyLock) void {
    if (!runtime_safety) return;
    assert(l.state == .locked);
}

Source Code

Source code
pub const SafetyLock = struct {
    state: State = if (runtime_safety) .unlocked else .unknown,

    pub const State = if (runtime_safety) enum { unlocked, locked } else enum { unknown };

    pub fn lock(l: *SafetyLock) void {
        if (!runtime_safety) return;
        assert(l.state == .unlocked);
        l.state = .locked;
    }

    pub fn unlock(l: *SafetyLock) void {
        if (!runtime_safety) return;
        assert(l.state == .locked);
        l.state = .unlocked;
    }

    pub fn assertUnlocked(l: SafetyLock) void {
        if (!runtime_safety) return;
        assert(l.state == .unlocked);
    }

    pub fn assertLocked(l: SafetyLock) void {
        if (!runtime_safety) return;
        assert(l.state == .locked);
    }
}