find_first()

fl::i32 fl::bitset_dynamic::find_first ( bool test_value, fl::u32 offset = 0 ) const

inlinenoexcept

Finds the first bit that matches the test value.

Returns the index of the first matching bit, or -1 if none found.

Parameters

test_value	The value to search for (true or false)
offset	Starting position to search from (default: 0)

Definition at line 315 of file bitset_dynamic.h.

                                                                       {
        // If offset is beyond our size, no match possible
        if (offset >= _size) {
            return -1;
        }
 
        // Calculate which block to start from
        fl::u32 start_block = offset / bits_per_block;
        fl::u32 start_bit = offset % bits_per_block;
        
        for (fl::u32 block_idx = start_block; block_idx < _block_count; ++block_idx) {
            block_type current_block = _blocks[block_idx];
            
            // For the last block, we need to mask out unused bits
            if (block_idx == _block_count - 1 && _size % bits_per_block != 0) {
                const fl::u32 valid_bits = _size % bits_per_block;
                block_type mask = (valid_bits == bits_per_block) 
                    ? static_cast<block_type>(~block_type(0)) 
                    : static_cast<block_type>(((block_type(1) << valid_bits) - 1));
                current_block &= mask;
            }
            
            // If looking for false bits, invert the block
            if (!test_value) {
                current_block = ~current_block;
            }
            
            // For the first block, mask out bits before the offset
            if (block_idx == start_block && start_bit > 0) {
                current_block &= ~static_cast<block_type>(((block_type(1) << start_bit) - 1));
            }
            
            // If there are any matching bits in this block
            if (current_block != 0) {
                // Find the first set bit
                fl::u32 bit_pos = static_cast<fl::u32>(__builtin_ctz(current_block));
                fl::u32 absolute_pos = block_idx * bits_per_block + bit_pos;
                
                // Make sure we haven't gone past the end of the bitset
                if (absolute_pos < _size) {
                    return static_cast<fl::i32>(absolute_pos);
                }
            }
        }
        
        return -1;  // No matching bit found
    }

References _block_count, _blocks, _size, bits_per_block, and offset().

Here is the call graph for this function: