LCOV - code coverage report
Current view: top level - geom/virtual - PartitionCoEdge.cpp (source / functions) Hit Total Coverage
Test: coverage_sk.info Lines: 1 82 1.2 %
Date: 2020-06-30 00:58:45 Functions: 2 21 9.5 %
Branches: 2 106 1.9 %

           Branch data     Line data    Source code
       1                 :            : #include "PartitionCoEdge.hpp"
       2                 :            : #include "PartitionSurface.hpp"
       3                 :            : #include "PartitionCurve.hpp"
       4                 :            : #include "PartitionLoop.hpp"
       5                 :            : #include "PartitionEngine.hpp"
       6                 :            : #include "VirtualQueryEngine.hpp"
       7                 :            : 
       8                 :          0 : PartitionCoEdge::PartitionCoEdge(PartitionSurface* surf, CubitSense sense)
       9                 :            :   : mySense(sense),
      10                 :            :     myLoop(0), 
      11                 :            :     loopPrev(0),
      12                 :            :     loopNext(0),
      13                 :            :     myCurve(0), 
      14         [ #  # ]:          0 :     curveNext(0)
      15                 :            : { 
      16 [ #  # ][ #  # ]:          0 :   surf->sub_entity_set().add_lower_order( this );
      17                 :          0 : }
      18                 :            : 
      19                 :          0 : PartitionCoEdge::PartitionCoEdge(CoEdgeSM* coedge)
      20                 :            :   : myLoop(0), 
      21                 :            :     loopPrev(0),
      22                 :            :     loopNext(0),
      23                 :            :     myCurve(0), 
      24         [ #  # ]:          0 :     curveNext(0)
      25                 :            : {
      26         [ #  # ]:          0 :   mySense = coedge->sense();
      27 [ #  # ][ #  # ]:          0 :   assert( dynamic_cast<SubEntitySet*>(coedge->owner()) == 0 );
                 [ #  # ]
      28 [ #  # ][ #  # ]:          0 :   new SubEntitySet( coedge, this );
      29                 :          0 : }
      30                 :            : 
      31                 :          0 : PartitionCoEdge::PartitionCoEdge(PartitionCoEdge* split_from)
      32                 :            :   : myLoop(0), 
      33                 :            :     loopPrev(0),
      34                 :            :     loopNext(0),
      35                 :            :     myCurve(0), 
      36         [ #  # ]:          0 :     curveNext(0)
      37                 :            : {
      38                 :          0 :   mySense = split_from->mySense;
      39 [ #  # ][ #  # ]:          0 :   if( split_from->real_coedge() )
      40                 :            :   {
      41 [ #  # ][ #  # ]:          0 :     split_from->sub_entity_set().add_partition( this, split_from );
                 [ #  # ]
      42                 :            :   }
      43                 :            :   else
      44                 :            :   {
      45 [ #  # ][ #  # ]:          0 :     split_from->sub_entity_set().add_lower_order( this );
      46                 :            :   }
      47                 :          0 : }
      48                 :            : 
      49         [ #  # ]:          0 : PartitionCoEdge::~PartitionCoEdge()
      50                 :            : {
      51         [ #  # ]:          0 :   if( myCurve )
      52         [ #  # ]:          0 :     myCurve->remove(this);
      53         [ #  # ]:          0 :   if( myLoop )
      54         [ #  # ]:          0 :     myLoop->remove(this);
      55                 :            :   
      56 [ #  # ][ #  # ]:          0 :   assert( !myCurve && !myLoop );
      57         [ #  # ]:          0 : }
      58                 :            : 
      59                 :          0 : void PartitionCoEdge::reverse_sense()
      60                 :            : {
      61                 :          0 :   mySense = mySense == CUBIT_FORWARD  ? CUBIT_REVERSED :
      62                 :          0 :             mySense == CUBIT_REVERSED ? CUBIT_FORWARD  :
      63 [ #  # ][ #  # ]:          0 :                                         CUBIT_UNKNOWN  ;
      64                 :          0 : } 
      65                 :            : 
      66                 :          0 : TopologyBridge* PartitionCoEdge::find_parent_loop() const
      67                 :            : {
      68 [ #  # ][ #  # ]:          0 :   if( get_loop() )
      69         [ #  # ]:          0 :     return get_loop();
      70                 :            :   
      71         [ #  # ]:          0 :   CoEdgeSM* coedge = real_coedge();
      72         [ #  # ]:          0 :   if( !coedge )
      73                 :          0 :     return 0;
      74                 :            :   
      75         [ #  # ]:          0 :   DLIList<TopologyBridge*> list;
      76         [ #  # ]:          0 :   coedge->get_parents_virt( list );
      77 [ #  # ][ #  # ]:          0 :   assert( list.size() == 1 );
      78 [ #  # ][ #  # ]:          0 :   return list.get();
      79                 :            : }
      80                 :            : 
      81                 :          0 : CoEdgeSM* PartitionCoEdge::real_coedge() const
      82                 :            : {
      83         [ #  # ]:          0 :   return dynamic_cast<CoEdgeSM*>(partitioned_entity());
      84                 :            :     // this will be null for coedges of segmented (split) curves.
      85                 :            : }
      86                 :            : 
      87                 :          0 : void PartitionCoEdge::get_children_virt( DLIList<TopologyBridge*>& list )
      88                 :            : {
      89         [ #  # ]:          0 :   assert( myCurve != NULL );
      90         [ #  # ]:          0 :   list.append( myCurve );
      91                 :          0 : }
      92                 :            : 
      93                 :            : 
      94                 :          0 : void PartitionCoEdge::get_parents_virt( DLIList<TopologyBridge*>& list )
      95                 :            : {
      96         [ #  # ]:          0 :   TopologyBridge* result = find_parent_loop();
      97         [ #  # ]:          0 :   assert( result != NULL );
      98         [ #  # ]:          0 :   list.append( result );
      99                 :          0 : }
     100                 :            : 
     101                 :            : 
     102                 :            :     
     103                 :          0 : void PartitionCoEdge::append_simple_attribute_virt( const CubitSimpleAttrib& )
     104                 :          0 :   { }
     105                 :          0 : void PartitionCoEdge::remove_simple_attribute_virt( const CubitSimpleAttrib& )
     106                 :          0 :   { }
     107                 :          0 : void PartitionCoEdge::remove_all_simple_attribute_virt()
     108                 :          0 :   { }
     109                 :          0 : CubitStatus PartitionCoEdge::get_simple_attribute( DLIList<CubitSimpleAttrib>& )
     110                 :          0 :   { return CUBIT_FAILURE; }
     111                 :          0 : CubitStatus PartitionCoEdge::get_simple_attribute(const CubitString& ,
     112                 :            :                                        DLIList<CubitSimpleAttrib>& )
     113                 :          0 :   { return CUBIT_FAILURE; }
     114                 :            : 
     115                 :            : 
     116                 :            : 
     117                 :          0 : GeometryQueryEngine* PartitionCoEdge::get_geometry_query_engine() const
     118                 :            : {
     119                 :          0 :   return VirtualQueryEngine::instance();
     120                 :            : }
     121                 :            : 
     122                 :          0 : PartitionPoint* PartitionCoEdge::start_point() const
     123                 :            : {
     124                 :          0 :   PartitionPoint* result = 0;
     125         [ #  # ]:          0 :   if( myCurve )
     126                 :            :   {
     127         [ #  # ]:          0 :     if( mySense == CUBIT_FORWARD )
     128                 :          0 :       result = myCurve->start_point();
     129         [ #  # ]:          0 :     else if( mySense == CUBIT_REVERSED )
     130                 :          0 :       result = myCurve->end_point();
     131                 :            :   }
     132                 :          0 :   return result;
     133                 :            : }
     134                 :            : 
     135                 :          0 : PartitionPoint* PartitionCoEdge::end_point() const
     136                 :            : {
     137                 :          0 :   PartitionPoint* result = 0;
     138         [ #  # ]:          0 :   if( myCurve )
     139                 :            :   {
     140         [ #  # ]:          0 :     if( mySense == CUBIT_FORWARD )
     141                 :          0 :       result = myCurve->end_point();
     142         [ #  # ]:          0 :     else if( mySense == CUBIT_REVERSED )
     143                 :          0 :       result = myCurve->start_point();
     144                 :            :   }
     145                 :          0 :   return result;
     146                 :            : }
     147                 :            : 
     148                 :          0 : void PartitionCoEdge::notify_split( FacetEntity*, FacetEntity* )
     149                 :          0 :   { assert(0); }
     150                 :            : 
     151                 :          0 : CubitBox PartitionCoEdge::bounding_box() const
     152 [ +  - ][ +  - ]:       6364 :   { return ((Curve*)get_curve())->bounding_box(); }
     153                 :            : 

Generated by: LCOV version 1.11