VecAlignedOffsetAt

Documentation

API Reference

VecAlignedOffsetAt

Description

Compute the aligned byte offset of element idx from the start of the vector data buffer. The vector applies per-element alignment internally so that arbitrarily-typed payloads are correctly aligned.

Stride is taken from allocator->alignment when an allocator is present; for stack-init vecs (NULL allocator – see VecInitStack / StrInitStack) the stride collapses to sizeof(VEC_DATATYPE(v)) because the macro backs storage with an _Alignas(T) char[], giving every slot T’s natural alignment without padding.

Parameters

Name	Direction	Description
`v`	in	Vector to query.
`idx`	in	Element index.

Usage example (Cross-references)

Usage examples (Cross-references)

In VecCharPtr.c:448:

                if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
                    size_t index   = extract_u32(data, offset, data_size) % VecLen(vec);
                    size_t aligned = VecAlignedOffsetAt(vec, index);
                    (void)aligned;
                }

In VecStr.c:425:

                if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
                    size_t index   = extract_u32(data, offset, data_size) % VecLen(vec);
                    size_t aligned = VecAlignedOffsetAt(vec, index);
                    (void)aligned;
                }

In VecInt.c:366:

                uint16_t idx = extract_u16(data, offset, data_size);
                if (idx <= VecLen(vec)) {
                    volatile uint64_t offset_val = VecAlignedOffsetAt(vec, idx);
                    (void)offset_val;
                }

In Vec.Access.c:191:

        vec_size            = VecSize(&vec);
        vec_len             = VecLen(&vec);
        size aligned_offset = VecAlignedOffsetAt(&vec, VecLen(&vec));
        result              = result && (vec_size == aligned_offset);
        result              = result && (vec_len == VecLen(&vec));

In Vec.Access.c:209:

        size aligned_vec_size  = VecSize(&aligned_vec);
        size aligned_vec_len   = VecLen(&aligned_vec);
        size aligned_offset_at = VecAlignedOffsetAt(&aligned_vec, VecLen(&aligned_vec));
        result                 = result && (aligned_vec_size == aligned_offset_at);
        result                 = result && (aligned_vec_len == VecLen(&aligned_vec));

In Vec.Access.c:223:

    // Test VecAlignedOffsetAt function
    bool test_vec_aligned_offset_at(void) {
        WriteFmt("Testing VecAlignedOffsetAt\n");
    
        DefaultAllocator alloc    = DefaultAllocatorInit();

In Vec.Access.c:233:

    
        // Check offsets
        bool result = (VecAlignedOffsetAt(&vec, 0) == 0);
        result      = result && (VecAlignedOffsetAt(&vec, 1) == sizeof(int));
        result      = result && (VecAlignedOffsetAt(&vec, 2) == 2 * sizeof(int));

In Vec.Access.c:234:

        // Check offsets
        bool result = (VecAlignedOffsetAt(&vec, 0) == 0);
        result      = result && (VecAlignedOffsetAt(&vec, 1) == sizeof(int));
        result      = result && (VecAlignedOffsetAt(&vec, 2) == 2 * sizeof(int));

In Vec.Access.c:235:

        bool result = (VecAlignedOffsetAt(&vec, 0) == 0);
        result      = result && (VecAlignedOffsetAt(&vec, 1) == sizeof(int));
        result      = result && (VecAlignedOffsetAt(&vec, 2) == 2 * sizeof(int));
    
        // Clean up

In Vec.Access.c:248:

    
        // Check offsets with alignment
        result = result && (VecAlignedOffsetAt(&aligned_vec, 0) == 0);
        result = result && (VecAlignedOffsetAt(&aligned_vec, 1) == aligned_size);
        result = result && (VecAlignedOffsetAt(&aligned_vec, 2) == 2 * aligned_size);

In Vec.Access.c:249:

        // Check offsets with alignment
        result = result && (VecAlignedOffsetAt(&aligned_vec, 0) == 0);
        result = result && (VecAlignedOffsetAt(&aligned_vec, 1) == aligned_size);
        result = result && (VecAlignedOffsetAt(&aligned_vec, 2) == 2 * aligned_size);

In Vec.Access.c:250:

        result = result && (VecAlignedOffsetAt(&aligned_vec, 0) == 0);
        result = result && (VecAlignedOffsetAt(&aligned_vec, 1) == aligned_size);
        result = result && (VecAlignedOffsetAt(&aligned_vec, 2) == 2 * aligned_size);
    
        // Clean up

In Access.h:42:

    /// TAGS: Vec, Access, Index
    ///
    #define VecAt(v, idx) ((VEC_DATATYPE(v) *)(VecAlignedOffsetAt((v), (idx)) + (char *)(v)->data))[0]
    
    ///

In Access.h:53:

    /// TAGS: Vec, Access, Index, Pointer
    ///
    #define VecPtrAt(v, idx) ((VEC_DATATYPE(v) *)(VecAlignedOffsetAt((v), (idx)) + (char *)(v)->data))
    
    ///

In Access.h:92:

    /// TAGS: Vec, Access, Iterator, End
    ///
    #define VecEnd(v) ((VEC_DATATYPE(v) *)((char *)(v)->data + VecAlignedOffsetAt((v), (v)->length)))
    
    ///

In Access.h:103:

    /// TAGS: Vec, Access, Size, Bytes
    ///
    #define VecSize(v) VecAlignedOffsetAt(v, (v)->length)
    
    ///

In Access.h:132:

    /// TAGS: Str, Access, Alignment
    ///
    #define StrAlignedOffsetAt(str, idx) VecAlignedOffsetAt(str, idx)
    
    ///

Last updated on June 4, 2026

Vec VecAllocator