wehub-resource-sync
e7738de6d2
CI / Deep Native Runtime Cases (1/6) (push) Has been skipped
CI / Native Preflight (push) Failing after 1s
CI / Native Runtime Cases (1/2) (push) Failing after 0s
CI / Native Runtime Cases (2/2) (push) Failing after 1s
CI / Native Metadata Reports (push) Failing after 0s
CI / Native Direct Backend Artifacts (push) Failing after 0s
CI / Native Sanitizer Smoke (push) Failing after 1s
CI / Command Contract Snapshots (push) Failing after 1s
CI / Deep Conformance Suite (push) Has been skipped
CI / Graph Build Perf (push) Failing after 1s
CI / Deep Native Preflight (push) Has been skipped
CI / Deep Native Runtime Cases (2/6) (push) Has been skipped
CI / Deep Native Runtime Cases (3/6) (push) Has been skipped
CI / Conformance Suite (push) Failing after 1s
CI / Workspace Checks (push) Failing after 0s
CI / Deep Native Runtime Cases (5/6) (push) Has been skipped
CI / Deep Native Runtime Cases (6/6) (push) Has been skipped
CI / Deep Native Runtime Cases (4/6) (push) Has been skipped
CI / Deep Graph Build Perf (push) Has been skipped
526 lines
15 KiB
Plaintext
526 lines
15 KiB
Plaintext
fn __zero_std_search_index_of<T: Type>(items: Span<T>, needle: T) -> usize {
|
|
var index: usize = 0
|
|
while index < std.mem.len(items) {
|
|
if items[index] == needle {
|
|
return index
|
|
}
|
|
index = index + 1
|
|
}
|
|
return std.mem.len(items)
|
|
}
|
|
|
|
fn __zero_std_search_last_index_of<T: Type>(items: Span<T>, needle: T) -> usize {
|
|
var index: usize = std.mem.len(items)
|
|
while index > 0 {
|
|
index = index - 1
|
|
if items[index] == needle {
|
|
return index
|
|
}
|
|
}
|
|
return std.mem.len(items)
|
|
}
|
|
|
|
fn __zero_std_search_lower_bound_i32(items: Span<i32>, needle: i32) -> usize {
|
|
var low: usize = 0
|
|
var high: usize = std.mem.len(items)
|
|
while low < high {
|
|
let mid: usize = low + (high - low) / 2
|
|
if items[mid] < needle {
|
|
low = mid + 1
|
|
} else {
|
|
high = mid
|
|
}
|
|
}
|
|
return low
|
|
}
|
|
|
|
fn __zero_std_search_upper_bound_i32(items: Span<i32>, needle: i32) -> usize {
|
|
var low: usize = 0
|
|
var high: usize = std.mem.len(items)
|
|
while low < high {
|
|
let mid: usize = low + (high - low) / 2
|
|
if items[mid] <= needle {
|
|
low = mid + 1
|
|
} else {
|
|
high = mid
|
|
}
|
|
}
|
|
return low
|
|
}
|
|
|
|
fn __zero_std_search_binary_i32(items: Span<i32>, needle: i32) -> usize {
|
|
let index: usize = __zero_std_search_lower_bound_i32(items, needle)
|
|
if index < std.mem.len(items) && items[index] == needle {
|
|
return index
|
|
}
|
|
return std.mem.len(items)
|
|
}
|
|
|
|
fn __zero_std_search_contains_sorted_i32(items: Span<i32>, needle: i32) -> Bool {
|
|
return __zero_std_search_binary_i32(items, needle) < std.mem.len(items)
|
|
}
|
|
|
|
fn __zero_std_search_count_sorted_i32(items: Span<i32>, needle: i32) -> usize {
|
|
return __zero_std_search_upper_bound_i32(items, needle) - __zero_std_search_lower_bound_i32(items, needle)
|
|
}
|
|
|
|
fn __zero_std_search_equal_range_i32(items: Span<i32>, needle: i32) -> Span<i32> {
|
|
let start: usize = __zero_std_search_lower_bound_i32(items, needle)
|
|
let end: usize = __zero_std_search_upper_bound_i32(items, needle)
|
|
return items[start..end]
|
|
}
|
|
|
|
fn __zero_std_search_partition_point_i32(items: Span<i32>, pivot: i32) -> usize {
|
|
return __zero_std_search_lower_bound_i32(items, pivot)
|
|
}
|
|
|
|
fn __zero_std_search_lower_bound_desc_i32(items: Span<i32>, needle: i32) -> usize {
|
|
var low: usize = 0
|
|
var high: usize = std.mem.len(items)
|
|
while low < high {
|
|
let mid: usize = low + (high - low) / 2
|
|
if items[mid] > needle {
|
|
low = mid + 1
|
|
} else {
|
|
high = mid
|
|
}
|
|
}
|
|
return low
|
|
}
|
|
|
|
fn __zero_std_search_upper_bound_desc_i32(items: Span<i32>, needle: i32) -> usize {
|
|
var low: usize = 0
|
|
var high: usize = std.mem.len(items)
|
|
while low < high {
|
|
let mid: usize = low + (high - low) / 2
|
|
if items[mid] >= needle {
|
|
low = mid + 1
|
|
} else {
|
|
high = mid
|
|
}
|
|
}
|
|
return low
|
|
}
|
|
|
|
fn __zero_std_search_binary_desc_i32(items: Span<i32>, needle: i32) -> usize {
|
|
let index: usize = __zero_std_search_lower_bound_desc_i32(items, needle)
|
|
if index < std.mem.len(items) && items[index] == needle {
|
|
return index
|
|
}
|
|
return std.mem.len(items)
|
|
}
|
|
|
|
fn __zero_std_search_contains_sorted_desc_i32(items: Span<i32>, needle: i32) -> Bool {
|
|
return __zero_std_search_binary_desc_i32(items, needle) < std.mem.len(items)
|
|
}
|
|
|
|
fn __zero_std_search_count_sorted_desc_i32(items: Span<i32>, needle: i32) -> usize {
|
|
return __zero_std_search_upper_bound_desc_i32(items, needle) - __zero_std_search_lower_bound_desc_i32(items, needle)
|
|
}
|
|
|
|
fn __zero_std_search_equal_range_desc_i32(items: Span<i32>, needle: i32) -> Span<i32> {
|
|
let start: usize = __zero_std_search_lower_bound_desc_i32(items, needle)
|
|
let end: usize = __zero_std_search_upper_bound_desc_i32(items, needle)
|
|
return items[start..end]
|
|
}
|
|
|
|
fn __zero_std_search_partition_point_desc_i32(items: Span<i32>, pivot: i32) -> usize {
|
|
return __zero_std_search_lower_bound_desc_i32(items, pivot)
|
|
}
|
|
|
|
fn __zero_std_search_min_i32(items: Span<i32>) -> Maybe<i32> {
|
|
if std.mem.isEmpty(items) {
|
|
return null
|
|
}
|
|
var best: i32 = items[0]
|
|
var index: usize = 1
|
|
while index < std.mem.len(items) {
|
|
if items[index] < best {
|
|
best = items[index]
|
|
}
|
|
index = index + 1
|
|
}
|
|
return best
|
|
}
|
|
|
|
fn __zero_std_search_min_index_i32(items: Span<i32>) -> usize {
|
|
if std.mem.isEmpty(items) {
|
|
return std.mem.len(items)
|
|
}
|
|
var best: usize = 0
|
|
var index: usize = 1
|
|
while index < std.mem.len(items) {
|
|
if items[index] < items[best] {
|
|
best = index
|
|
}
|
|
index = index + 1
|
|
}
|
|
return best
|
|
}
|
|
|
|
fn __zero_std_search_max_i32(items: Span<i32>) -> Maybe<i32> {
|
|
if std.mem.isEmpty(items) {
|
|
return null
|
|
}
|
|
var best: i32 = items[0]
|
|
var index: usize = 1
|
|
while index < std.mem.len(items) {
|
|
if items[index] > best {
|
|
best = items[index]
|
|
}
|
|
index = index + 1
|
|
}
|
|
return best
|
|
}
|
|
|
|
fn __zero_std_search_max_index_i32(items: Span<i32>) -> usize {
|
|
if std.mem.isEmpty(items) {
|
|
return std.mem.len(items)
|
|
}
|
|
var best: usize = 0
|
|
var index: usize = 1
|
|
while index < std.mem.len(items) {
|
|
if items[index] > items[best] {
|
|
best = index
|
|
}
|
|
index = index + 1
|
|
}
|
|
return best
|
|
}
|
|
|
|
fn __zero_std_search_lower_bound_u32(items: Span<u32>, needle: u32) -> usize {
|
|
var low: usize = 0
|
|
var high: usize = std.mem.len(items)
|
|
while low < high {
|
|
let mid: usize = low + (high - low) / 2
|
|
if items[mid] < needle {
|
|
low = mid + 1
|
|
} else {
|
|
high = mid
|
|
}
|
|
}
|
|
return low
|
|
}
|
|
|
|
fn __zero_std_search_upper_bound_u32(items: Span<u32>, needle: u32) -> usize {
|
|
var low: usize = 0
|
|
var high: usize = std.mem.len(items)
|
|
while low < high {
|
|
let mid: usize = low + (high - low) / 2
|
|
if items[mid] <= needle {
|
|
low = mid + 1
|
|
} else {
|
|
high = mid
|
|
}
|
|
}
|
|
return low
|
|
}
|
|
|
|
fn __zero_std_search_binary_u32(items: Span<u32>, needle: u32) -> usize {
|
|
let index: usize = __zero_std_search_lower_bound_u32(items, needle)
|
|
if index < std.mem.len(items) && items[index] == needle {
|
|
return index
|
|
}
|
|
return std.mem.len(items)
|
|
}
|
|
|
|
fn __zero_std_search_contains_sorted_u32(items: Span<u32>, needle: u32) -> Bool {
|
|
return __zero_std_search_binary_u32(items, needle) < std.mem.len(items)
|
|
}
|
|
|
|
fn __zero_std_search_count_sorted_u32(items: Span<u32>, needle: u32) -> usize {
|
|
return __zero_std_search_upper_bound_u32(items, needle) - __zero_std_search_lower_bound_u32(items, needle)
|
|
}
|
|
|
|
fn __zero_std_search_equal_range_u32(items: Span<u32>, needle: u32) -> Span<u32> {
|
|
let start: usize = __zero_std_search_lower_bound_u32(items, needle)
|
|
let end: usize = __zero_std_search_upper_bound_u32(items, needle)
|
|
return items[start..end]
|
|
}
|
|
|
|
fn __zero_std_search_partition_point_u32(items: Span<u32>, pivot: u32) -> usize {
|
|
return __zero_std_search_lower_bound_u32(items, pivot)
|
|
}
|
|
|
|
fn __zero_std_search_lower_bound_desc_u32(items: Span<u32>, needle: u32) -> usize {
|
|
var low: usize = 0
|
|
var high: usize = std.mem.len(items)
|
|
while low < high {
|
|
let mid: usize = low + (high - low) / 2
|
|
if items[mid] > needle {
|
|
low = mid + 1
|
|
} else {
|
|
high = mid
|
|
}
|
|
}
|
|
return low
|
|
}
|
|
|
|
fn __zero_std_search_upper_bound_desc_u32(items: Span<u32>, needle: u32) -> usize {
|
|
var low: usize = 0
|
|
var high: usize = std.mem.len(items)
|
|
while low < high {
|
|
let mid: usize = low + (high - low) / 2
|
|
if items[mid] >= needle {
|
|
low = mid + 1
|
|
} else {
|
|
high = mid
|
|
}
|
|
}
|
|
return low
|
|
}
|
|
|
|
fn __zero_std_search_binary_desc_u32(items: Span<u32>, needle: u32) -> usize {
|
|
let index: usize = __zero_std_search_lower_bound_desc_u32(items, needle)
|
|
if index < std.mem.len(items) && items[index] == needle {
|
|
return index
|
|
}
|
|
return std.mem.len(items)
|
|
}
|
|
|
|
fn __zero_std_search_contains_sorted_desc_u32(items: Span<u32>, needle: u32) -> Bool {
|
|
return __zero_std_search_binary_desc_u32(items, needle) < std.mem.len(items)
|
|
}
|
|
|
|
fn __zero_std_search_count_sorted_desc_u32(items: Span<u32>, needle: u32) -> usize {
|
|
return __zero_std_search_upper_bound_desc_u32(items, needle) - __zero_std_search_lower_bound_desc_u32(items, needle)
|
|
}
|
|
|
|
fn __zero_std_search_equal_range_desc_u32(items: Span<u32>, needle: u32) -> Span<u32> {
|
|
let start: usize = __zero_std_search_lower_bound_desc_u32(items, needle)
|
|
let end: usize = __zero_std_search_upper_bound_desc_u32(items, needle)
|
|
return items[start..end]
|
|
}
|
|
|
|
fn __zero_std_search_partition_point_desc_u32(items: Span<u32>, pivot: u32) -> usize {
|
|
return __zero_std_search_lower_bound_desc_u32(items, pivot)
|
|
}
|
|
|
|
fn __zero_std_search_min_u32(items: Span<u32>) -> Maybe<u32> {
|
|
if std.mem.isEmpty(items) {
|
|
return null
|
|
}
|
|
var best: u32 = items[0]
|
|
var index: usize = 1
|
|
while index < std.mem.len(items) {
|
|
if items[index] < best {
|
|
best = items[index]
|
|
}
|
|
index = index + 1
|
|
}
|
|
return best
|
|
}
|
|
|
|
fn __zero_std_search_min_index_u32(items: Span<u32>) -> usize {
|
|
if std.mem.isEmpty(items) {
|
|
return std.mem.len(items)
|
|
}
|
|
var best: usize = 0
|
|
var index: usize = 1
|
|
while index < std.mem.len(items) {
|
|
if items[index] < items[best] {
|
|
best = index
|
|
}
|
|
index = index + 1
|
|
}
|
|
return best
|
|
}
|
|
|
|
fn __zero_std_search_max_u32(items: Span<u32>) -> Maybe<u32> {
|
|
if std.mem.isEmpty(items) {
|
|
return null
|
|
}
|
|
var best: u32 = items[0]
|
|
var index: usize = 1
|
|
while index < std.mem.len(items) {
|
|
if items[index] > best {
|
|
best = items[index]
|
|
}
|
|
index = index + 1
|
|
}
|
|
return best
|
|
}
|
|
|
|
fn __zero_std_search_max_index_u32(items: Span<u32>) -> usize {
|
|
if std.mem.isEmpty(items) {
|
|
return std.mem.len(items)
|
|
}
|
|
var best: usize = 0
|
|
var index: usize = 1
|
|
while index < std.mem.len(items) {
|
|
if items[index] > items[best] {
|
|
best = index
|
|
}
|
|
index = index + 1
|
|
}
|
|
return best
|
|
}
|
|
|
|
fn __zero_std_search_lower_bound_usize(items: Span<usize>, needle: usize) -> usize {
|
|
var low: usize = 0
|
|
var high: usize = std.mem.len(items)
|
|
while low < high {
|
|
let mid: usize = low + (high - low) / 2
|
|
if items[mid] < needle {
|
|
low = mid + 1
|
|
} else {
|
|
high = mid
|
|
}
|
|
}
|
|
return low
|
|
}
|
|
|
|
fn __zero_std_search_upper_bound_usize(items: Span<usize>, needle: usize) -> usize {
|
|
var low: usize = 0
|
|
var high: usize = std.mem.len(items)
|
|
while low < high {
|
|
let mid: usize = low + (high - low) / 2
|
|
if items[mid] <= needle {
|
|
low = mid + 1
|
|
} else {
|
|
high = mid
|
|
}
|
|
}
|
|
return low
|
|
}
|
|
|
|
fn __zero_std_search_binary_usize(items: Span<usize>, needle: usize) -> usize {
|
|
let index: usize = __zero_std_search_lower_bound_usize(items, needle)
|
|
if index < std.mem.len(items) && items[index] == needle {
|
|
return index
|
|
}
|
|
return std.mem.len(items)
|
|
}
|
|
|
|
fn __zero_std_search_contains_sorted_usize(items: Span<usize>, needle: usize) -> Bool {
|
|
return __zero_std_search_binary_usize(items, needle) < std.mem.len(items)
|
|
}
|
|
|
|
fn __zero_std_search_count_sorted_usize(items: Span<usize>, needle: usize) -> usize {
|
|
return __zero_std_search_upper_bound_usize(items, needle) - __zero_std_search_lower_bound_usize(items, needle)
|
|
}
|
|
|
|
fn __zero_std_search_equal_range_usize(items: Span<usize>, needle: usize) -> Span<usize> {
|
|
let start: usize = __zero_std_search_lower_bound_usize(items, needle)
|
|
let end: usize = __zero_std_search_upper_bound_usize(items, needle)
|
|
return items[start..end]
|
|
}
|
|
|
|
fn __zero_std_search_partition_point_usize(items: Span<usize>, pivot: usize) -> usize {
|
|
return __zero_std_search_lower_bound_usize(items, pivot)
|
|
}
|
|
|
|
fn __zero_std_search_lower_bound_desc_usize(items: Span<usize>, needle: usize) -> usize {
|
|
var low: usize = 0
|
|
var high: usize = std.mem.len(items)
|
|
while low < high {
|
|
let mid: usize = low + (high - low) / 2
|
|
if items[mid] > needle {
|
|
low = mid + 1
|
|
} else {
|
|
high = mid
|
|
}
|
|
}
|
|
return low
|
|
}
|
|
|
|
fn __zero_std_search_upper_bound_desc_usize(items: Span<usize>, needle: usize) -> usize {
|
|
var low: usize = 0
|
|
var high: usize = std.mem.len(items)
|
|
while low < high {
|
|
let mid: usize = low + (high - low) / 2
|
|
if items[mid] >= needle {
|
|
low = mid + 1
|
|
} else {
|
|
high = mid
|
|
}
|
|
}
|
|
return low
|
|
}
|
|
|
|
fn __zero_std_search_binary_desc_usize(items: Span<usize>, needle: usize) -> usize {
|
|
let index: usize = __zero_std_search_lower_bound_desc_usize(items, needle)
|
|
if index < std.mem.len(items) && items[index] == needle {
|
|
return index
|
|
}
|
|
return std.mem.len(items)
|
|
}
|
|
|
|
fn __zero_std_search_contains_sorted_desc_usize(items: Span<usize>, needle: usize) -> Bool {
|
|
return __zero_std_search_binary_desc_usize(items, needle) < std.mem.len(items)
|
|
}
|
|
|
|
fn __zero_std_search_count_sorted_desc_usize(items: Span<usize>, needle: usize) -> usize {
|
|
return __zero_std_search_upper_bound_desc_usize(items, needle) - __zero_std_search_lower_bound_desc_usize(items, needle)
|
|
}
|
|
|
|
fn __zero_std_search_equal_range_desc_usize(items: Span<usize>, needle: usize) -> Span<usize> {
|
|
let start: usize = __zero_std_search_lower_bound_desc_usize(items, needle)
|
|
let end: usize = __zero_std_search_upper_bound_desc_usize(items, needle)
|
|
return items[start..end]
|
|
}
|
|
|
|
fn __zero_std_search_partition_point_desc_usize(items: Span<usize>, pivot: usize) -> usize {
|
|
return __zero_std_search_lower_bound_desc_usize(items, pivot)
|
|
}
|
|
|
|
fn __zero_std_search_min_usize(items: Span<usize>) -> Maybe<usize> {
|
|
if std.mem.isEmpty(items) {
|
|
return null
|
|
}
|
|
var best: usize = items[0]
|
|
var index: usize = 1
|
|
while index < std.mem.len(items) {
|
|
if items[index] < best {
|
|
best = items[index]
|
|
}
|
|
index = index + 1
|
|
}
|
|
return best
|
|
}
|
|
|
|
fn __zero_std_search_min_index_usize(items: Span<usize>) -> usize {
|
|
if std.mem.isEmpty(items) {
|
|
return std.mem.len(items)
|
|
}
|
|
var best: usize = 0
|
|
var index: usize = 1
|
|
while index < std.mem.len(items) {
|
|
if items[index] < items[best] {
|
|
best = index
|
|
}
|
|
index = index + 1
|
|
}
|
|
return best
|
|
}
|
|
|
|
fn __zero_std_search_max_usize(items: Span<usize>) -> Maybe<usize> {
|
|
if std.mem.isEmpty(items) {
|
|
return null
|
|
}
|
|
var best: usize = items[0]
|
|
var index: usize = 1
|
|
while index < std.mem.len(items) {
|
|
if items[index] > best {
|
|
best = items[index]
|
|
}
|
|
index = index + 1
|
|
}
|
|
return best
|
|
}
|
|
|
|
fn __zero_std_search_max_index_usize(items: Span<usize>) -> usize {
|
|
if std.mem.isEmpty(items) {
|
|
return std.mem.len(items)
|
|
}
|
|
var best: usize = 0
|
|
var index: usize = 1
|
|
while index < std.mem.len(items) {
|
|
if items[index] > items[best] {
|
|
best = index
|
|
}
|
|
index = index + 1
|
|
}
|
|
return best
|
|
}
|