//! Raw vector backed by caller-managed storage.

//!

//! Users provide their own storage and the vector manages

//! element count within that arena. The arena should be aligned according

//! to the element type's requirements.

/// Raw vector metadata structure.

///

/// Does not own storage, points to user-provided arena.

export record RawVec: Copy {

    /// Pointer to user-provided byte arena.

    data: *unsafe mut [u8],

    /// Current number of elements stored.

    len: u32,

    /// Size of each element in bytes (stride between elements).

    stride: u32,

    /// Alignment in bytes required by element type (>= 1).

    alignment: u32,

}

/// Create a new raw vector with external arena.

///

/// * `arena` must outlive the vector and all returned element pointers.

/// * `stride` is the size of each element.

/// * `alignment` is the required alignment for elements.

export unsafe fn new(arena: &mut [u8], stride: u32, alignment: u32) -> RawVec {

    assert stride > 0;

    assert alignment > 0;

    assert (arena.ptr as u32) % alignment == 0;

    assert (arena.len % stride) == 0;

    return RawVec { data: arena as *unsafe mut [u8], len: 0, stride, alignment };

}

/// Get the current number of elements in the vector.

export fn len(vec: &RawVec) -> u32 {

    return vec.len;

}

/// Get the maximum capacity of the vector.

export unsafe fn capacity(vec: &RawVec) -> u32 {

    return vec.data.len / vec.stride;

}

/// Reset the vector to empty (does not clear memory).

export fn reset(vec: &mut RawVec) {

    set vec.len = 0;

}

/// Get a pointer to the element at the given index.

///

/// Returns nil if index is out of bounds.

export unsafe fn get(vec: &RawVec, index: u32) -> ?*unsafe opaque {

    if index >= vec.len {

        return nil;

    }

    let offset: u32 = index * vec.stride;

    let ptr: *unsafe u8 = &vec.data[offset];

    return ptr as *unsafe opaque;

}

/// Push an element onto the end of the vector.

///

/// Returns false if the vector is at capacity.

export unsafe fn push(vec: &mut RawVec, elem: &opaque) -> bool {

    if vec.len >= capacity(vec) {

        return false;

    }

    let stride = vec.stride;

    let off: u32 = vec.len * stride;

    copyBytes(&mut vec.data[off..off + stride], @sliceOf(elem as &u8, stride));

    set vec.len += 1;

    return true;

}

/// Pop an element from the end of the vector.

///

/// Copies the element into the provided output pointer.

/// Returns false if the vector is empty.

export unsafe fn pop(vec: &mut RawVec, out: &mut opaque) -> bool {

    if vec.len == 0 {

        return false;

    }

    set vec.len -= 1;

    let off: u32 = vec.len * vec.stride;

    copyBytes(@sliceOf(out as &mut u8, vec.stride), &vec.data[off..off + vec.stride]);

    return true;

}

/// Set the element at the given index.

///

/// Returns false if index is out of bounds.

export unsafe fn put(vec: &mut RawVec, index: u32, elem: &opaque) -> bool {

    if index >= vec.len {

        return false;

    }

    let stride = vec.stride;

    let off: u32 = index * stride;

    copyBytes(&mut vec.data[off..off + stride], @sliceOf(elem as &u8, stride));

    return true;

}

/// Copy bytes from source to destination.

fn copyBytes(dst: &mut [u8], src: &[u8]) {

    assert dst.len == src.len;

    for i in 0..src.len {

        set dst[i] = src[i];

    }

}