home *** CD-ROM | disk | FTP | other *** search
/ ftptest.leeds.ac.uk / 2015.02.ftptest.leeds.ac.uk.tar / ftptest.leeds.ac.uk / bionet / CAE-GROUP / SCL-WIN3x / SCL.EXE / INSTMGR.CPP < prev    next >
C/C++ Source or Header  |  1994-10-03  |  10KB  |  352 lines
  1.  
  2. /*
  3. * NIST STEP Editor Class Library
  4. * cleditor/instmgr.cc
  5. * February, 1994
  6. * David Sauder
  7. * K. C. Morris
  8.  
  9. * Development of this software was funded by the United States Government,
  10. * and is not subject to copyright.
  11. */
  12.  
  13. /* $Id: instmgr.cc,v 2.0.1.1 1994/04/05 16:42:31 sauderd Exp $ */ 
  14.  
  15. //////////////////////////////////////////////////////////////////////////////
  16. //
  17. // InstMgr member functions
  18. //
  19. //////////////////////////////////////////////////////////////////////////////
  20.  
  21. #include <Sentity.h>
  22. #include <instmgr.h>
  23.  
  24. ///////////////////////////////////////////////////////////////////////////////
  25. //    debug_level >= 2 => tells when a command is chosen
  26. //    debug_level >= 3 => prints values within functions:
  27. ///////////////////////////////////////////////////////////////////////////////
  28. static int debug_level = 2;
  29.     // if debug_level is greater than this number then
  30.     // function names get printed out when executed
  31. //static int PrintFunctionTrace = 2;
  32.     // if debug_level is greater than this number then
  33.     // values within functions get printed out
  34. //static int PrintValues = 3;
  35.  
  36.  
  37. ///////////////////////////////////////////////////////////////////////////////
  38.  
  39. InstMgr::InstMgr()
  40. {
  41.     maxFileId = -1;
  42.  
  43.     master = new MgrNodeArray();
  44.     sortedMaster = new MgrNodeArraySorted();
  45. }
  46.  
  47. ///////////////////////////////////////////////////////////////////////////////
  48.  
  49. void InstMgr::ClearInstances()
  50. {
  51. //    delete master;
  52. //    master = new MgrNodeArray();
  53.     master->DeleteEntries();
  54.     sortedMaster->ClearEntries();
  55.     maxFileId = -1;
  56. }
  57.  
  58. ///////////////////////////////////////////////////////////////////////////////
  59.  
  60. /**************************************************
  61.  description:
  62.  returns:
  63.     SEVERITY_NULL:        if all instances are complete
  64.     SEVERITY_INCOMPLETE:  if at least one instance is missing a required attribute
  65.     SEVERITY_WARNING:     
  66.     SEVERITY_INPUT_ERROR: if at least one instance can not be fetched
  67.                           from the instance list.
  68. **************************************************/
  69.  
  70. enum Severity
  71. InstMgr::VerifyInstances(ErrorDescriptor& err) 
  72. {
  73.     int errorCount = 0;
  74.     char errbuf[BUFSIZ];
  75.     
  76.     int n = InstanceCount();
  77.     MgrNode* mn;
  78.     STEPentity* se;
  79.     enum Severity rval = SEVERITY_NULL;
  80.     
  81.     //for each instance on the list,
  82.     //check the MgrNode state.
  83.     //if the state is complete then do nothing
  84.     //if the state is not complete,
  85.     //   then check if it is valid
  86.     //   if it is valid then increment the warning count,
  87.     //      and set the rval to SEVERITY_INCOMPLETE
  88.     //   if it is not valid, then increment the error count 
  89.     //      and set the rval to 
  90.  
  91.     for (register int i = 0; i < n; ++i) 
  92.     {
  93.     mn = GetMgrNode(i);
  94.     if (!mn) 
  95.     {
  96.         ++errorCount;
  97.         if (errorCount == 1) 
  98.         sprintf(errbuf,
  99.         "VerifyInstances: Unable to verify the following instances: node %d", 
  100.             i);
  101.         else
  102.         sprintf(errbuf,", node %d",i);
  103.  
  104.         err.AppendToDetailMsg(errbuf);
  105.         rval = SEVERITY_INPUT_ERROR;
  106.         err.GreaterSeverity(SEVERITY_INPUT_ERROR);
  107.         continue;
  108.     }
  109.     if (!mn->MgrNodeListMember(completeSE)) 
  110.     {
  111.         se = mn->GetSTEPentity();
  112.         if (se->ValidLevel(&err,this,0) < SEVERITY_USERMSG)
  113.         {
  114.         if (rval > SEVERITY_INCOMPLETE) 
  115.             rval = SEVERITY_INCOMPLETE;
  116.         ++errorCount;
  117.         if (errorCount == 1)
  118.             sprintf(errbuf,
  119.                 "VerifyInstances: Unable to verify the following instances: #%d",
  120.                 se->FileId());
  121.         else 
  122.             sprintf(errbuf,", #%d",se->FileId());
  123.         err.AppendToDetailMsg(errbuf);
  124.         }
  125.     }
  126.     }
  127.     if (errorCount) 
  128.     {
  129.     sprintf(errbuf,
  130.         "VerifyInstances: %d invalid instances in list.\n", 
  131.         errorCount);
  132.     err.AppendToUserMsg(errbuf);
  133.     err.AppendToDetailMsg(".\n");
  134.     err.GreaterSeverity(SEVERITY_INCOMPLETE);
  135.     }
  136.  
  137.     return rval;
  138. }
  139.  
  140. ///////////////////////////////////////////////////////////////////////////////
  141.  
  142. MgrNode *InstMgr::FindFileId(int fileId)
  143. {
  144.     int index = sortedMaster->MgrNodeIndex(fileId);
  145.     if(index >= 0)
  146.     return (MgrNode *)(*sortedMaster)[index];
  147.     else
  148.     return (MgrNode *)0;
  149. }
  150.  
  151. ///////////////////////////////////////////////////////////////////////////////
  152.  
  153.     // get the index into display list given a STEPentity
  154.     //  called by see initiated functions
  155. int InstMgr::GetIndex(MgrNode *mn)
  156. {
  157.     return mn->ArrayIndex();
  158. }
  159.  
  160. ///////////////////////////////////////////////////////////////////////////////
  161.  
  162. int InstMgr::GetIndex(STEPentity *se)
  163. {
  164.     int fileId = se->FileId();
  165.     return sortedMaster->MgrNodeIndex(fileId);
  166. }
  167.  
  168. ///////////////////////////////////////////////////////////////////////////////
  169.  
  170. int InstMgr::VerifyEntity(int fileId, const char *expectedType)
  171. {
  172.     MgrNode *mn = FindFileId(fileId);
  173.     if(mn) 
  174.     {
  175.     if(!strcmp(expectedType, mn->GetSTEPentity()->EntityName()))
  176.         return 2;    // types match
  177.     else
  178.         return 1;    // possible mismatch depending on descendants
  179.     }
  180.     else
  181.     return 0;
  182. }
  183.  
  184. ///////////////////////////////////////////////////////////////////////////////
  185. //   Append instance to the list of instances.  Checks the file id and 
  186. //   sets it if 1) it is not set already or 2) it already exists in the list.
  187.  
  188. MgrNode *InstMgr::Append(STEPentity *se, stateEnum listState)
  189. {
  190.     if (debug_level > 3)
  191.     cout << "#" << se->FileId() << " append node to InstMgr\n";
  192.  
  193.     if ((se  -> FileId () == 0)  // no id assigned
  194.     || FindFileId (se -> FileId ())) // id already in list
  195.       se -> FileId ( NextFileId () );
  196.     else if (se->FileId() > MaxFileId()) maxFileId = se->FileId();
  197.  
  198.     MgrNode *mn = new MgrNode(se, listState);
  199.     if(listState == noStateSE)
  200.     cout << "append to InstMgr **ERROR ** node #" << se->FileId() << 
  201.         " doesn't have state information\n";
  202.     master->Append(mn);
  203.     sortedMaster->Insert(mn);
  204.     return mn;
  205. }
  206.  
  207. ///////////////////////////////////////////////////////////////////////////////
  208.  
  209. void InstMgr::Delete(MgrNode *node)
  210. {
  211.     // delete the node from its current state list
  212.     node->Remove();
  213.  
  214.     int index;    
  215.  
  216.     // get the index of the node in the sorted master array
  217.     index = sortedMaster->MgrNodeIndex(node->GetFileId());
  218.     // remove the node from the sorted master array
  219.     sortedMaster->Remove(index);
  220.  
  221.     // get the index into the master array by ptr arithmetic
  222.     index = node->ArrayIndex();
  223.     master->Remove(index);
  224.  
  225.     delete node;
  226. }
  227.  
  228. ///////////////////////////////////////////////////////////////////////////////
  229.  
  230. void InstMgr::Delete(STEPentity *se)
  231. {
  232.    Delete (FindFileId (se->FileId()));
  233. }
  234.  
  235. ///////////////////////////////////////////////////////////////////////////////
  236.  
  237. void InstMgr::ChangeState(MgrNode *node, stateEnum listState)
  238. {
  239.     switch(listState){
  240.     case completeSE:
  241.         if (debug_level > 3)
  242.             cout << "#" << node->GetSTEPentity()->FileId() << 
  243.             " change node to InstMgr's complete list\n";
  244.         node->ChangeState(listState);
  245.         break;
  246.     case incompleteSE:
  247.         if (debug_level > 3)
  248.             cout << "#" << node->GetSTEPentity()->FileId() << 
  249.             " change node to InstMgr's incomplete list\n";
  250.         node->ChangeState(listState);
  251.         break;
  252.     case newSE:
  253.         if (debug_level > 3)
  254.             cout << "#" << node->GetSTEPentity()->FileId() << 
  255.             " change node to InstMgr's new list\n";
  256.         node->ChangeState(listState);
  257.         break;
  258.     case deleteSE:
  259.         if (debug_level > 3)
  260.             cout << "#" << node->GetSTEPentity()->FileId() << 
  261.             " change node to InstMgr's delete list\n";
  262.         node->ChangeState(listState);
  263.         break;
  264.     case noStateSE:
  265.         cout << "#" << node->GetSTEPentity()->FileId() << 
  266.         "ERROR can't change this node state\n";
  267.         node->Remove();
  268.         break;
  269.     }
  270. }
  271.  
  272. ///////////////////////////////////////////////////////////////////////////////
  273.  
  274. /**************************************************
  275.  description:
  276.     This function returns an integer value indicating
  277.     the number of instances with the given name appearing
  278.     on the instance manager.
  279. **************************************************/
  280. int 
  281. InstMgr::EntityKeywordCount(const char* name) 
  282. {
  283.     int count = 0;
  284.     MgrNode* node;
  285.     STEPentity* se;
  286.     int n = InstanceCount();
  287.     for (register int j = 0; j<n; ++j) 
  288.       {
  289.       node = GetMgrNode(j);
  290.       se = node->GetSTEPentity();
  291.       if (!strcmp(se->EntityName(),
  292.               PrettyTmpName(name)))
  293.           ++count;
  294.       }
  295.     return count;
  296. }
  297.  
  298. ///////////////////////////////////////////////////////////////////////////////
  299.  
  300. STEPentity *
  301. InstMgr::GetSTEPentity(int index)
  302. {
  303.     MgrNode *mn = (MgrNode*)(*master)[index];
  304.     if(mn)
  305.     return mn->GetSTEPentity(); 
  306.     else
  307.     return 0;
  308. }
  309.  
  310. ///////////////////////////////////////////////////////////////////////////////
  311.  
  312. /**************************************************
  313.  description:
  314.     This function returns the first entity (by index)
  315.     on the instance manager, which has the given
  316.     entity name. It starts its search at starting_index,
  317.     and returns ENTITY_NULL if a match does not occur 
  318.     before the last index is reached. This function 
  319.     does not wrap around to search indices before the
  320.     starting_index.
  321. **************************************************/
  322. STEPentity*
  323. InstMgr::GetSTEPentity(const char* entityKeyword, int starting_index) 
  324. {
  325.     MgrNode *node;
  326.     STEPentity *se;
  327.     
  328.     int count = InstanceCount();
  329.     for (register int j = starting_index; j<count; ++j) 
  330.       {
  331.       node=GetMgrNode(j);
  332.       se = node->GetSTEPentity();
  333.       if (!strcmp(se->EntityName(),PrettyTmpName(entityKeyword)))
  334.       {
  335.       return se;
  336.        }
  337.       }
  338.     return ENTITY_NULL;
  339. }
  340.  
  341. ///////////////////////////////////////////////////////////////////////////////
  342.  
  343. void *
  344. InstMgr::GetSEE(int index)
  345. {
  346.     MgrNode *mn = (MgrNode*)(*master)[index];
  347.     if(mn)
  348.     return mn->SEE(); 
  349.     else
  350.     return 0;
  351. }
  352.