LCOV - code coverage report
Current view: top level - geom - CAUniqueId.cpp (source / functions) Hit Total Coverage
Test: coverage_sk.info Lines: 50 66 75.8 %
Date: 2020-06-30 00:58:45 Functions: 9 11 81.8 %
Branches: 43 98 43.9 %

           Branch data     Line data    Source code
       1                 :            : //- Class:          CAUniqueId
       2                 :            : //- Owner:          Tim Tautges
       3                 :            : //- Description:    Cubit Attribute for unique ids
       4                 :            : //- Checked By:
       5                 :            : //- Version:
       6                 :            : 
       7                 :            : #include "CAUniqueId.hpp"
       8                 :            : #include "CubitSimpleAttrib.hpp"
       9                 :            : #include "RefEntity.hpp"
      10                 :            : #include "TDUniqueId.hpp"
      11                 :            : #include "GSaveOpen.hpp"
      12                 :            : #include "GeometryQueryTool.hpp"
      13                 :            : 
      14                 :       1635 : DLIList<CAUniqueId *> CAUniqueId::allCAUniqueIds;
      15                 :            : bool CAUniqueId::autoUniqueId = false;
      16                 :       1635 : UIDMap CAUniqueId::oldUIDToNewUID;
      17                 :            : 
      18                 :      10150 : CubitAttrib* CAUniqueId_creator(RefEntity* entity, const CubitSimpleAttrib &p_csa)
      19                 :            : {
      20         [ +  - ]:      10150 :   return new CAUniqueId(entity, p_csa);
      21                 :            : }
      22                 :            : 
      23                 :      30450 : CAUniqueId::~CAUniqueId()
      24                 :            : {
      25 [ +  - ][ +  - ]:      10150 :   if (allCAUniqueIds.move_to(this))
      26         [ +  - ]:      10150 :     allCAUniqueIds.extract();
      27         [ -  + ]:      20300 : }
      28                 :            : 
      29                 :      10150 : CAUniqueId::CAUniqueId(RefEntity* new_attrib_owner,
      30                 :            :                                const CubitSimpleAttrib &csa_ptr)
      31                 :      10150 :         : CubitAttrib(new_attrib_owner)
      32                 :            : {
      33                 :      10150 :   uniqueId = -1;
      34                 :            : 
      35 [ +  - ][ +  + ]:      10150 :   if(!csa_ptr.isEmpty())
      36                 :            :   {
      37 [ +  - ][ +  - ]:        558 :     uniqueId = csa_ptr.int_data_list()[0];
      38                 :            :   }
      39         [ +  - ]:      10150 :   allCAUniqueIds.append(this);
      40                 :      10150 : }
      41                 :            : 
      42                 :        558 : CubitStatus CAUniqueId::actuate()
      43                 :            : {
      44                 :            : 
      45         [ -  + ]:        558 :   if (hasActuated == CUBIT_TRUE) return CUBIT_SUCCESS;
      46                 :            : 
      47                 :            :     // create a TDUniqueId for the entity, if it doesn't already
      48                 :            :     // exist
      49                 :        558 :   TDUniqueId *uid = (TDUniqueId *) attrib_owner()->get_TD(&TDUniqueId::is_unique_id);
      50                 :            : 
      51         [ -  + ]:        558 :   if (uid != NULL) {
      52                 :            :       // check to make sure it's the same unique id
      53         [ #  # ]:          0 :     if (uid->unique_id() != uniqueId) {
      54         [ #  # ]:          0 :       PRINT_ERROR("Different unique id found for %s %d.\n",
      55         [ #  # ]:          0 :                   attrib_owner()->class_name(), attrib_owner()->id());
      56                 :          0 :       return CUBIT_FAILURE;
      57                 :            :     }
      58                 :            :   }
      59                 :            :   else 
      60                 :            :   {
      61 [ +  - ][ +  - ]:        558 :     if( !GSaveOpen::performingUndo && 
      62         [ +  - ]:        558 :          GeometryQueryTool::importingSolidModel &&
      63                 :        558 :         !GeometryQueryTool::mergeGloballyOnImport)
      64                 :            :     {
      65                 :            :       //Is there an entity that already has this id?
      66                 :        558 :       ToolDataUser *tdu = TDUniqueId::find_td_unique_id(uniqueId);
      67         [ +  + ]:        558 :       if( tdu )
      68                 :            :       {
      69                 :            :         //is it already in the map
      70         [ +  - ]:        198 :         UIDMap::iterator iter;
      71         [ +  - ]:        198 :         iter = oldUIDToNewUID.find( uniqueId );
      72                 :            :         
      73 [ +  - ][ +  - ]:        198 :         if( iter != oldUIDToNewUID.end() )
                 [ -  + ]
      74         [ #  # ]:          0 :           uniqueId = (*iter).second;
      75                 :            :         else
      76                 :            :         {
      77         [ +  - ]:        198 :           int new_unique_id = TDUniqueId::generate_unique_id();
      78         [ +  - ]:        198 :           UIDMap::value_type this_pair(uniqueId, new_unique_id);
      79         [ +  - ]:        198 :           oldUIDToNewUID.insert(this_pair);
      80                 :        558 :           uniqueId = new_unique_id;
      81                 :            :         }
      82                 :            :       }
      83                 :            :     }
      84                 :            : 
      85                 :            :       // else make a new one
      86 [ +  - ][ +  - ]:        558 :     uid = new TDUniqueId(attrib_owner(), uniqueId);
      87                 :            :   }
      88                 :            :   
      89                 :        558 :   delete_attrib(CUBIT_TRUE);
      90                 :        558 :   hasActuated = CUBIT_TRUE;
      91                 :            :   
      92                 :        558 :   return CUBIT_SUCCESS;
      93                 :            : }
      94                 :            : 
      95                 :      10150 : CubitStatus CAUniqueId::update()
      96                 :            : {
      97         [ -  + ]:      10150 :   if (hasUpdated) return CUBIT_SUCCESS;
      98                 :            :   
      99                 :            :     // set the updated flag
     100                 :      10150 :   hasUpdated = CUBIT_TRUE;
     101                 :            : 
     102                 :            :     // if the owner has a unique id, save it, otherwise delete this one
     103                 :      10150 :   TDUniqueId *td_uid = (TDUniqueId *) attrib_owner()->get_TD(&TDUniqueId::is_unique_id);
     104                 :            : 
     105 [ +  + ][ -  + ]:      10150 :   if (NULL == td_uid && autoUniqueId) 
     106 [ #  # ][ #  # ]:          0 :     td_uid = new TDUniqueId(attrib_owner());
     107                 :            : 
     108         [ +  + ]:      10150 :   if (td_uid == NULL) {
     109                 :       8836 :     delete_attrib(CUBIT_TRUE);
     110                 :            :   }
     111                 :            : 
     112                 :            :   else {
     113                 :       1314 :     uniqueId = td_uid->unique_id();
     114         [ -  + ]:       1314 :     if (delete_attrib() == CUBIT_TRUE) delete_attrib(CUBIT_FALSE);
     115                 :            :   }
     116                 :            :   
     117                 :      10150 :   return CUBIT_SUCCESS;
     118                 :            : }
     119                 :            : 
     120                 :      11662 : CubitSimpleAttrib CAUniqueId::cubit_simple_attrib()
     121                 :            : {
     122                 :            :   return CubitSimpleAttrib(att_internal_name(), "", "",
     123 [ +  - ][ +  - ]:      11662 :                                &uniqueId);
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
     124                 :            : }
     125                 :            : 
     126                 :          0 : CubitStatus CAUniqueId::actuate_all()
     127                 :            : {
     128                 :            :     //- actuate all the CAUI's on the list, then empty the list
     129         [ #  # ]:          0 :   for (int i = allCAUniqueIds.size(); i > 0; i--) {
     130                 :          0 :     CAUniqueId *cauid = allCAUniqueIds.get();
     131         [ #  # ]:          0 :     if (cauid->actuate() == CUBIT_SUCCESS) allCAUniqueIds.extract();
     132                 :          0 :     else allCAUniqueIds.step();
     133                 :            :   }
     134                 :            :   
     135                 :          0 :   return CUBIT_SUCCESS;
     136                 :            : }
     137                 :            : 
     138                 :          0 : void CAUniqueId::print()
     139                 :            : {
     140                 :            :     // print info on this attribute
     141                 :            :   
     142         [ #  # ]:          0 :   PRINT_INFO("CAUniqueId: owner = %s %d: uid=%d\n",
     143                 :            :              attribOwnerEntity->class_name(), attribOwnerEntity->id(),
     144         [ #  # ]:          0 :              uniqueId);
     145                 :          0 : }
     146                 :            : 
     147                 :        938 : void CAUniqueId::clear_out_old_to_new_map()
     148                 :            : {
     149                 :        938 :   oldUIDToNewUID.clear(); 
     150 [ +  - ][ +  - ]:       6540 : }
     151                 :            : 

Generated by: LCOV version 1.11