EIC code displayed by LXR master/​include/​opencascade/​BRepGraphInc_BitFlags.hxx	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2026-09-28 09:19:37

 // Copyright (c) 2026 OPEN CASCADE SAS
 //
 // This file is part of Open CASCADE Technology software library.
 //
 // This library is free software; you can redistribute it and/or modify it under
 // the terms of the GNU Lesser General Public License version 2.1 as published
 // by the Free Software Foundation, with special exception defined in the file
 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
 // distribution for complete text of the license and disclaimer of any warranty.
 //
 // Alternatively, this file may be used under the terms of Open CASCADE
 // commercial license or contractual agreement.
 
 #ifndef _BRepGraphInc_BitFlags_HeaderFile
 #define _BRepGraphInc_BitFlags_HeaderFile
 
 #include <NCollection_LinearVector.hxx>
 
 #include <cstdint>
 #include <cstddef>
 
 //! @brief Contiguous bit-vector for per-entity boolean flags.
 //!
 //! Stores one bit per entity index in a flat array of 64-bit blocks.
 //! Provides O(1) Set/Clear/Test operations and cache-friendly sequential
 //! traversal (512 flags per 64-byte cache line via eight 64-bit blocks).
 //!
 //! Used by BRepGraphInc_Storage to store IsRemoved and IsOwned flags
 //! outside the entity structs, improving cache locality during traversal
 //! and reducing struct size by eliminating bool-field padding.
 //!
 //! Public helpers in BRepGraphInc_Storage validate indices before reaching this
 //! low-level container. Set, Clear, and Test remain unchecked for hot internal
 //! paths that already proved the index is in range.
 //!
 //! @code
 //!   BRepGraphInc_BitFlags aFlags;
 //!   aFlags.Resize(1000);
 //!   aFlags.Set(42);
 //!   if (aFlags.Test(42)) { ... }
 //!   aFlags.Clear(42);
 //! @endcode
 class BRepGraphInc_BitFlags
 {
   static constexpr uint32_t THE_BITS_PER_BLOCK = 64;
   using BlockType                              = uint64_t;
 
 public:
   //! Construct an empty bit-vector.
   BRepGraphInc_BitFlags() = default;
 
   //! Resize the bit-vector to hold at least theCount bits.
   //! Newly added bits are initialized to false.
   void Resize(const size_t theCount)
   {
     const size_t aBlockCount = (theCount + THE_BITS_PER_BLOCK - 1) / THE_BITS_PER_BLOCK;
     myBlocks.Resize(aBlockCount, 0);
     myBitCount = theCount;
     maskTailBits();
   }
 
   //! Set the bit at theIndex to true.
   void Set(const uint32_t theIndex)
   {
     const size_t   aBlock = theIndex / THE_BITS_PER_BLOCK;
     const uint32_t aBit   = theIndex % THE_BITS_PER_BLOCK;
     myBlocks[aBlock] |= (BlockType(1) << aBit);
   }
 
   //! Clear the bit at theIndex to false.
   void Clear(const uint32_t theIndex)
   {
     const size_t   aBlock = theIndex / THE_BITS_PER_BLOCK;
     const uint32_t aBit   = theIndex % THE_BITS_PER_BLOCK;
     myBlocks[aBlock] &= ~(BlockType(1) << aBit);
   }
 
   //! Return the value of the bit at theIndex.
   [[nodiscard]] bool Test(const uint32_t theIndex) const
   {
     const size_t   aBlock = theIndex / THE_BITS_PER_BLOCK;
     const uint32_t aBit   = theIndex % THE_BITS_PER_BLOCK;
     return (myBlocks[aBlock] & (BlockType(1) << aBit)) != 0;
   }
 
   //! Set all bits to true.
   void SetAll()
   {
     for (size_t i = 0; i < myBlocks.Size(); ++i)
     {
       myBlocks[i] = ~BlockType(0);
     }
     maskTailBits();
   }
 
   //! Clear all bits to false.
   void ClearAll()
   {
     for (size_t i = 0; i < myBlocks.Size(); ++i)
     {
       myBlocks[i] = 0;
     }
   }
 
   //! Return true if any bit is set.
   [[nodiscard]] bool HasAnyBitSet() const
   {
     for (size_t i = 0; i < myBlocks.Size(); ++i)
     {
       if (myBlocks[i] != 0)
       {
         return true;
       }
     }
     return false;
   }
 
   //! Return the number of blocks allocated.
   [[nodiscard]] size_t NbBlocks() const { return myBlocks.Size(); }
 
   //! Return the number of valid bits represented by this vector.
   [[nodiscard]] size_t BitCount() const { return myBitCount; }
 
   //! Return true if theIndex is inside the valid bit range.
   [[nodiscard]] bool IsValidIndex(const uint32_t theIndex) const { return theIndex < myBitCount; }
 
   //! Return the raw block array for direct iteration.
   [[nodiscard]] const BlockType* Blocks() const { return myBlocks.Data(); }
 
 private:
   void maskTailBits()
   {
     const uint32_t aTailBits = static_cast<uint32_t>(myBitCount % THE_BITS_PER_BLOCK);
     if (aTailBits == 0u || myBlocks.Size() == 0)
     {
       return;
     }
 
     const BlockType aTailMask = (BlockType(1) << aTailBits) - BlockType(1);
     myBlocks[myBlocks.Size() - 1] &= aTailMask;
   }
 
   NCollection_LinearVector<BlockType> myBlocks;
   size_t                              myBitCount = 0;
 };
 
 #endif // _BRepGraphInc_BitFlags_HeaderFile

This page was automatically generated by the 2.3.7 LXR engine. The LXR team