span

Takes a sentinel-terminated pointer and returns a slice, iterating over the memory to find the sentinel and determine the length. Pointer attributes such as const are preserved. [*c] pointers are assumed to be non-null and 0-terminated.

Function parameters

Parameters

ptr:anytype

Type definitions in this namespace

Types

Allocator
Alignment: Stored as a power-of-two.
DelimiterType

Detects and asserts if the std.mem.Allocator interface is violated by the caller

Functions

ValidationAllocator: Detects and asserts if the std.mem.Allocator interface is violated by the caller
validationWrap
copyForwards: Copy all of source into dest at position 0.
copyBackwards: Copy all of source into dest at position 0.
zeroes: Generally, Zig users are encouraged to explicitly initialize all fields of a struct explicitly rather than using this function.
zeroInit: Initializes all fields of the struct with their default value, or zero values if no default value is present.
sort
sortUnstable
sortContext: TODO: currently this just calls `insertionSortContext`.
sortUnstableContext
order: Compares two slices of numbers lexicographically.
orderZ: Compares two many-item pointers with NUL-termination lexicographically.
lessThan: Returns true if lhs < rhs, false otherwise
eql: Returns true if and only if the slices have the same length and all elements
indexOfDiff: Compares two slices and returns the index of the first inequality.
span: Takes a sentinel-terminated pointer and returns a slice, iterating over the
sliceTo: Takes a pointer to an array, a sentinel-terminated pointer, or a slice and iterates searching for
len: Takes a sentinel-terminated pointer and iterates over the memory to find the
indexOfSentinel
allEqual: Returns true if all elements in a slice are equal to the scalar value provided
trimStart: Remove a set of values from the beginning of a slice.
trimLeft: Deprecated: use `trimStart` instead.
trimEnd: Remove a set of values from the end of a slice.
trimRight: Deprecated: use `trimEnd` instead.
trim: Remove a set of values from the beginning and end of a slice.
indexOfScalar: Linear search for the index of a scalar value inside a slice.
lastIndexOfScalar: Linear search for the last index of a scalar value inside a slice.
indexOfScalarPos
indexOfAny
lastIndexOfAny
indexOfAnyPos
indexOfNone: Find the first item in `slice` which is not contained in `values`.
lastIndexOfNone: Find the last item in `slice` which is not contained in `values`.
indexOfNonePos: Find the first item in `slice[start_index..]` which is not contained in `values`.
indexOf
lastIndexOfLinear: Find the index in a slice of a sub-slice, searching from the end backwards.
indexOfPosLinear: Consider using `indexOfPos` instead of this, which will automatically use a
lastIndexOf: Find the index in a slice of a sub-slice, searching from the end backwards.
indexOfPos: Uses Boyer-Moore-Horspool algorithm on large inputs; `indexOfPosLinear` on small inputs.
count: Returns the number of needles inside the haystack
containsAtLeast: Returns true if the haystack contains expected_count or more needles
containsAtLeastScalar: Returns true if the haystack contains expected_count or more needles
readVarInt: Reads an integer from memory with size equal to bytes.len.
readVarPackedInt: Loads an integer from packed memory with provided bit_count, bit_offset, and signedness.
readInt: Reads an integer from memory with bit count specified by T.
readPackedInt: Loads an integer from packed memory.
writeInt: Writes an integer to memory, storing it in twos-complement.
writePackedInt: Stores an integer to packed memory.
writeVarPackedInt: Stores an integer to packed memory with provided bit_offset, bit_count, and signedness.
byteSwapAllFields: Swap the byte order of all the members of the fields of a struct
byteSwapAllElements
tokenizeAny: Returns an iterator that iterates over the slices of `buffer` that are not
tokenizeSequence: Returns an iterator that iterates over the slices of `buffer` that are not
tokenizeScalar: Returns an iterator that iterates over the slices of `buffer` that are not
splitSequence: Returns an iterator that iterates over the slices of `buffer` that
splitAny: Returns an iterator that iterates over the slices of `buffer` that
splitScalar: Returns an iterator that iterates over the slices of `buffer` that
splitBackwardsSequence: Returns an iterator that iterates backwards over the slices of `buffer` that
splitBackwardsAny: Returns an iterator that iterates backwards over the slices of `buffer` that
splitBackwardsScalar: Returns an iterator that iterates backwards over the slices of `buffer` that
window: Returns an iterator with a sliding window of slices for `buffer`.
WindowIterator
startsWith
endsWith
TokenIterator
SplitIterator
SplitBackwardsIterator
join: Naively combines a series of slices with a separator.
joinZ: Naively combines a series of slices with a separator and null terminator.
concat: Copies each T from slices into a new slice that exactly holds all the elements.
concatWithSentinel: Copies each T from slices into a new slice that exactly holds all the elements.
concatMaybeSentinel: Copies each T from slices into a new slice that exactly holds all the elements as well as the sentinel.
min: Returns the smallest number in a slice.
max: Returns the largest number in a slice.
minMax: Finds the smallest and largest number in a slice.
indexOfMin: Returns the index of the smallest number in a slice.
indexOfMax: Returns the index of the largest number in a slice.
indexOfMinMax: Finds the indices of the smallest and largest number in a slice.
swap
reverse: In-place order reversal of a slice
reverseIterator: Iterates over a slice in reverse.
rotate: In-place rotation of the values in an array ([0 1 2 3] becomes [1 2 3 0] if we rotate by 1)
replace: Replace needle with replacement as many times as possible, writing to an output buffer which is assumed to be of
replaceScalar: Replace all occurrences of `match` with `replacement`.
collapseRepeatsLen: Collapse consecutive duplicate elements into one entry.
collapseRepeats: Collapse consecutive duplicate elements into one entry.
replacementSize: Calculate the size needed in an output buffer to perform a replacement.
replaceOwned: Perform a replacement on an allocated buffer of pre-determined size.
littleToNative: Converts a little-endian integer to host endianness.
bigToNative: Converts a big-endian integer to host endianness.
toNative: Converts an integer from specified endianness to host endianness.
nativeTo: Converts an integer which has host endianness to the desired endianness.
nativeToLittle: Converts an integer which has host endianness to little endian.
nativeToBig: Converts an integer which has host endianness to big endian.
alignPointerOffset: Returns the number of elements that, if added to the given pointer, align it
alignPointer: Aligns a given pointer value to a specified alignment factor.
asBytes: Given a pointer to a single item, returns a slice of the underlying bytes, preserving pointer attributes.
toBytes: Given any value, returns a copy of its bytes in an array.
bytesAsValue: Given a pointer to an array of bytes, returns a pointer to a value of the specified type
bytesToValue: Given a pointer to an array of bytes, returns a value of the specified type backed by a
bytesAsSlice: Given a slice of bytes, returns a slice of the specified type
sliceAsBytes: Given a slice, returns a slice of the underlying bytes, preserving pointer attributes.
alignForwardAnyAlign: Round an address down to the next (or current) aligned address.
alignForward: Round an address up to the next (or current) aligned address.
alignForwardLog2
doNotOptimizeAway: Force an evaluation of the expression; this tries to prevent
alignBackwardAnyAlign: Round an address down to the previous (or current) aligned address.
alignBackward: Round an address down to the previous (or current) aligned address.
isValidAlign: Returns whether `alignment` is a valid alignment, meaning it is
isValidAlignGeneric: Returns whether `alignment` is a valid alignment, meaning it is
isAlignedAnyAlign
isAlignedLog2
isAligned: Given an address and an alignment, return true if the address is a multiple of the alignment
isAlignedGeneric
alignInBytes: Returns the largest slice in the given bytes that conforms to the new alignment,
alignInSlice: Returns the largest sub-slice within the given slice that conforms to the new alignment,

The standard library currently thoroughly depends on byte size

Values

byte_size_in_bits: The standard library currently thoroughly depends on byte size
readPackedIntNative: = switch (native_endian) { .little => readPackedIntLittle, .big => readPackedIntBig, }
readPackedIntForeign: = switch (native_endian) { .little => readPackedIntBig, .big => readPackedIntLittle, }
writePackedIntNative: = switch (native_endian) { .little => writePackedIntLittle, .big => writePackedIntBig, }
writePackedIntForeign: = switch (native_endian) { .little => writePackedIntBig, .big => writePackedIntLittle, }

Source

Implementation

pub fn span(ptr: anytype) Span(@TypeOf(ptr)) {
    if (@typeInfo(@TypeOf(ptr)) == .optional) {
        if (ptr) |non_null| {
            return span(non_null);
        } else {
            return null;
        }
    }
    const Result = Span(@TypeOf(ptr));
    const l = len(ptr);
    const ptr_info = @typeInfo(Result).pointer;
    if (ptr_info.sentinel()) |s| {
        return ptr[0..l :s];
    } else {
        return ptr[0..l];
    }
}