//! Typed vector backed by caller-owned static storage.

/// Typed vector metadata backed by caller-owned storage.

export record Vec⟨T⟩ {

    /// Typed slice containing the vector's storage.

    data: *mut [T],

    /// Number of initialized elements.

    len: u32,

}

/// Initialize a vector over caller-owned storage.

export fn init⟨T⟩(vec: *mut Vec⟨T⟩, arena: *mut [T]) {

    set vec.data = arena;

    set vec.len = 0;

}

/// Return the number of initialized elements.

export fn len⟨T⟩(vec: *Vec⟨T⟩) -> u32 {

    return vec.len;

}

/// Return the storage capacity in elements.

export fn capacity⟨T⟩(vec: *Vec⟨T⟩) -> u32 {

    return vec.data.len;

}

/// Reset a vector without clearing its storage.

export fn reset⟨T⟩(vec: *mut Vec⟨T⟩) {

    set vec.len = 0;

}

/// Return a typed pointer to an element, or `nil` when out of bounds.

export fn get⟨T⟩(vec: *Vec⟨T⟩, index: u32) -> ?*T {

    if index >= vec.len {

        return nil;

    }

    return &vec.data[index];

}

/// Append an element, returning `false` when the vector is full.

export fn push⟨T⟩(vec: *mut Vec⟨T⟩, value: T) -> bool {

    if vec.len >= vec.data.len {

        return false;

    }

    set vec.data[vec.len] = value;

    set vec.len += 1;

    return true;

}

/// Replace an initialized element, returning `false` when out of bounds.

export fn put⟨T⟩(vec: *mut Vec⟨T⟩, index: u32, value: T) -> bool {

    if index >= vec.len {

        return false;

    }

    set vec.data[index] = value;

    return true;

}

/// Remove and return the last element, or `nil` when empty.

export fn pop⟨T⟩(vec: *mut Vec⟨T⟩) -> ?T {

    if vec.len == 0 {

        return nil;

    }

    set vec.len -= 1;

    return vec.data[vec.len];

}