VecAt

Macro
August 22, 2025

Table of Contents

`VecAt`

Description

Value at given index in a vector. It’s strongly recommended to always use this instead of directly accessing the data.

Parameters

Name	Direction	Description
`v`	in	Vector to get data from
`idx`	in	Index to get data at

Usage example (Cross-references)

In Access.h:39:

    /// Access character at given index
    ///
    #define StrCharAt(str, idx) VecAt(str, idx)
    
    ///

In Foreach.h:34:

    if ((v)->length > 0) {                                                                                         \
    for ((idx) = 0; (idx) < (v)->length; ++(idx)) {                                                            \
    var = VecAt(v, idx);                                                                                   \
    { body }                                                                                               \
    if ((idx) >= (v)->length) {                                                                            \

In Foreach.h:61:

    if ((v)->length > 0) {                                                                                         \
    for ((idx) = (v)->length - 1; (idx) < (v)->length; --(idx)) {                                              \
    var = VecAt(v, idx);                                                                                   \
    { body }                                                                                               \
    if ((idx) >= (v)->length) {                                                                            \

In Foreach.h:260:

    );                                                                                                 \
    }                                                                                                      \
    var = VecAt(v, idx);                                                                                   \
    { body }                                                                                               \
    }                                                                                                          \

In Access.h:46:

    /// v[in] : Vector to get first element of.
    ///
    #define VecFirst(v) VecAt(v, 0)
    
    ///

In Access.h:53:

    /// v[in] : Vector to get last element of.
    ///
    #define VecLast(v) VecAt(v, (v)->length - 1)
    
    ///

In Sys.c:417:

    size total_len = 0;
    for (size i = 0; i < argv->length; i++) {
    Str* arg   = &VecAt(argv, i);
    total_len += arg->length;
    if (i > 0)

In Sys.c:439:

    
    for (size i = 0; i < argv->length; i++) {
    Str* arg = &VecAt(argv, i);
    
    if (i > 0) {

In Sys.c:475:

    size total_len = 0;
    for (size i = 0; i < env->length; i++) {
    Str* env_var  = &VecAt(env, i);
    total_len    += env_var->length + 1; // +1 for null terminator
    }

In Sys.c:486:

    char* ptr = env_block;
    for (size i = 0; i < env->length; i++) {
    Str* env_var = &VecAt(env, i);
    memcpy(ptr, env_var->data, env_var->length);
    ptr    += env_var->length;

In Sys.c:509:

    
    for (size i = 0; i < argv->length; i++) {
    Str* arg     = &VecAt(argv, i);
    arg_array[i] = (char*)malloc(arg->length + 1);
    if (!arg_array[i]) {

In Sys.c:538:

    
    for (size i = 0; i < env->length; i++) {
    Str* env_var = &VecAt(env, i);
    env_array[i] = (char*)malloc(env_var->length + 1);
    if (!env_array[i]) {

In Read.Simple.c:283:

    
    if (languages.length >= 3) {
    Str* lang1 = &VecAt(&languages, 0);
    Str* lang2 = &VecAt(&languages, 1);
    Str* lang3 = &VecAt(&languages, 2);

In Read.Simple.c:284:

    if (languages.length >= 3) {
    Str* lang1 = &VecAt(&languages, 0);
    Str* lang2 = &VecAt(&languages, 1);
    Str* lang3 = &VecAt(&languages, 2);

In Read.Simple.c:285:

    Str* lang1 = &VecAt(&languages, 0);
    Str* lang2 = &VecAt(&languages, 1);
    Str* lang3 = &VecAt(&languages, 2);
    
    if (StrCmpCstr(lang1, "C", 1) != 0) {

In Read.Simple.c:428:

    
    if (product.tags.length >= 3) {
    Str* tag1 = &VecAt(&product.tags, 0);
    Str* tag2 = &VecAt(&product.tags, 1);
    Str* tag3 = &VecAt(&product.tags, 2);

In Read.Simple.c:429:

    if (product.tags.length >= 3) {
    Str* tag1 = &VecAt(&product.tags, 0);
    Str* tag2 = &VecAt(&product.tags, 1);
    Str* tag3 = &VecAt(&product.tags, 2);

In Read.Simple.c:430:

    Str* tag1 = &VecAt(&product.tags, 0);
    Str* tag2 = &VecAt(&product.tags, 1);
    Str* tag3 = &VecAt(&product.tags, 2);
    
    if (StrCmpCstr(tag1, "electronics", 11) != 0) {

In Read.EdgeCases.c:526:

    });
    
    if (obj.x_value == 1 && VecLen(&obj.filled_items) == 2 && VecAt(&obj.filled_items, 0) == 1 &&
    VecAt(&obj.filled_items, 1) == 2) {
    printf(

In Read.EdgeCases.c:527:

    
    if (obj.x_value == 1 && VecLen(&obj.filled_items) == 2 && VecAt(&obj.filled_items, 0) == 1 &&
    VecAt(&obj.filled_items, 1) == 2) {
    printf(
    "[DEBUG] Mixed empty and filled test passed - x: %d, items: %zu\n",

In Read.EdgeCases.c:540:

    );
    if (VecLen(&obj.filled_items) > 0) {
    printf("[DEBUG] First item: %d\n", VecAt(&obj.filled_items, 0));
    }
    success = false;

In Write.Nested.c:246:

    // Write dynamic key for source function ID
    Str source_key = StrInit();
    u64 source_id  = response.data.length > 0 ? VecAt(&response.data, 0).source_function_id : 0;
    StrWriteFmt(&source_key, "{}", source_id);

In Write.Nested.c:251:

    JW_OBJ_KV(json, source_key.data, {
    if (response.data.length > 0) {
    AnnSymbol* s          = &VecAt(&response.data, 0);
    Str        target_key = StrInit();
    StrWriteFmt(&target_key, "{}", s->target_function_id);

In RoundTrip.c:77:

    
    for (size i = 0; i < VecLen(&a->features); i++) {
    if (StrCmp(&VecAt(&a->features, i), &VecAt(&b->features, i)) != 0) {
    return false;
    }

In RoundTrip.c:401:

    if (numbers_match) {
    for (size i = 0; i < VecLen(&original_numbers); i++) {
    if (VecAt(&original_numbers, i) != VecAt(&parsed_numbers, i)) {
    numbers_match = false;
    break;

In RoundTrip.c:411:

    if (strings_match) {
    for (size i = 0; i < VecLen(&original_strings); i++) {
    if (VecAt(&original_strings, i).length != VecAt(&parsed_strings, i).length ||
    (VecAt(&original_strings, i).length &&
    StrCmp(&VecAt(&original_strings, i), &VecAt(&parsed_strings, i)) != 0)) {

In RoundTrip.c:412:

    for (size i = 0; i < VecLen(&original_strings); i++) {
    if (VecAt(&original_strings, i).length != VecAt(&parsed_strings, i).length ||
    (VecAt(&original_strings, i).length &&
    StrCmp(&VecAt(&original_strings, i), &VecAt(&parsed_strings, i)) != 0)) {
    strings_match = false;

In RoundTrip.c:413:

    if (VecAt(&original_strings, i).length != VecAt(&parsed_strings, i).length ||
    (VecAt(&original_strings, i).length &&
    StrCmp(&VecAt(&original_strings, i), &VecAt(&parsed_strings, i)) != 0)) {
    strings_match = false;
    break;

In RoundTrip.c:606:

    if (numbers_match) {
    for (size i = 0; i < VecLen(&original.numbers); i++) {
    if (VecAt(&original.numbers, i) != VecAt(&parsed.numbers, i)) {
    numbers_match = false;
    break;

In RoundTrip.c:616:

    if (flags_match) {
    for (size i = 0; i < VecLen(&original.flags); i++) {
    if (VecAt(&original.flags, i) != VecAt(&parsed.flags, i)) {
    flags_match = false;
    break;

In Read.Nested.c:371:

    
    if (symbols.length >= 2) {
    AnnSymbol* sym1 = &VecAt(&symbols, 0);
    AnnSymbol* sym2 = &VecAt(&symbols, 1);

In Read.Nested.c:372:

    if (symbols.length >= 2) {
    AnnSymbol* sym1 = &VecAt(&symbols, 0);
    AnnSymbol* sym2 = &VecAt(&symbols, 1);
    
    if (!(sym1->source_function_id == 12345 || sym1->source_function_id == 54321)) {

In Read.Nested.c:495:

    
    if (response.data.length > 0) {
    AnnSymbol* sym = &VecAt(&response.data, 0);
    
    // Debug individual symbol checks

In Read.Nested.c:833:

    
    if (response.data.length > 0) {
    AnnSymbol* sym = &VecAt(&response.data, 0);
    
    if (sym->source_function_id != 12345) {

In Read.Nested.c:1002:

    
    if (response.data.length > 0) {
    AnnSymbol* sym = &VecAt(&response.data, 0);
    
    if (sym->source_function_id != 12345) {

In Str.Type.c:59:

    // Check the content of the strings
    if (result) {
    Str* str1 = &VecAt(&sv, 0);
    Str* str2 = &VecAt(&sv, 1);

In Str.Type.c:60:

    if (result) {
    Str* str1 = &VecAt(&sv, 0);
    Str* str2 = &VecAt(&sv, 1);
    
    result = result && (ZstrCompare(str1->data, "Hello") == 0);

In Vec.Foreach.Simple.c:46:

    // Check that the values in the vector are unchanged (foreach uses value, not reference)
    for (size i = 0; i < vec.length; i++) {
    result = result && (VecAt(&vec, i) == values[i]);
    }

In Vec.Foreach.Simple.c:107:

    bool result = true;
    for (size i = 0; i < vec.length; i++) {
    result = result && (VecAt(&vec, i) == values[i] * 2);
    }

In Vec.Foreach.Simple.c:144:

    bool result = true;
    for (size i = 0; i < vec.length; i++) {
    result = result && (VecAt(&vec, i) == i);
    }

In Vec.Foreach.Simple.c:202:

    VecForeachReverseIdx(&vec, item, idx, {
    result = result && (item == values[idx]);
    result = result && (VecAt(&vec, idx) == item);
    });

In Vec.Foreach.Simple.c:234:

    bool result     = true;
    for (size i = 0; i < vec.length; i++) {
    result = result && (VecAt(&vec, i) == expected[i]);
    }

In Vec.Foreach.Simple.c:267:

    bool result     = true;
    for (size i = 0; i < vec.length; i++) {
    result = result && (VecAt(&vec, i) == expected[i]);
    }

In Vec.Access.c:19:

    // Test VecAt function
    bool test_vec_at(void) {
    printf("Testing VecAt\n");
    
    // Create a vector of integers

In Vec.Access.c:33:

    
    // Check values using VecAt
    bool result = (VecAt(&vec, 0) == 10);
    result      = result && (VecAt(&vec, 1) == 20);
    result      = result && (VecAt(&vec, 2) == 30);

In Vec.Access.c:34:

    // Check values using VecAt
    bool result = (VecAt(&vec, 0) == 10);
    result      = result && (VecAt(&vec, 1) == 20);
    result      = result && (VecAt(&vec, 2) == 30);
    result      = result && (VecAt(&vec, 3) == 40);

In Vec.Access.c:35:

    bool result = (VecAt(&vec, 0) == 10);
    result      = result && (VecAt(&vec, 1) == 20);
    result      = result && (VecAt(&vec, 2) == 30);
    result      = result && (VecAt(&vec, 3) == 40);
    result      = result && (VecAt(&vec, 4) == 50);

In Vec.Access.c:36:

    result      = result && (VecAt(&vec, 1) == 20);
    result      = result && (VecAt(&vec, 2) == 30);
    result      = result && (VecAt(&vec, 3) == 40);
    result      = result && (VecAt(&vec, 4) == 50);

In Vec.Access.c:37:

    result      = result && (VecAt(&vec, 2) == 30);
    result      = result && (VecAt(&vec, 3) == 40);
    result      = result && (VecAt(&vec, 4) == 50);
    
    // Modify a value using VecAt

In Vec.Access.c:40:

    
    // Modify a value using VecAt
    VecAt(&vec, 2) = 35;
    result         = result && (VecAt(&vec, 2) == 35);

In Vec.Access.c:41:

    // Modify a value using VecAt
    VecAt(&vec, 2) = 35;
    result         = result && (VecAt(&vec, 2) == 35);
    
    // Clean up

In Vec.Access.c:77:

    
    // Verify changes
    result = result && (VecAt(&vec, 0) == 15);
    result = result && (VecAt(&vec, 2) == 35);

In Vec.Access.c:78:

    // Verify changes
    result = result && (VecAt(&vec, 0) == 15);
    result = result && (VecAt(&vec, 2) == 35);
    
    // Clean up

In Vec.Access.c:108:

    
    // Verify changes
    result = result && (VecAt(&vec, 0) == 15);
    result = result && (VecAt(&vec, 2) == 35);

In Vec.Access.c:109:

    // Verify changes
    result = result && (VecAt(&vec, 0) == 15);
    result = result && (VecAt(&vec, 2) == 35);
    
    // Clean up

In Vec.Insert.c:41:

    // Check elements in order
    for (size i = 0; i < vec.length; i++) {
    result = result && (VecAt(&vec, i) == values[i]);
    }

In Vec.Insert.c:69:

    // Check elements in reverse order (since we pushed to front)
    for (size i = 0; i < vec.length; i++) {
    result = result && (VecAt(&vec, i) == values[4 - i]);
    }

In Vec.Insert.c:90:

    
    // Check first element
    bool result = (vec.length == 1 && VecAt(&vec, 0) == 10);
    
    // Insert at the end

In Vec.Insert.c:96:

    
    // Check elements
    result = result && (vec.length == 2 && VecAt(&vec, 0) == 10 && VecAt(&vec, 1) == 30);
    
    // Insert in the middle

In Vec.Insert.c:103:

    // Check all elements
    result = result && (vec.length == 3);
    result = result && (VecAt(&vec, 0) == 10);
    result = result && (VecAt(&vec, 1) == 20);
    result = result && (VecAt(&vec, 2) == 30);

In Vec.Insert.c:104:

    result = result && (vec.length == 3);
    result = result && (VecAt(&vec, 0) == 10);
    result = result && (VecAt(&vec, 1) == 20);
    result = result && (VecAt(&vec, 2) == 30);

In Vec.Insert.c:105:

    result = result && (VecAt(&vec, 0) == 10);
    result = result && (VecAt(&vec, 1) == 20);
    result = result && (VecAt(&vec, 2) == 30);
    
    // Clean up

In Vec.Insert.c:130:

    // Check elements in order
    for (size i = 0; i < vec.length; i++) {
    result = result && (VecAt(&vec, i) == values[i]);
    }

In Vec.Insert.c:142:

    // Check all elements
    for (size i = 0; i < 5; i++) {
    result = result && (VecAt(&vec, i) == values[i]);
    }
    for (size i = 0; i < 3; i++) {

In Vec.Insert.c:145:

    }
    for (size i = 0; i < 3; i++) {
    result = result && (VecAt(&vec, i + 5) == more_values[i]);
    }

In Vec.Insert.c:171:

    // Check elements in order
    for (size i = 0; i < vec.length; i++) {
    result = result && (VecAt(&vec, i) == values[i]);
    }

In Vec.Insert.c:183:

    // Check all elements
    for (size i = 0; i < 3; i++) {
    result = result && (VecAt(&vec, i) == more_values[i]);
    }
    for (size i = 0; i < 5; i++) {

In Vec.Insert.c:186:

    }
    for (size i = 0; i < 5; i++) {
    result = result && (VecAt(&vec, i + 3) == values[i]);
    }

In Vec.Insert.c:219:

    // Check all elements
    for (size i = 0; i < vec.length; i++) {
    result = result && (VecAt(&vec, i) == expected[i]);
    }

In Vec.Insert.c:256:

    // Check all elements
    for (size i = 0; i < vec.length; i++) {
    result = result && (VecAt(&vec, i) == expected[i]);
    }

In Vec.Insert.c:297:

    // Check all elements in vec1
    for (size i = 0; i < vec1.length; i++) {
    result = result && (VecAt(&vec1, i) == expected[i]);
    }

In Vec.Insert.c:319:

    
    // Check that the element was added
    bool result = (vec.length == 1 && VecAt(&vec, 0) == 42);
    
    // Test L-value insert operations

In Vec.Insert.c:326:

    
    // Check that the element was added
    result = result && (vec.length == 2 && VecAt(&vec, 1) == 100);
    
    // Test R-value insert at index

In Vec.Insert.c:333:

    // Check that the element was inserted
    result = result && (vec.length == 3);
    result = result && (VecAt(&vec, 0) == 42);
    result = result && (VecAt(&vec, 1) == 50);
    result = result && (VecAt(&vec, 2) == 100);

In Vec.Insert.c:334:

    result = result && (vec.length == 3);
    result = result && (VecAt(&vec, 0) == 42);
    result = result && (VecAt(&vec, 1) == 50);
    result = result && (VecAt(&vec, 2) == 100);

In Vec.Insert.c:335:

    result = result && (VecAt(&vec, 0) == 42);
    result = result && (VecAt(&vec, 1) == 50);
    result = result && (VecAt(&vec, 2) == 100);
    
    // Test L-value insert at index

In Vec.Insert.c:343:

    // Check that the element was inserted
    result = result && (vec.length == 4);
    result = result && (VecAt(&vec, 0) == 42);
    result = result && (VecAt(&vec, 1) == 50);
    result = result && (VecAt(&vec, 2) == 75);

In Vec.Insert.c:344:

    result = result && (vec.length == 4);
    result = result && (VecAt(&vec, 0) == 42);
    result = result && (VecAt(&vec, 1) == 50);
    result = result && (VecAt(&vec, 2) == 75);
    result = result && (VecAt(&vec, 3) == 100);

In Vec.Insert.c:345:

    result = result && (VecAt(&vec, 0) == 42);
    result = result && (VecAt(&vec, 1) == 50);
    result = result && (VecAt(&vec, 2) == 75);
    result = result && (VecAt(&vec, 3) == 100);

In Vec.Insert.c:346:

    result = result && (VecAt(&vec, 1) == 50);
    result = result && (VecAt(&vec, 2) == 75);
    result = result && (VecAt(&vec, 3) == 100);
    
    // Test R-value fast insert

In Vec.Insert.c:353:

    // Check that the element was inserted
    result = result && (vec.length == 5);
    result = result && (VecAt(&vec, 1) == 60);
    
    // Test L-value fast insert

In Vec.Insert.c:361:

    // Check that the element was inserted
    result = result && (vec.length == 6);
    result = result && (VecAt(&vec, 3) == 80);
    
    // Test array operations with L-values and R-values

In Vec.Insert.c:371:

    // Check that the elements were added
    result = result && (vec.length == 9);
    result = result && (VecAt(&vec, 6) == 200);
    result = result && (VecAt(&vec, 7) == 300);
    result = result && (VecAt(&vec, 8) == 400);

In Vec.Insert.c:372:

    result = result && (vec.length == 9);
    result = result && (VecAt(&vec, 6) == 200);
    result = result && (VecAt(&vec, 7) == 300);
    result = result && (VecAt(&vec, 8) == 400);

In Vec.Insert.c:373:

    result = result && (VecAt(&vec, 6) == 200);
    result = result && (VecAt(&vec, 7) == 300);
    result = result && (VecAt(&vec, 8) == 400);
    
    // L-value array operations

In Vec.Insert.c:380:

    // Check that the elements were added
    result = result && (vec.length == 12);
    result = result && (VecAt(&vec, 0) == 200);
    result = result && (VecAt(&vec, 1) == 300);
    result = result && (VecAt(&vec, 2) == 400);

In Vec.Insert.c:381:

    result = result && (vec.length == 12);
    result = result && (VecAt(&vec, 0) == 200);
    result = result && (VecAt(&vec, 1) == 300);
    result = result && (VecAt(&vec, 2) == 400);

In Vec.Insert.c:382:

    result = result && (VecAt(&vec, 0) == 200);
    result = result && (VecAt(&vec, 1) == 300);
    result = result && (VecAt(&vec, 2) == 400);
    
    // Clean up

In Vec.Memory.c:43:

    // Check that the data is still intact
    for (size i = 0; i < vec.length; i++) {
    result = result && (VecAt(&vec, i) == values[i]);
    }

In Vec.Memory.c:77:

    // First 3 elements should be unchanged
    for (size i = 0; i < 3; i++) {
    result = result && (VecAt(&vec, i) == values[i]);
    }

In Vec.Memory.c:88:

    // First 3 elements should still be the same
    for (size i = 0; i < 3; i++) {
    result = result && (VecAt(&vec, i) == values[i]);
    }

In Vec.Complex.c:161:

    
    // Check that the item was copied correctly
    result = result && ComplexItemsEqual(&VecAt(&vec, 0), &item);
    
    // Modify the original item and verify the vector's copy is independent

In Vec.Complex.c:169:

    
    // The vector's copy should still have the original values
    result = result && (strcmp(VecAt(&vec, 0).name, "Test Item") == 0);
    result = result && (VecAt(&vec, 0).values[0] == 1);

In Vec.Complex.c:170:

    // The vector's copy should still have the original values
    result = result && (strcmp(VecAt(&vec, 0).name, "Test Item") == 0);
    result = result && (VecAt(&vec, 0).values[0] == 1);
    
    // Clean up

In Vec.Complex.c:205:

    
    // Check items order: item2, item1, item3
    result = result && (strcmp(VecAt(&vec, 0).name, "Item 2") == 0);
    result = result && (strcmp(VecAt(&vec, 1).name, "Item 1") == 0);
    result = result && (strcmp(VecAt(&vec, 2).name, "Item 3") == 0);

In Vec.Complex.c:206:

    // Check items order: item2, item1, item3
    result = result && (strcmp(VecAt(&vec, 0).name, "Item 2") == 0);
    result = result && (strcmp(VecAt(&vec, 1).name, "Item 1") == 0);
    result = result && (strcmp(VecAt(&vec, 2).name, "Item 3") == 0);

In Vec.Complex.c:207:

    result = result && (strcmp(VecAt(&vec, 0).name, "Item 2") == 0);
    result = result && (strcmp(VecAt(&vec, 1).name, "Item 1") == 0);
    result = result && (strcmp(VecAt(&vec, 2).name, "Item 3") == 0);
    
    // Check values

In Vec.Complex.c:210:

    
    // Check values
    result = result && (VecAt(&vec, 0).values[0] == 40);
    result = result && (VecAt(&vec, 1).values[0] == 10);
    result = result && (VecAt(&vec, 2).values[0] == 70);

In Vec.Complex.c:211:

    // Check values
    result = result && (VecAt(&vec, 0).values[0] == 40);
    result = result && (VecAt(&vec, 1).values[0] == 10);
    result = result && (VecAt(&vec, 2).values[0] == 70);

In Vec.Complex.c:212:

    result = result && (VecAt(&vec, 0).values[0] == 40);
    result = result && (VecAt(&vec, 1).values[0] == 10);
    result = result && (VecAt(&vec, 2).values[0] == 70);
    
    // Clean up

In Vec.Complex.c:253:

    
    // Check items order: item2, item3, item1
    result = result && (strcmp(VecAt(&vec, 0).name, "Item 2") == 0);
    result = result && (strcmp(VecAt(&vec, 1).name, "Item 3") == 0);
    result = result && (strcmp(VecAt(&vec, 2).name, "Item 1") == 0);

In Vec.Complex.c:254:

    // Check items order: item2, item3, item1
    result = result && (strcmp(VecAt(&vec, 0).name, "Item 2") == 0);
    result = result && (strcmp(VecAt(&vec, 1).name, "Item 3") == 0);
    result = result && (strcmp(VecAt(&vec, 2).name, "Item 1") == 0);

In Vec.Complex.c:255:

    result = result && (strcmp(VecAt(&vec, 0).name, "Item 2") == 0);
    result = result && (strcmp(VecAt(&vec, 1).name, "Item 3") == 0);
    result = result && (strcmp(VecAt(&vec, 2).name, "Item 1") == 0);
    
    // Clean up

In Vec.Complex.c:297:

    
    // Check items in vec1: item1, item2, item3
    result = result && (strcmp(VecAt(&vec1, 0).name, "Item 1") == 0);
    result = result && (strcmp(VecAt(&vec1, 1).name, "Item 2") == 0);
    result = result && (strcmp(VecAt(&vec1, 2).name, "Item 3") == 0);

In Vec.Complex.c:298:

    // Check items in vec1: item1, item2, item3
    result = result && (strcmp(VecAt(&vec1, 0).name, "Item 1") == 0);
    result = result && (strcmp(VecAt(&vec1, 1).name, "Item 2") == 0);
    result = result && (strcmp(VecAt(&vec1, 2).name, "Item 3") == 0);

In Vec.Complex.c:299:

    result = result && (strcmp(VecAt(&vec1, 0).name, "Item 1") == 0);
    result = result && (strcmp(VecAt(&vec1, 1).name, "Item 2") == 0);
    result = result && (strcmp(VecAt(&vec1, 2).name, "Item 3") == 0);
    
    // Now test VecMergeL which transfers ownership

In Vec.Complex.c:329:

    
    // Check items in vec3: item4, item5
    result = result && (strcmp(VecAt(&vec3, 0).name, "Item 4") == 0);
    result = result && (strcmp(VecAt(&vec3, 1).name, "Item 5") == 0);

In Vec.Complex.c:330:

    // Check items in vec3: item4, item5
    result = result && (strcmp(VecAt(&vec3, 0).name, "Item 4") == 0);
    result = result && (strcmp(VecAt(&vec3, 1).name, "Item 5") == 0);
    
    // Clean up

In Vec.Complex.c:368:

    
    // Check items order: val2, val3, val1
    result = result && (VecAt(&vec, 0) == 20);
    result = result && (VecAt(&vec, 1) == 30);
    result = result && (VecAt(&vec, 2) == 10);

In Vec.Complex.c:369:

    // Check items order: val2, val3, val1
    result = result && (VecAt(&vec, 0) == 20);
    result = result && (VecAt(&vec, 1) == 30);
    result = result && (VecAt(&vec, 2) == 10);

In Vec.Complex.c:370:

    result = result && (VecAt(&vec, 0) == 20);
    result = result && (VecAt(&vec, 1) == 30);
    result = result && (VecAt(&vec, 2) == 10);
    
    // Test array operations

In Vec.Complex.c:382:

    
    // Check items: val2, val3, val1, arr[0], arr[1], arr[2]
    result = result && (VecAt(&vec, 3) == 40);
    result = result && (VecAt(&vec, 4) == 50);
    result = result && (VecAt(&vec, 5) == 60);

In Vec.Complex.c:383:

    // Check items: val2, val3, val1, arr[0], arr[1], arr[2]
    result = result && (VecAt(&vec, 3) == 40);
    result = result && (VecAt(&vec, 4) == 50);
    result = result && (VecAt(&vec, 5) == 60);

In Vec.Complex.c:384:

    result = result && (VecAt(&vec, 3) == 40);
    result = result && (VecAt(&vec, 4) == 50);
    result = result && (VecAt(&vec, 5) == 60);
    
    // Clean up

In Vec.Complex.c:414:

    
    // Check that the element was inserted
    result = result && (VecAt(&vec, 2) == 99);
    
    // Use regular insert range instead of fast insert range

In Vec.Complex.c:425:

    
    // Check that the array was inserted
    result = result && (VecAt(&vec, 1) == 100);
    result = result && (VecAt(&vec, 2) == 200);
    result = result && (VecAt(&vec, 3) == 300);

In Vec.Complex.c:426:

    // Check that the array was inserted
    result = result && (VecAt(&vec, 1) == 100);
    result = result && (VecAt(&vec, 2) == 200);
    result = result && (VecAt(&vec, 3) == 300);

In Vec.Complex.c:427:

    result = result && (VecAt(&vec, 1) == 100);
    result = result && (VecAt(&vec, 2) == 200);
    result = result && (VecAt(&vec, 3) == 300);
    
    // Clean up

In Vec.Complex.c:448:

    
    result = result && (vec2.length == 6);
    result = result && (VecAt(&vec2, 2) == 42);
    
    // Now try the range insert with a small array

In Vec.Complex.c:460:

    
    // Check that the array was inserted
    result = result && (VecAt(&vec2, 1) == 111);
    result = result && (VecAt(&vec2, 2) == 222);

In Vec.Complex.c:461:

    // Check that the array was inserted
    result = result && (VecAt(&vec2, 1) == 111);
    result = result && (VecAt(&vec2, 2) == 222);
    
    // Clean up

In Vec.Complex.c:488:

    
    // Check that the element was deleted and elements shifted
    result = result && (VecAt(&vec, 0) == 10);
    result = result && (VecAt(&vec, 1) == 20);
    result = result && (VecAt(&vec, 2) == 40); // 30 was deleted, so now 40 is at index 2

In Vec.Complex.c:489:

    // Check that the element was deleted and elements shifted
    result = result && (VecAt(&vec, 0) == 10);
    result = result && (VecAt(&vec, 1) == 20);
    result = result && (VecAt(&vec, 2) == 40); // 30 was deleted, so now 40 is at index 2

In Vec.Complex.c:490:

    result = result && (VecAt(&vec, 0) == 10);
    result = result && (VecAt(&vec, 1) == 20);
    result = result && (VecAt(&vec, 2) == 40); // 30 was deleted, so now 40 is at index 2
    
    // Test VecDeleteRange (regular delete range)

In Vec.Complex.c:499:

    
    // Check that elements were deleted and remaining elements shifted
    result = result && (VecAt(&vec, 0) == 40);
    result = result && (VecAt(&vec, 1) == 50);

In Vec.Complex.c:500:

    // Check that elements were deleted and remaining elements shifted
    result = result && (VecAt(&vec, 0) == 40);
    result = result && (VecAt(&vec, 1) == 50);
    
    // Clean up this vector

In Vec.Complex.c:519:

    
    // Check that the element was deleted and replaced with the last element (90)
    result = result && (VecAt(&vec, 0) == 10);
    result = result && (VecAt(&vec, 1) == 20);
    result = result && (VecAt(&vec, 2) == 90); // 30 was replaced with 90

In Vec.Complex.c:520:

    // Check that the element was deleted and replaced with the last element (90)
    result = result && (VecAt(&vec, 0) == 10);
    result = result && (VecAt(&vec, 1) == 20);
    result = result && (VecAt(&vec, 2) == 90); // 30 was replaced with 90
    result = result && (VecAt(&vec, 7) == 80); // Last element is now 80

In Vec.Complex.c:521:

    result = result && (VecAt(&vec, 0) == 10);
    result = result && (VecAt(&vec, 1) == 20);
    result = result && (VecAt(&vec, 2) == 90); // 30 was replaced with 90
    result = result && (VecAt(&vec, 7) == 80); // Last element is now 80

In Vec.Complex.c:522:

    result = result && (VecAt(&vec, 1) == 20);
    result = result && (VecAt(&vec, 2) == 90); // 30 was replaced with 90
    result = result && (VecAt(&vec, 7) == 80); // Last element is now 80
    
    // Test VecDeleteRangeFast (fast delete range)

In Vec.Complex.c:552:

    
    // Check that the element was deleted
    result = result && (VecAt(&vec, 3) == 50); // 40 was deleted, so now 50 is at index 3
    
    // Clean up

In Vec.Complex.c:570:

    // Test pushing to empty vector
    VecPushBackR(&vec, 10);
    bool result = (vec.length == 1 && VecAt(&vec, 0) == 10);
    
    // Test pushing with zero count

In Vec.Complex.c:580:

    // Test inserting at end index
    VecInsertR(&vec, 20, vec.length);
    result = result && (vec.length == 2 && VecAt(&vec, 1) == 20);
    
    // Test with large number of elements

In Vec.Complex.c:597:

    bool all_correct = true;
    for (int i = 0; i < large_count; i++) {
    if (VecAt(&vec, i) != i) {
    all_correct = false;
    break;

In Vec.Complex.c:614:

    // Push an element (should auto-resize)
    VecPushBackR(&vec, 42);
    result = result && (vec.length == 1 && VecAt(&vec, 0) == 42);
    
    // Clean up

In Vec.Remove.c:57:

    // Check remaining elements
    for (size i = 0; i < vec.length; i++) {
    result = result && (VecAt(&vec, i) == values[i]);
    }

In Vec.Remove.c:105:

    // Check remaining elements
    for (size i = 0; i < vec.length; i++) {
    result = result && (VecAt(&vec, i) == values[i + 1]);
    }

In Vec.Remove.c:150:

    int expected1[] = {10, 20, 40, 50};
    for (size i = 0; i < vec.length; i++) {
    result = result && (VecAt(&vec, i) == expected1[i]);
    }

In Vec.Remove.c:162:

    int expected2[] = {20, 40, 50};
    for (size i = 0; i < vec.length; i++) {
    result = result && (VecAt(&vec, i) == expected2[i]);
    }

In Vec.Remove.c:199:

    int expected[] = {10, 50, 30, 40};
    for (size i = 0; i < vec.length; i++) {
    result = result && (VecAt(&vec, i) == expected[i]);
    }

In Vec.Remove.c:235:

    int expected[] = {10, 20, 60, 70};
    for (size i = 0; i < vec.length; i++) {
    result = result && (VecAt(&vec, i) == expected[i]);
    }

In Vec.Remove.c:264:

    printf("Before fast range delete: ");
    for (size i = 0; i < vec.length; i++) {
    printf("%d ", VecAt(&vec, i));
    }
    printf("\n");

In Vec.Remove.c:275:

    int end_values[3];
    for (int i = 0; i < count; i++) {
    end_values[i] = VecAt(&vec, vec.length - count + i);
    }

In Vec.Remove.c:283:

    printf("After fast range delete: ");
    for (size i = 0; i < vec.length; i++) {
    printf("%d ", VecAt(&vec, i));
    }
    printf("\n");

In Vec.Remove.c:292:

    // Check that the last 3 elements moved to the deleted positions
    for (int i = 0; i < count; i++) {
    result = result && (VecAt(&vec, start_index + i) == end_values[i]);
    }

In Vec.Remove.c:298:

    bool values_found[10] = {false};
    for (size i = 0; i < vec.length; i++) {
    int val   = VecAt(&vec, i);
    int index = val / 10;
    if (index >= 0 && index < 10) {

In Vec.Remove.c:346:

    // Check remaining elements
    for (size i = 0; i < vec.length; i++) {
    result = result && (VecAt(&vec, i) == values[i]);
    }

In Vec.Remove.c:357:

    // Check remaining elements
    for (size i = 0; i < vec.length; i++) {
    result = result && (VecAt(&vec, i) == values[i]);
    }

In Vec.Remove.c:393:

    int expected[] = {10, 20, 40, 50};
    for (size i = 0; i < vec.length; i++) {
    result = result && (VecAt(&vec, i) == expected[i]);
    }

In Vec.Remove.c:428:

    int expected[] = {10, 20, 40, 50};
    for (size i = 0; i < vec.length; i++) {
    result = result && (VecAt(&vec, i) == expected[i]);
    }

In Vec.Remove.c:457:

    printf("Before L-value fast delete: ");
    for (size i = 0; i < vec.length; i++) {
    printf("%d ", VecAt(&vec, i));
    }
    printf("\n");

In Vec.Remove.c:463:

    // Test L-value fast delete operation
    int fast_index       = 2;                           // Delete 30
    int valueToBeDeleted = VecAt(&vec, fast_index);
    int lastValue        = VecAt(&vec, vec.length - 1); // Should move to deleted position
    VecDeleteFast(&vec, fast_index);

In Vec.Remove.c:464:

    int fast_index       = 2;                           // Delete 30
    int valueToBeDeleted = VecAt(&vec, fast_index);
    int lastValue        = VecAt(&vec, vec.length - 1); // Should move to deleted position
    VecDeleteFast(&vec, fast_index);

In Vec.Remove.c:470:

    printf("After L-value fast delete: ");
    for (size i = 0; i < vec.length; i++) {
    printf("%d ", VecAt(&vec, i));
    }
    printf("\n");

In Vec.Remove.c:480:

    bool containsValue = false;
    for (size i = 0; i < vec.length; i++) {
    if (VecAt(&vec, i) == valueToBeDeleted) {
    containsValue = true;
    break;

In Vec.Remove.c:488:

    
    // Check that the value at the deleted position is now the last value
    result = result && (VecAt(&vec, fast_index) == lastValue);
    printf("Value at deleted position (%d) is now %d (expected %d)\n", fast_index, VecAt(&vec, fast_index), lastValue);

In Vec.Remove.c:489:

    // Check that the value at the deleted position is now the last value
    result = result && (VecAt(&vec, fast_index) == lastValue);
    printf("Value at deleted position (%d) is now %d (expected %d)\n", fast_index, VecAt(&vec, fast_index), lastValue);
    
    // Verify all expected values (except the deleted one and the moved one) are still present

In Vec.Remove.c:496:

    bool found = false;
    for (size j = 0; j < vec.length; j++) {
    if (VecAt(&vec, j) == expected_values[i]) {
    found = true;
    break;

In Vec.Remove.c:533:

    printf("Before R-value fast delete: ");
    for (size i = 0; i < vec.length; i++) {
    printf("%d ", VecAt(&vec, i));
    }
    printf("\n");

In Vec.Remove.c:538:

    
    // Remember the value to be deleted and the last value
    int valueToBeDeleted = VecAt(&vec, 2);              // 30
    int lastValue        = VecAt(&vec, vec.length - 1); // Should move to deleted position

In Vec.Remove.c:539:

    // Remember the value to be deleted and the last value
    int valueToBeDeleted = VecAt(&vec, 2);              // 30
    int lastValue        = VecAt(&vec, vec.length - 1); // Should move to deleted position
    
    // Test R-value fast delete operation

In Vec.Remove.c:547:

    printf("After R-value fast delete: ");
    for (size i = 0; i < vec.length; i++) {
    printf("%d ", VecAt(&vec, i));
    }
    printf("\n");

In Vec.Remove.c:557:

    bool containsValue = false;
    for (size i = 0; i < vec.length; i++) {
    if (VecAt(&vec, i) == valueToBeDeleted) {
    containsValue = true;
    break;

In Vec.Remove.c:565:

    
    // Check that the value at the deleted position is now the last value
    result = result && (VecAt(&vec, 2) == lastValue);
    printf("Value at deleted position (2) is now %d (expected %d)\n", VecAt(&vec, 2), lastValue);

In Vec.Remove.c:566:

    // Check that the value at the deleted position is now the last value
    result = result && (VecAt(&vec, 2) == lastValue);
    printf("Value at deleted position (2) is now %d (expected %d)\n", VecAt(&vec, 2), lastValue);
    
    // Verify all expected values (except the deleted one and the moved one) are still present

In Vec.Remove.c:573:

    bool found = false;
    for (size j = 0; j < vec.length; j++) {
    if (VecAt(&vec, j) == expected_values[i]) {
    found = true;
    break;

In Vec.Remove.c:618:

    int expected[] = {10, 20, 60, 70};
    for (size i = 0; i < vec.length; i++) {
    result = result && (VecAt(&vec, i) == expected[i]);
    }

In Vec.Remove.c:653:

    int expected[] = {10, 20, 60, 70};
    for (size i = 0; i < vec.length; i++) {
    result = result && (VecAt(&vec, i) == expected[i]);
    }

In Vec.Remove.c:682:

    printf("Before L-value fast range delete: ");
    for (size i = 0; i < vec.length; i++) {
    printf("%d ", VecAt(&vec, i));
    }
    printf("\n");

In Vec.Remove.c:697:

    printf("After L-value fast range delete: ");
    for (size i = 0; i < vec.length; i++) {
    printf("%d ", VecAt(&vec, i));
    }
    printf("\n");

In Vec.Remove.c:708:

    bool found = false;
    for (size j = 0; j < vec.length; j++) {
    if (VecAt(&vec, j) == valuesToDelete[i]) {
    found = true;
    break;

In Vec.Remove.c:724:

    bool found = false;
    for (size j = 0; j < vec.length; j++) {
    if (VecAt(&vec, j) == remainingValues[i]) {
    found = true;
    break;

In Vec.Remove.c:761:

    printf("Before R-value fast range delete: ");
    for (size i = 0; i < vec.length; i++) {
    printf("%d ", VecAt(&vec, i));
    }
    printf("\n");

In Vec.Remove.c:774:

    printf("After R-value fast range delete: ");
    for (size i = 0; i < vec.length; i++) {
    printf("%d ", VecAt(&vec, i));
    }
    printf("\n");

In Vec.Remove.c:785:

    bool found = false;
    for (size j = 0; j < vec.length; j++) {
    if (VecAt(&vec, j) == valuesToDelete[i]) {
    found = true;
    break;

In Vec.Remove.c:801:

    bool found = false;
    for (size j = 0; j < vec.length; j++) {
    if (VecAt(&vec, j) == remainingValues[i]) {
    found = true;
    break;

In Vec.Init.c:164:

    
    // Check that the data was added correctly
    if (vec.length != 3 || VecAt(&vec, 0) != 10 || VecAt(&vec, 1) != 20 || VecAt(&vec, 2) != 30) {
    result = false;
    }

In Vec.Init.c:196:

    
    // Check that the item was added correctly
    if (test_vec.length != 1 || VecAt(&test_vec, 0).id != 1 || VecAt(&test_vec, 0).value != 3.14f) {
    result = false;
    }

In Vec.Init.c:238:

    if (result) {
    for (size i = 0; i < src.length; i++) {
    if (VecAt(&clone, i) != VecAt(&src, i)) {
    result = false;
    break;

In Vec.Ops.c:46:

    
    // Check that the elements were swapped
    bool result = (VecAt(&vec, 0) == 50 && VecAt(&vec, 4) == 10);
    
    // Swap two elements in the middle

In Vec.Ops.c:52:

    
    // Check that the elements were swapped
    result = result && (VecAt(&vec, 1) == 40 && VecAt(&vec, 3) == 20);
    
    // Check that the middle element is unchanged

In Vec.Ops.c:55:

    
    // Check that the middle element is unchanged
    result = result && (VecAt(&vec, 2) == 30);
    
    // Clean up

In Vec.Ops.c:83:

    bool result = true;
    for (size i = 0; i < vec.length; i++) {
    result = result && (VecAt(&vec, i) == values[4 - i]);
    }

In Vec.Ops.c:91:

    // Check that the elements are back in the original order
    for (size i = 0; i < vec.length; i++) {
    result = result && (VecAt(&vec, i) == values[i]);
    }

In Vec.Ops.c:106:

    // Check that the elements are reversed
    for (size i = 0; i < vec.length; i++) {
    result = result && (VecAt(&vec, i) == even_values[3 - i]);
    }

In Vec.Ops.c:136:

    int  sorted_asc[] = {10, 20, 30, 40, 50};
    for (size i = 0; i < vec.length; i++) {
    result = result && (VecAt(&vec, i) == sorted_asc[i]);
    }

In Vec.Ops.c:145:

    int sorted_desc[] = {50, 40, 30, 20, 10};
    for (size i = 0; i < vec.length; i++) {
    result = result && (VecAt(&vec, i) == sorted_desc[i]);
    }

VecAt

VecAt

Description

Parameters

Usage example (Cross-references)

Share :

`VecAt`