BitVecCapacity

Documentation

API Reference

BitVecCapacity

Description

Maximum number of bits the bitvector can hold without reallocation.

Usage example (Cross-references)

Usage examples (Cross-references)

In Int.c:41:

    
        *out = int_wrap(BitVecInitWithCapacity(capacity, alloc));
        if (capacity != 0 && BitVecCapacity(INT_BITS(out)) < capacity) {
            IntDeinit(out);
            *out = IntInit(alloc);

In BitVec.Memory.c:41:

    
        // Check that capacity is larger than length
        u64  initial_capacity = BitVecCapacity(&bv);
        bool result           = (initial_capacity >= 100) && (BitVecLen(&bv) == 3);

In BitVec.Memory.c:48:

    
        // Check that capacity is now closer to length
        result = result && (BitVecCapacity(&bv) < initial_capacity);
        result = result && (BitVecCapacity(&bv) >= BitVecLen(&bv));

In BitVec.Memory.c:49:

        // Check that capacity is now closer to length
        result = result && (BitVecCapacity(&bv) < initial_capacity);
        result = result && (BitVecCapacity(&bv) >= BitVecLen(&bv));
    
        // Check that data is still intact

In BitVec.Memory.c:80:

    
        // Check that capacity was set correctly
        bool result = (BitVecCapacity(&bv) >= 50) && (BitVecLen(&bv) == 2);
    
        // Check that data is still intact

In BitVec.Memory.c:90:

    
        // Capacity should still accommodate at least the current length
        result = result && (BitVecCapacity(&bv) >= BitVecLen(&bv));
        result = result && (BitVecLen(&bv) == 2);

In BitVec.Memory.c:223:

        // Clone should share the same Allocator* and therefore see identical
        // configuration fields on the base allocator.
        bool result = BitVecLen(&clone) == BitVecLen(&original) && BitVecCapacity(&clone) >= BitVecLen(&original) &&
                      BitVecAllocator(&clone) == BitVecAllocator(&original) &&
                      BitVecAllocator(&clone)->allocate == BitVecAllocator(&original)->allocate &&

In BitVec.Memory.c:249:

        // Test shrink on empty bitvec
        BitVecShrinkToFit(&bv);
        result = result && (BitVecLen(&bv) == 0) && (BitVecCapacity(&bv) >= 0);
    
        // Test shrink on single element

In BitVec.Memory.c:254:

        BitVecPush(&bv, true);
        BitVecShrinkToFit(&bv);
        result = result && (BitVecLen(&bv) == 1) && (BitVecCapacity(&bv) >= 1);
        result = result && (BitVecGet(&bv, 0) == true);

In BitVec.Memory.c:283:

        // Test set capacity on empty bitvec
        BitVecReserve(&bv, 100);
        result = result && (BitVecCapacity(&bv) >= 100) && (BitVecLen(&bv) == 0);
    
        // BitVecReserve is grow-only; use BitVecClear to drop length to 0.

In BitVec.Memory.c:301:

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

In BitVec.Type.c:25:

        // Check initial state
        bool result =
            (BitVecLen(&bitvec) == 0 && BitVecCapacity(&bitvec) == 0 && BitVecData(&bitvec) == NULL &&
             BitVecByteSize(&bitvec) == 0);

In BitVec.Access.Simple.c:112:

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

In BitVec.Access.Simple.c:125:

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

In BitVec.Access.Simple.c:130:

        BitVecReserve(&bv, 100);
        result = result && (BitVecLen(&bv) == 3);
        result = result && (BitVecCapacity(&bv) >= 100);
    
        BitVecDeinit(&bv);

In BitVec.Access.Simple.c:353:

        // Test length and capacity macros if they exist
        result = result && (BitVecLen(&bv) == 2);
        result = result && (BitVecCapacity(&bv) >= 2);
    
        // Test some bit operations

In BitVec.Init.c:33:

        // Check initial state
        bool result = (BitVecLen(&bv) == 0);
        result      = result && (BitVecCapacity(&bv) == 0);
        result      = result && (BitVecData(&bv) == NULL);
        result      = result && (BitVecByteSize(&bv) == 0);

In BitVec.Init.c:68:

        // but we can check that the structure is reset to safe values
        result = result && (BitVecLen(&bv) == 0);
        result = result && (BitVecCapacity(&bv) == 0);
        result = result && (BitVecData(&bv) == NULL);
        result = result && (BitVecByteSize(&bv) == 0);

In BitVec.Init.c:89:

    
        // Check that capacity was increased
        bool result = (BitVecCapacity(&bv) >= 50);
        result      = result && (BitVecLen(&bv) == 0);     // Length should still be 0
        result      = result && (BitVecData(&bv) != NULL); // Memory should be allocated

In BitVec.Init.c:99:

    
        result = result && (BitVecLen(&bv) == 10);
        result = result && (BitVecCapacity(&bv) >= 50); // Should still have the reserved capacity
    
        // Test reserving less than current capacity (should be no-op)

In BitVec.Init.c:102:

    
        // 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:104:

        u64 original_capacity = BitVecCapacity(&bv);
        BitVecReserve(&bv, 25);
        result = result && (BitVecCapacity(&bv) == original_capacity);
    
        // Clean up

In BitVec.Init.c:130:

        // Check initial state
        bool result            = (BitVecLen(&bv) == 4) && (BitVecData(&bv) != NULL);
        u64  original_capacity = BitVecCapacity(&bv);
    
        // Clear the bitvector

In BitVec.Init.c:137:

        // Check that length is 0 but capacity and memory allocation remain
        result = result && (BitVecLen(&bv) == 0);
        result = result && (BitVecCapacity(&bv) == original_capacity);
        result = result && (BitVecData(&bv) != NULL); // Memory should still be allocated

In BitVec.Init.c:232:

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

In BitVec.Init.c:236:

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

In BitVec.Init.c:240:

        // Test very large but reasonable reservation
        BitVecReserve(&bv, 10000);
        result = result && (BitVecCapacity(&bv) >= 10000);
    
        // Test reserving same u64 repeatedly (should be no-op)

In BitVec.Init.c:243:

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

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 BitVec.Init.c:246:

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

In BitVec.Access.c:146:

    
        // Initially should be empty
        bool result = (BitVecLen(&bv) == 0) && (BitVecCapacity(&bv) == 0);
    
        // Add some bits

In BitVec.Access.c:154:

    
        result = result && (BitVecLen(&bv) == 3);
        result = result && (BitVecCapacity(&bv) >= 3);
    
        // Test empty check

In BitVec.Access.c:395:

        // Test all macros on empty bitvector
        result = result && (BitVecLen(&bv) == 0);
        result = result && (BitVecCapacity(&bv) == 0);
        result = result && BitVecEmpty(&bv);
        result = result && (BitVecByteSize(&bv) == 0);

In BitVec.Access.c:405:

    
        result = result && (BitVecLen(&bv) == 65);
        result = result && (BitVecCapacity(&bv) >= 65);
        result = result && !BitVecEmpty(&bv);
        result = result && (BitVecByteSize(&bv) >= 9); // At least 9 bytes for 65 bits

Last updated on June 4, 2026

BitVecByteSize BitVecClear