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

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

 // 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 _BRepGraph_DefsIterator_HeaderFile
 #define _BRepGraph_DefsIterator_HeaderFile
 
 #include <BRepGraph.hxx>
 #include <BRepGraph_RefsView.hxx>
 #include <BRepGraph_TopoView.hxx>
 #include <NCollection_ForwardRange.hxx>
 #include <NCollection_LinearVector.hxx>
 #include <type_traits>
 
 //! @brief Single-level typed iterators over active child definitions.
 //!
 //! These iterators do not recurse and do not accumulate location/orientation.
 //! They provide a lightweight alternative to BRepGraph_ChildExplorer when the
 //! caller only needs the direct active children of one parent definition.
 //!
 //! The iterator skips:
 //! - removed reference entries
 //! - invalid child ids
 //! - removed child definitions
 namespace BRepGraph_DefsIterator
 {
 template <typename ParentIdT,
           typename RefIdT,
           typename RefEntryT,
           typename ChildIdT,
           typename ChildDefT>
 struct BaseTraits
 {
   using ParentId = ParentIdT;
   using RefId    = RefIdT;
   using RefEntry = RefEntryT;
   using ChildId  = ChildIdT;
   using ChildDef = ChildDefT;
 
   static constexpr bool THE_IS_DIRECT = std::is_same_v<RefId, ChildId>;
 };
 
 //! Traits for iterating over shell children of a solid.
 struct ShellOfSolidTraits : public BaseTraits<BRepGraph_SolidId,
                                               BRepGraph_ShellRefId,
                                               BRepGraphInc::ShellRef,
                                               BRepGraph_ShellId,
                                               BRepGraphInc::ShellDef>
 {
   static bool IsParentValid(const BRepGraph& theGraph, const ParentId theParent)
   {
     return theParent.IsValid(theGraph.Topo().Solids().Nb()) && !theParent.IsRemoved(theGraph);
   }
 
   static const NCollection_LinearVector<RefId>& RefIds(const BRepGraph& theGraph,
                                                        const ParentId   theParent)
   {
     return theGraph.Topo().Solids().Relations(theParent).ShellRefIds;
   }
 
   static const BRepGraphInc::ShellRef& Ref(const BRepGraph& theGraph, const RefId theRefId)
   {
     return theGraph.Refs().Shells().Entry(theRefId);
   }
 
   static ChildId ChildIdOf(const BRepGraph&, const BRepGraphInc::ShellRef& theRef)
   {
     return theRef.ChildShellId;
   }
 
   static const ChildDef& Child(const BRepGraph& theGraph, const ChildId theChildId)
   {
     return theGraph.Topo().Shells().Definition(theChildId);
   }
 };
 
 //! Traits for iterating over face children of a shell.
 struct FaceOfShellTraits : public BaseTraits<BRepGraph_ShellId,
                                              BRepGraph_FaceRefId,
                                              BRepGraphInc::FaceRef,
                                              BRepGraph_FaceId,
                                              BRepGraphInc::FaceDef>
 {
   static bool IsParentValid(const BRepGraph& theGraph, const ParentId theParent)
   {
     return theParent.IsValid(theGraph.Topo().Shells().Nb()) && !theParent.IsRemoved(theGraph);
   }
 
   static const NCollection_LinearVector<RefId>& RefIds(const BRepGraph& theGraph,
                                                        const ParentId   theParent)
   {
     return theGraph.Topo().Shells().Relations(theParent).FaceRefIds;
   }
 
   static const BRepGraphInc::FaceRef& Ref(const BRepGraph& theGraph, const RefId theRefId)
   {
     return theGraph.Refs().Faces().Entry(theRefId);
   }
 
   static ChildId ChildIdOf(const BRepGraph&, const BRepGraphInc::FaceRef& theRef)
   {
     return theRef.ChildFaceId;
   }
 
   static const ChildDef& Child(const BRepGraph& theGraph, const ChildId theChildId)
   {
     return theGraph.Topo().Faces().Definition(theChildId);
   }
 };
 
 //! Traits for iterating over wire children of a face.
 struct WireOfFaceTraits : public BaseTraits<BRepGraph_FaceId,
                                             BRepGraph_WireRefId,
                                             BRepGraphInc::WireRef,
                                             BRepGraph_WireId,
                                             BRepGraphInc::WireDef>
 {
   static bool IsParentValid(const BRepGraph& theGraph, const ParentId theParent)
   {
     return theParent.IsValid(theGraph.Topo().Faces().Nb()) && !theParent.IsRemoved(theGraph);
   }
 
   static const NCollection_LinearVector<RefId>& RefIds(const BRepGraph& theGraph,
                                                        const ParentId   theParent)
   {
     return theGraph.Topo().Faces().Relations(theParent).WireRefIds;
   }
 
   static const BRepGraphInc::WireRef& Ref(const BRepGraph& theGraph, const RefId theRefId)
   {
     return theGraph.Refs().Wires().Entry(theRefId);
   }
 
   static ChildId ChildIdOf(const BRepGraph&, const BRepGraphInc::WireRef& theRef)
   {
     return theRef.ChildWireId;
   }
 
   static const ChildDef& Child(const BRepGraph& theGraph, const ChildId theChildId)
   {
     return theGraph.Topo().Wires().Definition(theChildId);
   }
 };
 
 //! Traits for iterating over coedge children of a wire (direct, no ref indirection).
 struct CoEdgeOfWireTraits : public BaseTraits<BRepGraph_WireId,
                                               BRepGraph_CoEdgeId,
                                               BRepGraphInc::CoEdgeDef,
                                               BRepGraph_CoEdgeId,
                                               BRepGraphInc::CoEdgeDef>
 {
   static bool IsParentValid(const BRepGraph& theGraph, const ParentId theParent)
   {
     return theParent.IsValid(theGraph.Topo().Wires().Nb()) && !theParent.IsRemoved(theGraph);
   }
 
   static const NCollection_LinearVector<RefId>& RefIds(const BRepGraph& theGraph,
                                                        const ParentId   theParent)
   {
     return theGraph.Topo().Wires().Relations(theParent).CoEdgeIds;
   }
 
   static const BRepGraphInc::CoEdgeDef& Ref(const BRepGraph& theGraph, const RefId theRefId)
   {
     return theGraph.Topo().CoEdges().Definition(theRefId);
   }
 
   static const ChildDef& Child(const BRepGraph& theGraph, const ChildId theChildId)
   {
     return theGraph.Topo().CoEdges().Definition(theChildId);
   }
 };
 
 //! Traits for iterating over edge children of a wire (via coedge indirection).
 struct EdgeOfWireTraits : public BaseTraits<BRepGraph_WireId,
                                             BRepGraph_CoEdgeId,
                                             BRepGraphInc::CoEdgeDef,
                                             BRepGraph_EdgeId,
                                             BRepGraphInc::EdgeDef>
 {
   static bool IsParentValid(const BRepGraph& theGraph, const ParentId theParent)
   {
     return theParent.IsValid(theGraph.Topo().Wires().Nb()) && !theParent.IsRemoved(theGraph);
   }
 
   static const NCollection_LinearVector<RefId>& RefIds(const BRepGraph& theGraph,
                                                        const ParentId   theParent)
   {
     return theGraph.Topo().Wires().Relations(theParent).CoEdgeIds;
   }
 
   static const BRepGraphInc::CoEdgeDef& Ref(const BRepGraph& theGraph, const RefId theRefId)
   {
     return theGraph.Topo().CoEdges().Definition(theRefId);
   }
 
   static ChildId ChildIdOf(const BRepGraph& theGraph, const BRepGraphInc::CoEdgeDef& theRef)
   {
     const BRepGraph_EdgeId aEdgeId = theRef.ChildEdgeId;
     if (!aEdgeId.IsValid(theGraph.Topo().Edges().Nb()) || aEdgeId.IsRemoved(theGraph))
     {
       return ChildId();
     }
     return aEdgeId;
   }
 
   static const ChildDef& Child(const BRepGraph& theGraph, const ChildId theChildId)
   {
     return theGraph.Topo().Edges().Definition(theChildId);
   }
 };
 
 //! Traits for iterating over solid children of a compsolid.
 struct SolidOfCompSolidTraits : public BaseTraits<BRepGraph_CompSolidId,
                                                   BRepGraph_SolidRefId,
                                                   BRepGraphInc::SolidRef,
                                                   BRepGraph_SolidId,
                                                   BRepGraphInc::SolidDef>
 {
   static bool IsParentValid(const BRepGraph& theGraph, const ParentId theParent)
   {
     return theParent.IsValid(theGraph.Topo().CompSolids().Nb()) && !theParent.IsRemoved(theGraph);
   }
 
   static const NCollection_LinearVector<RefId>& RefIds(const BRepGraph& theGraph,
                                                        const ParentId   theParent)
   {
     return theGraph.Topo().CompSolids().Relations(theParent).SolidRefIds;
   }
 
   static const BRepGraphInc::SolidRef& Ref(const BRepGraph& theGraph, const RefId theRefId)
   {
     return theGraph.Refs().Solids().Entry(theRefId);
   }
 
   static ChildId ChildIdOf(const BRepGraph&, const BRepGraphInc::SolidRef& theRef)
   {
     return theRef.ChildSolidId;
   }
 
   static const ChildDef& Child(const BRepGraph& theGraph, const ChildId theChildId)
   {
     return theGraph.Topo().Solids().Definition(theChildId);
   }
 };
 
 //! Traits for iterating over child nodes of a compound.
 struct ChildOfCompoundTraits : public BaseTraits<BRepGraph_CompoundId,
                                                  BRepGraph_ChildRefId,
                                                  BRepGraphInc::ChildRef,
                                                  BRepGraph_NodeId,
                                                  BRepGraphInc::BaseDef>
 {
   static bool IsParentValid(const BRepGraph& theGraph, const ParentId theParent)
   {
     return theParent.IsValid(theGraph.Topo().Compounds().Nb()) && !theParent.IsRemoved(theGraph);
   }
 
   static const NCollection_LinearVector<RefId>& RefIds(const BRepGraph& theGraph,
                                                        const ParentId   theParent)
   {
     return theGraph.Topo().Compounds().Relations(theParent).ChildRefIds;
   }
 
   static const BRepGraphInc::ChildRef& Ref(const BRepGraph& theGraph, const RefId theRefId)
   {
     return theGraph.Refs().Children().Entry(theRefId);
   }
 
   static ChildId ChildIdOf(const BRepGraph&, const BRepGraphInc::ChildRef& theRef)
   {
     return theRef.ChildNodeId;
   }
 
   static const ChildDef& Child(const BRepGraph& theGraph, const ChildId theChildId)
   {
     return *theGraph.Topo().Gen().TopoEntity(theChildId);
   }
 };
 
 //! Traits for iterating over occurrence children of a product.
 struct OccurrenceOfProductTraits : public BaseTraits<BRepGraph_ProductId,
                                                      BRepGraph_OccurrenceRefId,
                                                      BRepGraphInc::OccurrenceRef,
                                                      BRepGraph_OccurrenceId,
                                                      BRepGraphInc::OccurrenceDef>
 {
   static bool IsParentValid(const BRepGraph& theGraph, const ParentId theParent)
   {
     return theParent.IsValid(theGraph.Topo().Products().Nb()) && !theParent.IsRemoved(theGraph);
   }
 
   static const NCollection_LinearVector<RefId>& RefIds(const BRepGraph& theGraph,
                                                        const ParentId   theParent)
   {
     return theGraph.Topo().Products().Relations(theParent).OccurrenceRefIds;
   }
 
   static const BRepGraphInc::OccurrenceRef& Ref(const BRepGraph& theGraph, const RefId theRefId)
   {
     return theGraph.Refs().Occurrences().Entry(theRefId);
   }
 
   static ChildId ChildIdOf(const BRepGraph&, const BRepGraphInc::OccurrenceRef& theRef)
   {
     return theRef.ChildOccurrenceId;
   }
 
   static const ChildDef& Child(const BRepGraph& theGraph, const ChildId theChildId)
   {
     return theGraph.Topo().Occurrences().Definition(theChildId);
   }
 };
 
 template <typename TraitsT>
 class DefsOfParent
 {
 public:
   using ParentId = typename TraitsT::ParentId;
   using RefId    = typename TraitsT::RefId;
   using ChildId  = typename TraitsT::ChildId;
   using ChildDef = typename TraitsT::ChildDef;
 
   DefsOfParent(const BRepGraph& theGraph, const ParentId theParent)
       : myGraph(theGraph)
   {
     if (!TraitsT::IsParentValid(theGraph, theParent))
     {
       return;
     }
 
     myRefIds = &TraitsT::RefIds(theGraph, theParent);
     myLength = static_cast<uint32_t>(myRefIds->Size());
     if constexpr (std::is_convertible_v<RefId, BRepGraph_NodeId>)
     {
       myNbRefs = theGraph.Topo().Gen().Nb(BRepGraph_NodeId(RefId()).NodeKind);
     }
     else
     {
       myNbRefs = theGraph.Refs().Gen().Nb(BRepGraph_RefId(RefId()).RefKind);
     }
 
     if constexpr (TraitsT::THE_IS_DIRECT)
     {
       myNbChildren = myNbRefs;
     }
     else
     {
       if constexpr (!std::is_same_v<ChildId, BRepGraph_NodeId>)
       {
         myNbChildren = theGraph.Topo().Gen().Nb(BRepGraph_NodeId(ChildId()).NodeKind);
       }
     }
     skipRemoved();
   }
 
   [[nodiscard]] bool More() const { return myRefIds != nullptr && myIndex < myLength; }
 
   void Next()
   {
     ++myIndex;
     // Fast-path: check if the very next element is already valid.
     if (myRefIds != nullptr && myIndex < myLength)
     {
       const RefId aRefId = myRefIds->Value(static_cast<size_t>(myIndex));
       if (aRefId.IsValid(myNbRefs) && !aRefId.IsRemoved(myGraph))
       {
         if constexpr (TraitsT::THE_IS_DIRECT)
         {
           myCurrentChild = ChildId(aRefId);
           return;
         }
         else
         {
           const typename TraitsT::RefEntry& aRef     = TraitsT::Ref(myGraph, aRefId);
           const ChildId                     aChildId = TraitsT::ChildIdOf(myGraph, aRef);
           if constexpr (std::is_same_v<ChildId, BRepGraph_NodeId>)
           {
             if (myGraph.Topo().Gen().IsActive(aChildId))
             {
               myCurrentChild = aChildId;
               return;
             }
           }
           else if (aChildId.IsValid(myNbChildren) && !aChildId.IsRemoved(myGraph))
           {
             myCurrentChild = aChildId;
             return;
           }
         }
       }
     }
     // Slow-path: full scan for next valid element.
     skipRemoved();
   }
 
   [[nodiscard]] ChildId CurrentId() const
   {
     Standard_ASSERT_VOID(More(), "DefsOfParent::CurrentId() called on exhausted iterator");
     return myCurrentChild;
   }
 
   [[nodiscard]] const ChildDef& Current() const
   {
     Standard_ASSERT_VOID(More(), "DefsOfParent::Current() called on exhausted iterator");
     return TraitsT::Child(myGraph, CurrentId());
   }
 
   //! Returns the reference/coedge entry that carries the current child relation.
   [[nodiscard]] RefId CurrentRefId() const
   {
     return myRefIds != nullptr && myIndex < myLength ? myRefIds->Value(static_cast<size_t>(myIndex))
                                                      : RefId();
   }
 
   [[nodiscard]] uint32_t Index() const { return myIndex; }
 
   //! Returns an STL-compatible iterator for range-based for loops.
   NCollection_ForwardRangeIterator<DefsOfParent> begin()
   {
     return NCollection_ForwardRangeIterator<DefsOfParent>(this);
   }
 
   //! Returns a sentinel marking the end of iteration.
   NCollection_ForwardRangeSentinel end() const { return NCollection_ForwardRangeSentinel{}; }
 
 private:
   void skipRemoved()
   {
     while (myRefIds != nullptr && myIndex < myLength)
     {
       const RefId aRefId = myRefIds->Value(static_cast<size_t>(myIndex));
       if (aRefId.IsValid(myNbRefs) && !aRefId.IsRemoved(myGraph))
       {
         const ChildId aChildId = [&]() {
           if constexpr (TraitsT::THE_IS_DIRECT)
           {
             return ChildId(aRefId);
           }
           else
           {
             const typename TraitsT::RefEntry& aRef = TraitsT::Ref(myGraph, aRefId);
             return TraitsT::ChildIdOf(myGraph, aRef);
           }
         }();
         if constexpr (std::is_same_v<ChildId, BRepGraph_NodeId>)
         {
           if (myGraph.Topo().Gen().IsActive(aChildId))
           {
             myCurrentChild = aChildId;
             return;
           }
         }
         else if (aChildId.IsValid(myNbChildren) && !aChildId.IsRemoved(myGraph))
         {
           myCurrentChild = aChildId;
           return;
         }
       }
       ++myIndex;
     }
   }
 
   const BRepGraph&                       myGraph;
   const NCollection_LinearVector<RefId>* myRefIds = nullptr;
   ChildId                                myCurrentChild{};
   uint32_t                               myIndex      = 0;
   uint32_t                               myLength     = 0;
   uint32_t                               myNbRefs     = 0;
   uint32_t                               myNbChildren = 0;
 };
 
 //! @brief Direct active boundary vertex children of an edge.
 //!
 //! Iteration order is start vertex, then end vertex.
 class DefsVertexOfEdge
 {
 public:
   using ChildId  = BRepGraph_VertexId;
   using ChildDef = BRepGraphInc::VertexDef;
 
   DefsVertexOfEdge(const BRepGraph& theGraph, const BRepGraph_EdgeId theEdgeId)
       : myGraph(theGraph)
   {
     if (!theEdgeId.IsValid(theGraph.Topo().Edges().Nb()) || theEdgeId.IsRemoved(theGraph))
     {
       return;
     }
 
     myEdge         = &theGraph.Topo().Edges().Definition(theEdgeId);
     myLength       = 2u;
     myNbVertexRefs = theGraph.Refs().Vertices().Nb();
     myNbVertices   = theGraph.Topo().Vertices().Nb();
     skipRemoved();
   }
 
   [[nodiscard]] bool More() const { return myEdge != nullptr && myIndex < myLength; }
 
   void Next()
   {
     ++myIndex;
     skipRemoved();
   }
 
   [[nodiscard]] ChildId CurrentId() const
   {
     Standard_ASSERT_VOID(More(), "DefsVertexOfEdge::CurrentId() called on exhausted iterator");
     return myGraph.Refs().Vertices().Entry(currentRefId()).ChildVertexId;
   }
 
   [[nodiscard]] const ChildDef& Current() const
   {
     Standard_ASSERT_VOID(More(), "DefsVertexOfEdge::Current() called on exhausted iterator");
     return myGraph.Topo().Vertices().Definition(CurrentId());
   }
 
   //! Returns the start/end vertex reference entry that carries the current child relation.
   [[nodiscard]] BRepGraph_VertexRefId CurrentRefId() const
   {
     return More() ? currentRefId() : BRepGraph_VertexRefId();
   }
 
   [[nodiscard]] uint32_t Index() const { return myIndex; }
 
   //! Returns an STL-compatible iterator for range-based for loops.
   NCollection_ForwardRangeIterator<DefsVertexOfEdge> begin()
   {
     return NCollection_ForwardRangeIterator<DefsVertexOfEdge>(this);
   }
 
   //! Returns a sentinel marking the end of iteration.
   NCollection_ForwardRangeSentinel end() const { return NCollection_ForwardRangeSentinel{}; }
 
 private:
   [[nodiscard]] BRepGraph_VertexRefId refIdAt(const uint32_t theIndex) const
   {
     if (theIndex == 0)
     {
       return myEdge->StartVertexRefId;
     }
     return myEdge->EndVertexRefId;
   }
 
   [[nodiscard]] BRepGraph_VertexRefId currentRefId() const { return refIdAt(myIndex); }
 
   void skipRemoved()
   {
     while (myEdge != nullptr && myIndex < myLength)
     {
       const BRepGraph_VertexRefId aRefId = refIdAt(myIndex);
       if (aRefId.IsValid(myNbVertexRefs) && !myGraph.Refs().Gen().IsRemoved(aRefId))
       {
         const BRepGraphInc::VertexRef& aRef = myGraph.Refs().Vertices().Entry(aRefId);
         if (!aRef.ChildVertexId.IsValid(myNbVertices) || aRef.ChildVertexId.IsRemoved(myGraph))
         {
           ++myIndex;
           continue;
         }
         return;
       }
       ++myIndex;
     }
   }
 
   const BRepGraph&             myGraph;
   const BRepGraphInc::EdgeDef* myEdge         = nullptr;
   uint32_t                     myIndex        = 0;
   uint32_t                     myLength       = 0;
   uint32_t                     myNbVertexRefs = 0;
   uint32_t                     myNbVertices   = 0;
 };
 
 } // namespace BRepGraph_DefsIterator
 
 using BRepGraph_DefsShellOfSolid =
   BRepGraph_DefsIterator::DefsOfParent<BRepGraph_DefsIterator::ShellOfSolidTraits>;
 using BRepGraph_DefsFaceOfShell =
   BRepGraph_DefsIterator::DefsOfParent<BRepGraph_DefsIterator::FaceOfShellTraits>;
 using BRepGraph_DefsEdgeOfWire =
   BRepGraph_DefsIterator::DefsOfParent<BRepGraph_DefsIterator::EdgeOfWireTraits>;
 using BRepGraph_DefsWireOfFace =
   BRepGraph_DefsIterator::DefsOfParent<BRepGraph_DefsIterator::WireOfFaceTraits>;
 using BRepGraph_DefsCoEdgeOfWire =
   BRepGraph_DefsIterator::DefsOfParent<BRepGraph_DefsIterator::CoEdgeOfWireTraits>;
 using BRepGraph_DefsSolidOfCompSolid =
   BRepGraph_DefsIterator::DefsOfParent<BRepGraph_DefsIterator::SolidOfCompSolidTraits>;
 using BRepGraph_DefsChildOfCompound =
   BRepGraph_DefsIterator::DefsOfParent<BRepGraph_DefsIterator::ChildOfCompoundTraits>;
 using BRepGraph_DefsOccurrenceOfProduct =
   BRepGraph_DefsIterator::DefsOfParent<BRepGraph_DefsIterator::OccurrenceOfProductTraits>;
 using BRepGraph_DefsVertexOfEdge = BRepGraph_DefsIterator::DefsVertexOfEdge;
 
 #endif // _BRepGraph_DefsIterator_HeaderFile

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