BitVecReserve

Documentation

API Reference

BitVecReserve

Description

Ensure bv can hold at least n bits without further reallocation.

Parameters

Name	Direction	Description
`bv`	in,out	Bitvector whose capacity should grow.
`n`	in	Minimum bit capacity required after the call.

Success

Returns true; bv->capacity is at least n and existing bits are preserved.

Failure

Returns false on allocator OOM; bv is left unchanged.

Usage example (Cross-references)

Usage examples (Cross-references)

In BitVec.c:109:

        ValidateBitVec(bitvec);
        if (new_size > bitvec->capacity) {
            if (!BitVecReserve(bitvec, new_size)) {
                return false;
            }

In BitVec.c:138:

    }
    
    bool BitVecReserve(BitVec *bitvec, u64 n) {
        ValidateBitVec(bitvec);
        if (n <= bitvec->capacity)

In BitVec.c:233:

        }
    
        if (!BitVecReserve(out, bv->length) || !BitVecResize(out, bv->length)) {
            BitVecDeinit(out);
            *out = BitVecInit(bv->allocator);

In BitVec.c:297:

        if (bitvec->length >= bitvec->capacity) {
            u64 new_capacity = bitvec->capacity == 0 ? 8 : bitvec->capacity * 2;
            if (!BitVecReserve(bitvec, new_capacity)) {
                return false;
            }

In BitVec.c:879:

        *out = BitVecInit(alloc);
    
        if (!BitVecReserve(out, str_len)) {
            return false;
        }

In BitVec.c:982:

        }
    
        if (!BitVecReserve(out, bit_len) || !BitVecResize(out, bit_len)) {
            BitVecDeinit(out);
            *out = BitVecInit(alloc);

In BitVec.c:1040:

        }
    
        if (!BitVecReserve(out, bits) || !BitVecResize(out, bits)) {
            BitVecDeinit(out);
            *out = BitVecInit(alloc);

In BitVec.Memory.c:38:

    
        // Force capacity to be larger than needed by reserving space
        BitVecReserve(&bv, 100);
    
        // Check that capacity is larger than length

In BitVec.Memory.c:68:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecReserve\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Memory.c:77:

    
        // Set capacity to a specific value
        BitVecReserve(&bv, 50);
    
        // Check that capacity was set correctly

In BitVec.Memory.c:87:

    
        // Try to set capacity smaller than current length (should not shrink below length)
        BitVecReserve(&bv, 1);
    
        // Capacity should still accommodate at least the current length

In BitVec.Memory.c:263:

    
        // Test shrink after reserve and clear
        BitVecReserve(&bv, 1000);
        BitVecClear(&bv);
        BitVecShrinkToFit(&bv);

In BitVec.Memory.c:276:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecReserve edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Memory.c:282:

    
        // Test set capacity on empty bitvec
        BitVecReserve(&bv, 100);
        result = result && (BitVecCapacity(&bv) >= 100) && (BitVecLen(&bv) == 0);

In BitVec.Memory.c:300:

    
        // Test setting very large capacity
        BitVecReserve(&bv, 10000);
        result = result && (BitVecCapacity(&bv) >= 10000);

In BitVec.Memory.c:417:

            BitVecSwap(&bv1, &bv2);
    
            BitVecReserve(&bv1, cycle * 20);
            BitVecShrinkToFit(&bv2);

In BitVec.Access.Simple.c:128:

    
        // Reserve more space
        BitVecReserve(&bv, 100);
        result = result && (BitVecLen(&bv) == 3);
        result = result && (BitVecCapacity(&bv) >= 100);

In BitVec.Access.Simple.c:382:

        // Create large bitvector
        const int size = 10000;
        BitVecReserve(&bv, size);
    
        // Set alternating pattern

In BitVec.Init.c:81:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecReserve\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Init.c:86:

    
        // Reserve space for 50 bits
        BitVecReserve(&bv, 50);
    
        // Check that capacity was increased

In BitVec.Init.c:103:

        // Test reserving less than current capacity (should be no-op)
        u64 original_capacity = BitVecCapacity(&bv);
        BitVecReserve(&bv, 25);
        result = result && (BitVecCapacity(&bv) == original_capacity);

In BitVec.Init.c:225:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecReserve edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Init.c:231:

    
        // Test reserving 0 (should be safe no-op)
        BitVecReserve(&bv, 0);
        result = result && (BitVecCapacity(&bv) == 0) && (BitVecData(&bv) == NULL);

In BitVec.Init.c:235:

    
        // Test reserving 1 bit (minimum meaningful size)
        BitVecReserve(&bv, 1);
        result = result && (BitVecCapacity(&bv) >= 1) && (BitVecData(&bv) != NULL);

In BitVec.Init.c:239:

    
        // Test very large but reasonable reservation
        BitVecReserve(&bv, 10000);
        result = result && (BitVecCapacity(&bv) >= 10000);

In BitVec.Init.c:244:

        // Test reserving same u64 repeatedly (should be no-op)
        u64 cap_before = BitVecCapacity(&bv);
        BitVecReserve(&bv, BitVecCapacity(&bv));
        BitVecReserve(&bv, BitVecCapacity(&bv));
        result = result && (BitVecCapacity(&bv) == cap_before);

In BitVec.Init.c:245:

        u64 cap_before = BitVecCapacity(&bv);
        BitVecReserve(&bv, BitVecCapacity(&bv));
        BitVecReserve(&bv, BitVecCapacity(&bv));
        result = result && (BitVecCapacity(&bv) == cap_before);

In Init.h:27:

    #define BitVecMustReserve(bv, n)                                                                                       \
        do {                                                                                                               \
            if (!BitVecReserve((bv), (n))) {                                                                               \
                LOG_FATAL("BitVecMustReserve failed");                                                                     \
            }                                                                                                              \

Last updated on June 4, 2026

BitVecReplaceAll BitVecResize