srctree

/// This is a wrapper around an array of T values. Initialize with `init`.

///

/// This struct internally stores a `std.mem.Allocator` for memory management.

pub fn ArrayList(comptime T: type) type {

return ArrayListAligned(T, null);

}

/// Initialize with `init`.

///

/// This struct internally stores a `std.mem.Allocator` for memory management.

pub fn ArrayListAligned(comptime T: type, comptime alignment: ?u29) type {

if (alignment) |a| {

if (a == @alignOf(T)) {

}

return struct {

const Self = @This();

///

items: Slice,

/// How many T values this list can hold without allocating

/// additional memory.

 

/// The caller owns the returned memory. Empties this ArrayList.

pub fn toOwnedSliceSentinel(self: *Self, comptime sentinel: T) Allocator.Error!SentinelSlice(sentinel) {

self.appendAssumeCapacity(sentinel);

const result = try self.toOwnedSlice();

return result[0 .. result.len - 1 :sentinel];

return cloned;

}

 

/// This operation is O(N).

dst[0] = item;

}

 

/// This operation is O(N).

/// Asserts that there is enough capacity for the new item.

assert(self.items.len < self.capacity);

self.items.len += 1;

 

}

 

/// Add `count` new elements at position `index`, which have

/// Invalidates pre-existing pointers to elements at and after `index`.

/// Invalidates all pre-existing element pointers if capacity must be

/// increased to accomodate the new elements.

pub fn addManyAt(self: *Self, index: usize, count: usize) Allocator.Error![]T {

 

if (self.capacity >= new_len)

return addManyAtAssumeCapacity(self, index, count);

/// Asserts that there is enough capacity for the new elements.

/// Invalidates pre-existing pointers to elements at and after `index`, but

/// does not invalidate any before that.

pub fn addManyAtAssumeCapacity(self: *Self, index: usize, count: usize) []T {

const new_len = self.items.len + count;

assert(self.capacity >= new_len);

/// Invalidates pre-existing pointers to elements at and after `index`.

/// Invalidates all pre-existing element pointers if capacity must be

/// increased to accomodate the new elements.

pub fn insertSlice(

self: *Self,

index: usize,

/// Replace range of elements `list[start..][0..len]` with `new_items`.

/// Grows list if `len < new_items.len`.

/// Shrinks list if `len > new_items.len`.

pub fn replaceRange(self: *Self, start: usize, len: usize, new_items: []const T) Allocator.Error!void {

const range = self.items[start..after_range];

 

if (range.len == new_items.len)

try self.insertSlice(after_range, rest);

} else {

@memcpy(range[0..new_items.len], new_items);

 

for (self.items[after_range..], 0..) |item, i| {

self.items[after_subrange..][i] = item;

}

}

 

pub fn append(self: *Self, item: T) Allocator.Error!void {

const new_item_ptr = try self.addOne();

new_item_ptr.* = item;

}

 

pub fn appendAssumeCapacity(self: *Self, item: T) void {

const new_item_ptr = self.addOneAssumeCapacity();

new_item_ptr.* = item;

 

/// Remove the element at index `i`, shift elements after index

/// `i` forward, and return the removed element.

/// This operation is O(N).

/// This preserves item order. Use `swapRemove` if order preservation is not important.

pub fn orderedRemove(self: *Self, i: usize) T {

const newlen = self.items.len - 1;

if (newlen == i) return self.pop();

/// The empty slot is filled from the end of the list.

/// This operation is O(1).

/// This may not preserve item order. Use `orderedRemove` if you need to preserve order.

pub fn swapRemove(self: *Self, i: usize) T {

if (self.items.len - 1 == i) return self.pop();

 

 

/// Append the slice of items to the list. Allocates more

/// memory as necessary.

pub fn appendSlice(self: *Self, items: []const T) Allocator.Error!void {

try self.ensureUnusedCapacity(items.len);

self.appendSliceAssumeCapacity(items);

}

 

pub fn appendSliceAssumeCapacity(self: *Self, items: []const T) void {

const old_len = self.items.len;

const new_len = old_len + items.len;

/// Append an unaligned slice of items to the list. Allocates more

/// memory as necessary. Only call this function if calling

/// `appendSlice` instead would be a compile error.

pub fn appendUnalignedSlice(self: *Self, items: []align(1) const T) Allocator.Error!void {

try self.ensureUnusedCapacity(items.len);

self.appendUnalignedSliceAssumeCapacity(items);

}

 

pub fn appendUnalignedSliceAssumeCapacity(self: *Self, items: []align(1) const T) void {

const old_len = self.items.len;

const new_len = old_len + items.len;

@compileError("The Writer interface is only defined for ArrayList(u8) " ++

"but the given type is ArrayList(" ++ @typeName(T) ++ ")")

else

 

/// Initializes a Writer which will append to the list.

pub fn writer(self: *Self) Writer {

 

/// Same as `append` except it returns the number of bytes written, which is always the same

/// as `m.len`. The purpose of this function existing is to match `std.io.Writer` API.

fn appendWrite(self: *Self, m: []const u8) Allocator.Error!usize {

try self.appendSlice(m);

return m.len;

 

/// Append a value to the list `n` times.

/// Allocates more memory as necessary.

/// The function is inline so that a comptime-known `value` parameter will

/// have a more optimal memset codegen in case it has a repeated byte pattern.

pub inline fn appendNTimes(self: *Self, value: T, n: usize) Allocator.Error!void {

const old_len = self.items.len;

@memset(self.items[old_len..self.items.len], value);

}

 

/// Append a value to the list `n` times.

/// The function is inline so that a comptime-known `value` parameter will

/// have a more optimal memset codegen in case it has a repeated byte pattern.

pub inline fn appendNTimesAssumeCapacity(self: *Self, value: T, n: usize) void {

const new_len = self.items.len + n;

assert(new_len <= self.capacity);

self.items.len = new_len;

}

 

pub fn resize(self: *Self, new_len: usize) Allocator.Error!void {

try self.ensureTotalCapacity(new_len);

self.items.len = new_len;

 

/// Reduce allocated capacity to `new_len`.

/// May invalidate element pointers.

pub fn shrinkAndFree(self: *Self, new_len: usize) void {

var unmanaged = self.moveToUnmanaged();

unmanaged.shrinkAndFree(self.allocator, new_len);

}

 

/// Reduce length to `new_len`.

pub fn shrinkRetainingCapacity(self: *Self, new_len: usize) void {

assert(new_len <= self.items.len);

self.items.len = new_len;

 

/// If the current capacity is less than `new_capacity`, this function will

/// modify the array so that it can hold at least `new_capacity` items.

pub fn ensureTotalCapacity(self: *Self, new_capacity: usize) Allocator.Error!void {

if (@sizeOf(T) == 0) {

self.capacity = math.maxInt(usize);

 

/// If the current capacity is less than `new_capacity`, this function will

/// modify the array so that it can hold exactly `new_capacity` items.

pub fn ensureTotalCapacityPrecise(self: *Self, new_capacity: usize) Allocator.Error!void {

if (@sizeOf(T) == 0) {

self.capacity = math.maxInt(usize);

}

 

/// Modify the array so that it can hold at least `additional_count` **more** items.

pub fn ensureUnusedCapacity(self: *Self, additional_count: usize) Allocator.Error!void {

}

 

/// Increases the array's length to match the full capacity that is already allocated.

pub fn expandToCapacity(self: *Self) void {

self.items.len = self.capacity;

}

/// Increase length by 1, returning pointer to the new item.

/// The returned pointer becomes invalid when the list resized.

pub fn addOne(self: *Self) Allocator.Error!*T {

return self.addOneAssumeCapacity();

}

 

/// Increase length by 1, returning pointer to the new item.

/// The returned pointer becomes invalid when the list is resized.

pub fn addOneAssumeCapacity(self: *Self) *T {

assert(self.items.len < self.capacity);

self.items.len += 1;

/// Resizes list if `self.capacity` is not large enough.

pub fn addManyAsArray(self: *Self, comptime n: usize) Allocator.Error!*[n]T {

const prev_len = self.items.len;

return self.items[prev_len..][0..n];

}

 

/// Resize the array, adding `n` new elements, which have `undefined` values.

/// The return value is an array pointing to the newly allocated elements.

/// The returned pointer becomes invalid when the list is resized.

pub fn addManyAsArrayAssumeCapacity(self: *Self, comptime n: usize) *[n]T {

assert(self.items.len + n <= self.capacity);

const prev_len = self.items.len;

/// Resizes list if `self.capacity` is not large enough.

pub fn addManyAsSlice(self: *Self, n: usize) Allocator.Error![]T {

const prev_len = self.items.len;

return self.items[prev_len..][0..n];

}

 

/// Resize the array, adding `n` new elements, which have `undefined` values.

/// The return value is a slice pointing to the newly allocated elements.

/// The returned pointer becomes invalid when the list is resized.

pub fn addManyAsSliceAssumeCapacity(self: *Self, n: usize) []T {

assert(self.items.len + n <= self.capacity);

const prev_len = self.items.len;

}

 

/// Remove and return the last element from the list.

pub fn pop(self: *Self) T {

const val = self.items[self.items.len - 1];

self.items.len -= 1;

 

/// Remove and return the last element from the list, or

/// return `null` if list is empty.

pub fn popOrNull(self: *Self) ?T {

if (self.items.len == 0) return null;

return self.pop();

return self.allocatedSlice()[self.items.len..];

}

 

pub fn getLast(self: Self) T {

const val = self.items[self.items.len - 1];

return val;

}

 

pub fn getLastOrNull(self: Self) ?T {

if (self.items.len == 0) return null;

return self.getLast();

}

 

/// An ArrayList, but the allocator is passed as a parameter to the relevant functions

/// the entire lifetime of an ArrayListUnmanaged. Initialize directly or with

/// `initCapacity`, and deinitialize with `deinit` or use `toOwnedSlice`.

pub fn ArrayListUnmanaged(comptime T: type) type {

return ArrayListAlignedUnmanaged(T, null);

}

 

pub fn ArrayListAlignedUnmanaged(comptime T: type, comptime alignment: ?u29) type {

if (alignment) |a| {

if (a == @alignOf(T)) {

}

return struct {

const Self = @This();

///

items: Slice = &[_]T{},

/// How many T values this list can hold without allocating

/// additional memory.

 

/// Initialize with externally-managed memory. The buffer determines the

/// capacity, and the length is set to zero.

pub fn initBuffer(buffer: Slice) Self {

return .{

.items = buffer[0..0],

 

/// The caller owns the returned memory. ArrayList becomes empty.

pub fn toOwnedSliceSentinel(self: *Self, allocator: Allocator, comptime sentinel: T) Allocator.Error!SentinelSlice(sentinel) {

self.appendAssumeCapacity(sentinel);

const result = try self.toOwnedSlice(allocator);

return result[0 .. result.len - 1 :sentinel];

return cloned;

}

 

/// This operation is O(N).

dst[0] = item;

}

 

/// This operation is O(N).

assert(self.items.len < self.capacity);

self.items.len += 1;

 

}

 

/// Add `count` new elements at position `index`, which have

/// Invalidates pre-existing pointers to elements at and after `index`.

/// Invalidates all pre-existing element pointers if capacity must be

/// increased to accomodate the new elements.

pub fn addManyAt(

self: *Self,

allocator: Allocator,

/// `undefined` values. Returns a slice pointing to the newly allocated

/// elements, which becomes invalid after various `ArrayList`

/// operations.

/// Invalidates pre-existing pointers to elements at and after `index`, but

/// does not invalidate any before that.

pub fn addManyAtAssumeCapacity(self: *Self, index: usize, count: usize) []T {

const new_len = self.items.len + count;

assert(self.capacity >= new_len);

/// Invalidates pre-existing pointers to elements at and after `index`.

/// Invalidates all pre-existing element pointers if capacity must be

/// increased to accomodate the new elements.

pub fn insertSlice(

self: *Self,

allocator: Allocator,

/// Replace range of elements `list[start..][0..len]` with `new_items`

/// Grows list if `len < new_items.len`.

/// Shrinks list if `len > new_items.len`

pub fn replaceRange(

self: *Self,

allocator: Allocator,

}

 

/// Extend the list by 1 element. Allocates more memory as necessary.

pub fn append(self: *Self, allocator: Allocator, item: T) Allocator.Error!void {

const new_item_ptr = try self.addOne(allocator);

new_item_ptr.* = item;

}

 

pub fn appendAssumeCapacity(self: *Self, item: T) void {

const new_item_ptr = self.addOneAssumeCapacity();

new_item_ptr.* = item;

}

 

/// Remove the element at index `i` from the list and return its value.

/// This operation is O(N).

pub fn orderedRemove(self: *Self, i: usize) T {

const newlen = self.items.len - 1;

if (newlen == i) return self.pop();

/// The empty slot is filled from the end of the list.

/// Invalidates pointers to last element.

/// This operation is O(1).

pub fn swapRemove(self: *Self, i: usize) T {

if (self.items.len - 1 == i) return self.pop();

 

 

/// Append the slice of items to the list. Allocates more

/// memory as necessary.

pub fn appendSlice(self: *Self, allocator: Allocator, items: []const T) Allocator.Error!void {

try self.ensureUnusedCapacity(allocator, items.len);

self.appendSliceAssumeCapacity(items);

}

 

pub fn appendSliceAssumeCapacity(self: *Self, items: []const T) void {

const old_len = self.items.len;

const new_len = old_len + items.len;

/// Append the slice of items to the list. Allocates more

/// memory as necessary. Only call this function if a call to `appendSlice` instead would

/// be a compile error.

pub fn appendUnalignedSlice(self: *Self, allocator: Allocator, items: []align(1) const T) Allocator.Error!void {

try self.ensureUnusedCapacity(allocator, items.len);

self.appendUnalignedSliceAssumeCapacity(items);

}

 

/// instead would be a compile error.

pub fn appendUnalignedSliceAssumeCapacity(self: *Self, items: []align(1) const T) void {

const old_len = self.items.len;

const new_len = old_len + items.len;

@compileError("The Writer interface is only defined for ArrayList(u8) " ++

"but the given type is ArrayList(" ++ @typeName(T) ++ ")")

else

 

/// Initializes a Writer which will append to the list.

pub fn writer(self: *Self, allocator: Allocator) Writer {

 

/// Same as `append` except it returns the number of bytes written, which is always the same

/// as `m.len`. The purpose of this function existing is to match `std.io.Writer` API.

fn appendWrite(context: WriterContext, m: []const u8) Allocator.Error!usize {

try context.self.appendSlice(context.allocator, m);

return m.len;

 

/// Append a value to the list `n` times.

/// Allocates more memory as necessary.

/// The function is inline so that a comptime-known `value` parameter will

/// have a more optimal memset codegen in case it has a repeated byte pattern.

pub inline fn appendNTimes(self: *Self, allocator: Allocator, value: T, n: usize) Allocator.Error!void {

const old_len = self.items.len;

@memset(self.items[old_len..self.items.len], value);

}

 

/// Append a value to the list `n` times.

/// The function is inline so that a comptime-known `value` parameter will

pub inline fn appendNTimesAssumeCapacity(self: *Self, value: T, n: usize) void {

const new_len = self.items.len + n;

assert(new_len <= self.capacity);

self.items.len = new_len;

}

 

pub fn resize(self: *Self, allocator: Allocator, new_len: usize) Allocator.Error!void {

try self.ensureTotalCapacity(allocator, new_len);

self.items.len = new_len;

 

/// Reduce allocated capacity to `new_len`.

/// May invalidate element pointers.

pub fn shrinkAndFree(self: *Self, allocator: Allocator, new_len: usize) void {

assert(new_len <= self.items.len);

 

/// Reduce length to `new_len`.

/// Invalidates pointers to elements `items[new_len..]`.

/// Keeps capacity the same.

pub fn shrinkRetainingCapacity(self: *Self, new_len: usize) void {

assert(new_len <= self.items.len);

self.items.len = new_len;

 

/// If the current capacity is less than `new_capacity`, this function will

/// modify the array so that it can hold at least `new_capacity` items.

pub fn ensureTotalCapacity(self: *Self, allocator: Allocator, new_capacity: usize) Allocator.Error!void {

if (self.capacity >= new_capacity) return;

 

 

/// If the current capacity is less than `new_capacity`, this function will

/// modify the array so that it can hold exactly `new_capacity` items.

pub fn ensureTotalCapacityPrecise(self: *Self, allocator: Allocator, new_capacity: usize) Allocator.Error!void {

if (@sizeOf(T) == 0) {

self.capacity = math.maxInt(usize);

}

 

/// Modify the array so that it can hold at least `additional_count` **more** items.

pub fn ensureUnusedCapacity(

self: *Self,

allocator: Allocator,

additional_count: usize,

) Allocator.Error!void {

}

 

/// Increases the array's length to match the full capacity that is already allocated.

/// The new elements have `undefined` values.

pub fn expandToCapacity(self: *Self) void {

self.items.len = self.capacity;

}

 

/// Increase length by 1, returning pointer to the new item.

pub fn addOne(self: *Self, allocator: Allocator) Allocator.Error!*T {

try self.ensureTotalCapacity(allocator, newlen);

return self.addOneAssumeCapacity();

}

 

/// Increase length by 1, returning pointer to the new item.

pub fn addOneAssumeCapacity(self: *Self) *T {

assert(self.items.len < self.capacity);

 

/// The returned pointer becomes invalid when the list is resized.

pub fn addManyAsArray(self: *Self, allocator: Allocator, comptime n: usize) Allocator.Error!*[n]T {

const prev_len = self.items.len;

return self.items[prev_len..][0..n];

}

 

/// Resize the array, adding `n` new elements, which have `undefined` values.

/// The return value is an array pointing to the newly allocated elements.

/// The returned pointer becomes invalid when the list is resized.

pub fn addManyAsArrayAssumeCapacity(self: *Self, comptime n: usize) *[n]T {

assert(self.items.len + n <= self.capacity);

const prev_len = self.items.len;

/// Resizes list if `self.capacity` is not large enough.

pub fn addManyAsSlice(self: *Self, allocator: Allocator, n: usize) Allocator.Error![]T {

const prev_len = self.items.len;

return self.items[prev_len..][0..n];

}

 

/// Resize the array, adding `n` new elements, which have `undefined` values.

/// The return value is a slice pointing to the newly allocated elements.

/// The returned pointer becomes invalid when the list is resized.

pub fn addManyAsSliceAssumeCapacity(self: *Self, n: usize) []T {

assert(self.items.len + n <= self.capacity);

const prev_len = self.items.len;

}

 

/// Remove and return the last element from the list.

/// Invalidates pointers to last element.

pub fn pop(self: *Self) T {

const val = self.items[self.items.len - 1];

self.items.len -= 1;

}

 

/// Return the last element from the list.

pub fn getLast(self: Self) T {

const val = self.items[self.items.len - 1];

return val;

}

}

 

test "std.ArrayList/ArrayListUnmanaged.init" {

{

var list = ArrayList(i32).init(testing.allocator);

const const_list = list;

try testing.expectEqual(const_list.getLastOrNull().?, 2);

}