LCOV - code coverage report
Current view: top level - geom/cgm - RefEntityName.hpp (source / functions) Hit Total Coverage
Test: coverage_sk.info Lines: 11 12 91.7 %
Date: 2020-06-30 00:58:45 Functions: 8 9 88.9 %
Branches: 5 8 62.5 %

           Branch data     Line data    Source code
       1                 :            : //- Class: RefEntityName
       2                 :            : //-
       3                 :            : //- Description: This file maintains a map between a name and a
       4                 :            : //- refentity. Names must be unique, but a refentity may have 
       5                 :            : //- multiple names. This is a singleton class.
       6                 :            : //-
       7                 :            : //- Owner: Greg Sjaardema
       8                 :            : //- Checked by: 
       9                 :            : //- Version: $Id: 
      10                 :            : 
      11                 :            : #ifndef REFENTITYNAME_HPP
      12                 :            : #define REFENTITYNAME_HPP
      13                 :            : 
      14                 :            : #include "CGMGeomConfigure.h"
      15                 :            : #include "CubitDefines.h"
      16                 :            : #include <map>
      17                 :            : 
      18                 :            : template <class X> class DLIList;
      19                 :            : class CubitString;
      20                 :            : class RefEntity;
      21                 :            : 
      22                 :            : typedef std::multimap<RefEntity*, CubitString> RefEntityNameMap;
      23                 :            : typedef std::map<CubitString, RefEntity*> NameRefEntityMap;
      24                 :            : 
      25 [ +  - ][ +  - ]:        884 : struct RefEntityNameMaps
      26                 :            : {
      27                 :            :   RefEntityNameMap refMap;
      28                 :            :   NameRefEntityMap nameMap;
      29                 :            : };
      30                 :            : 
      31                 :            : class CUBIT_GEOM_EXPORT RefEntityName
      32                 :            : {
      33                 :            : 
      34                 :            : public:
      35                 :            : 
      36                 :            :   //Initialize all settings in this class
      37                 :            :   static void initialize_settings();
      38                 :            :   static RefEntityName *instance();
      39                 :            :   ~RefEntityName();
      40                 :            : 
      41                 :        322 :   static void delete_instance()
      42                 :            :   { 
      43         [ +  + ]:        322 :     if(instance_)
      44         [ +  - ]:        191 :       delete instance_;
      45                 :        322 :     instance_ = NULL;
      46                 :        322 :   }
      47                 :            : 
      48                 :            :   void       remove_refentity_name(RefEntity* entity,
      49                 :            :                                    const CubitString &name,
      50                 :            :                                    CubitBoolean update_attribs = CUBIT_TRUE);
      51                 :            :   //- Remove the this name from the map. All other names for this
      52                 :            :   //- RefEntity remain in the map
      53                 :            : 
      54                 :            :   void       remove_refentity_name(RefEntity *entity,
      55                 :            :                                    CubitBoolean update_attribs = CUBIT_TRUE);
      56                 :            :   //- Remove this RefEntity and all its names from the map.
      57                 :            : 
      58                 :            :   CubitStatus add_refentity_name(RefEntity *entity,
      59                 :            :                                  CubitString &name,
      60                 :            :                                  bool update_attribs = true,
      61                 :            :                                  bool check_name_validity = true);
      62                 :            :   //- Add the map between this RefEntity and the name.
      63                 :            :   //- If 'name' is invalid or duplicate, it is changed and
      64                 :            :   //- new name is returned.
      65                 :            :   //- Returns CUBIT_FAILURE if unsuccessful.
      66                 :            : 
      67                 :            :   CubitStatus add_refentity_name(RefEntity *entity,
      68                 :            :                                  DLIList<CubitString> &names,
      69                 :            :                                  bool update_attribs = true,
      70                 :            :                                  bool check_name_validity = true);
      71                 :            :     //- add multiple names to the name map for this entity
      72                 :            :   
      73                 :            :   int        get_refentity_name(const RefEntity *entity, DLIList<CubitString> &names);
      74                 :            :   //- Get the list of names corresponding to this RefEntity.
      75                 :            :   //- Returns the number of names found for this RefEntity.
      76                 :            : 
      77                 :            :   void       merge_refentity_names(RefEntity *retained,
      78                 :            :                                    RefEntity *dead);
      79                 :            :   //- Associates the names of the dead RefEntity with the retained
      80                 :            :   //- RefEntity.
      81                 :            : 
      82                 :            :   void       switch_refentity_names(RefEntity *entity1,
      83                 :            :                                     RefEntity *entity2);
      84                 :            :   //- Switch names of entity1 and entity2
      85                 :            : 
      86                 :            :   RefEntity* get_refentity(const CubitString &name);
      87                 :            :   //- Returns a pointer to the RefEntity with this name.
      88                 :            : 
      89                 :            :   void       list_refentity_names(const char *type = "all");
      90                 :            :   //- Prints an alphabetical list of all entity names in the map.
      91                 :            :   //- The argument is a filter on the list which restricts it to 
      92                 :            :   //- certain entity types (body, volume, surface, curve, vertex).
      93                 :            : 
      94                 :            :   const char*      get_refentity_type(const CubitString &name);
      95                 :            :   //- Returns a pointer to the string identifying the type of the
      96                 :            :   //- RefEntity with this name. (Body, Volume, ...)
      97                 :            : 
      98                 :            :   int        get_refentity_id(const CubitString &name);
      99                 :            :   //- Returns the id of the RefEntity with this name. 
     100                 :            : 
     101                 :            :   static int  get_generate_default_names();
     102                 :            :   static void set_generate_default_names(int on_off);
     103                 :            :   //- Specifies whether default RefEntity names should be generated (Surface1). 
     104                 :            : 
     105                 :            :   static int  get_fix_duplicate_names();
     106                 :            :   static void set_fix_duplicate_names(int on_off);
     107                 :            :   //- Specifies whether duplicate names should be fixed (made unique)
     108                 :            : 
     109                 :            :   void set_character(char rep, const CubitString &type);
     110                 :            :   char get_character(const CubitString &type) const;
     111                 :            : 
     112                 :            : 
     113                 :            :   static void set_suffix_setting(CubitString rep);
     114                 :            :   static CubitString get_suffix_setting();
     115                 :            :   static void set_replacement_setting(CubitString rep);
     116                 :            :   static CubitString get_replacement_setting();
     117                 :            :   
     118                 :            :   static CubitString base_name(const CubitString &name);
     119                 :            :   
     120                 :            :   CubitBoolean same_base_name(const CubitString &name1,
     121                 :            :                               const CubitString &name2);
     122                 :            :     //- return CUBIT_TRUE if the base name (i.e. the name before the suffixChar)
     123                 :            :     //- is the same
     124                 :            : 
     125                 :         80 :   static CubitBoolean get_merge_base_names() {return mergeBaseNames;};
     126                 :          0 :   static void set_merge_base_names(CubitBoolean flag) {mergeBaseNames = flag;};
     127                 :            :     //- get/set mergeBaseNames
     128                 :            :     
     129                 :            :   void copy_refentity_names( const RefEntity* source, 
     130                 :            :                              RefEntity* target,
     131                 :            :                              CubitBoolean update_attribs = CUBIT_TRUE );
     132                 :            :   void copy_refentity_names( DLIList<RefEntity*>& source_list,
     133                 :            :                              RefEntity* target,
     134                 :            :                              CubitBoolean unique_base_names = CUBIT_TRUE,
     135                 :            :                              CubitBoolean update_attribs = CUBIT_TRUE );
     136                 :            :     //- Copy names from one entity to another.
     137                 :            :     
     138                 :       1876 :   bool print_name_change_warnings() {return printNameChangeWarnings;}
     139                 :       1876 :   void print_name_change_warnings(bool new_val) {printNameChangeWarnings = new_val;}
     140                 :       1920 :   int num_name_change_warnings() {return numNameChangeWarnings;}
     141                 :        938 :   void num_name_change_warnings(int new_val) {numNameChangeWarnings = new_val;}
     142                 :            :   
     143                 :            : protected:
     144                 :            :   RefEntityName();
     145                 :            :   //- Class Constructor. (Not callable by user code. Class is constructed
     146                 :            :   //- by the {instance()} member function.
     147                 :            :   
     148                 :            : private:
     149                 :            :   CubitStatus clean(CubitString &raw_name);
     150                 :            :   //- replace invalid characters in {raw_name} with {replacementCharacter}
     151                 :            : 
     152                 :            :   CubitStatus generate_unique_name(CubitString &name);
     153                 :            : 
     154                 :            :   static RefEntityName *instance_;
     155                 :            :   //- static pointer to unique instance of this class
     156                 :            :   
     157                 :            :   RefEntityNameMaps nameEntityList;
     158                 :            : 
     159                 :            :   static int fixDuplicateNames;
     160                 :            :   static int generateDefaultNames;
     161                 :            :   static char replacementCharacter;
     162                 :            :   static char suffixCharacter;
     163                 :            :   static bool printNameChangeWarnings;
     164                 :            :   static int numNameChangeWarnings;
     165                 :            :  
     166                 :            :   static CubitBoolean mergeBaseNames;
     167                 :            :     //- if CUBIT_TRUE, when entity names are merged, names with duplicate
     168                 :            :     //- base names are removed
     169                 :            : };
     170                 :            : #endif
     171                 :            : 
     172                 :            : 

Generated by: LCOV version 1.11