srctree

 

/// 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).

/// Invalidates pointers if additional memory is needed.

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, index: usize, count: usize) Allocator.Error![]T {

 

if (self.capacity >= new_len)

return addManyAtAssumeCapacity(self, index, count);

/// `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,

index: usize,

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

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

/// Invalidates pointers if this ArrayList is resized.

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;

}

}

 

/// Invalidates pointers if additional memory is needed.

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

const new_item_ptr = try self.addOne();

new_item_ptr.* = item;

}

 

/// invalidate pointers.

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.

/// Invalidates pointers to end of list.

/// 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();

 

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;

self.appendUnalignedSliceAssumeCapacity(items);

}

 

/// Only call this function if calling `appendSliceAssumeCapacity` 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) Writer {

/// 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);

 

/// 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`.

/// Invalidates pointers for the elements `items[new_len..]`.

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

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

self.items.len = new_len;

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

/// Invalidates pointers if additional memory is needed.

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.

/// 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.

/// Invalidates pointers to the removed element.

pub fn pop(self: *Self) T {

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

self.items.len -= 1;

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();

 

/// 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).

/// Invalidates pointers if additional memory is needed.

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,

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

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

/// Invalidates pointers if this ArrayList is resized.

pub fn replaceRange(

self: *Self,

allocator: 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();

 

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;

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 {

/// 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.

/// **Does not** invalidate pointers.

/// 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);

 

/// 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;

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.

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

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.

/// **Does not** invalidate pointers.

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

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.

/// **Does not** invalidate pointers.

/// 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);

}