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 / MGRNODEA.CPP < prev    next >
C/C++ Source or Header  |  1994-10-03  |  7KB  |  233 lines
  1.  
  2. /*
  3. * NIST STEP Editor Class Library
  4. * cleditor/mgrnodearray.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: mgrnodearray.cc,v 2.0.1.1 1994/04/05 16:42:36 sauderd Exp $ */ 
  14.  
  15. /*
  16.  * MgrNodeArray - dynamic array object of MgrNodes.
  17.  * the array part of this is copied from Unidraws UArray - dynamic array object
  18.  * Copyright (c) 1990 Stanford University
  19.  */
  20.  
  21. ///////////////////////////////////////////////////////////////////////////////
  22. //    debug_level >= 2 => tells when a command is chosen
  23. //    debug_level >= 3 => prints values within functions:
  24. //       e.g. 1) entity type list when read
  25. //        2) entity instance list when read
  26. ///////////////////////////////////////////////////////////////////////////////
  27. static int debug_level = 1;
  28.     // if debug_level is greater than this number then
  29.     // function names get printed out when executed
  30. static int PrintFunctionTrace = 2;
  31.     // if debug_level is greater than this number then
  32.     // values within functions get printed out
  33. //static int PrintValues = 3;
  34.  
  35. #include <mgrnodearray.h>
  36. #include <Sentity.h>
  37.  
  38. #include <string.h>    // to get bcopy() - ANSI
  39.  
  40.  
  41. //////////////////////////////////////////////////////////////////////////////
  42. // class MgrNodeArray member functions
  43. //////////////////////////////////////////////////////////////////////////////
  44.  
  45. void MgrNodeArray::AssignIndexAddress(int index)
  46. {
  47. //    if(debug_level >= PrintFunctionTrace)
  48. //    cout << "MgrNodeArray::AssignIndexAddress()\n";
  49.     ((MgrNode *)_buf[index])->ArrayIndex(index);
  50. }
  51.  
  52. MgrNodeArray::~MgrNodeArray()
  53. {
  54.     if(debug_level >= PrintFunctionTrace)
  55.     cout << "MgrNodeArray::~MgrNodeArray()\n";
  56.     DeleteEntries();
  57. }
  58.  
  59. /*****************************************************************************/
  60.  
  61. void MgrNodeArray::ClearEntries()
  62. {
  63.     if(debug_level >= PrintFunctionTrace)
  64.     cout << "MgrNodeArray::ClearEntries()\n";
  65.     int i;
  66.     for(i = 0 ; i < _count; i++)
  67.     _buf[i] = 0;
  68.     _count = 0;
  69. }
  70.  
  71. /*****************************************************************************/
  72.  
  73. void MgrNodeArray::DeleteEntries()
  74. {
  75.     if(debug_level >= PrintFunctionTrace)
  76.     cout << "MgrNodeArray::DeleteEntries()\n";
  77.     int i;
  78.     for(i = 0 ; i < _count; i++)
  79.     delete ((MgrNode *)_buf[i]);
  80.     _count = 0;
  81. }
  82.  
  83. /*****************************************************************************/
  84.  
  85. int MgrNodeArray::Insert(GenericNode* gn, int index)
  86. {
  87.     if(debug_level >= PrintFunctionTrace)
  88.     cout << "MgrNodeArray::Insert()\n";
  89.     int AssignedIndex = GenNodeArray::Insert(gn, index);
  90.     int i;
  91.     for(i = AssignedIndex ; i < _count; i++)
  92.     ((MgrNode *)_buf[i])->ArrayIndex(i);
  93.     return AssignedIndex;
  94. }
  95.  
  96. /*****************************************************************************/
  97.  
  98. void MgrNodeArray::Remove(int index) {
  99.     if(debug_level >= PrintFunctionTrace)
  100.     cout << "MgrNodeArray::Remove()\n";
  101.     if (0 <= index && index < _count) {
  102.     GenNodeArray::Remove(index);
  103.     int i;
  104.     for(i = index; i < _count; i++)
  105.         ((MgrNode *)_buf[i])->ArrayIndex(i);
  106.     }
  107. }
  108.  
  109. /*****************************************************************************/
  110.  
  111. int MgrNodeArray::MgrNodeIndex(int fileId)
  112. {
  113.     if(debug_level >= PrintFunctionTrace)
  114.     cout << "MgrNodeArray::MgrNodeIndex()\n";
  115.     register int i;
  116.     for (i = 0; i < _count; ++i) {
  117.         if( ((MgrNode *)_buf[i])->GetSTEPentity()->GetFileId() == fileId) {
  118.             return i;
  119.         }
  120.     }
  121.     return -1;
  122. }
  123.  
  124. //////////////////////////////////////////////////////////////////////////////
  125. // class MgrNodeArraySorted member functions
  126. //////////////////////////////////////////////////////////////////////////////
  127.  
  128. int MgrNodeArraySorted::Insert (GenericNode* gn) {
  129. //    if(debug_level >= PrintFunctionTrace)
  130. //    cout << "MgrNodeArraySorted::Insert()\n";
  131.  
  132.     // since gn is really a MgrNode
  133.     int fileId = ((MgrNode *)gn)->GetSTEPentity()->GetFileId();
  134.  
  135.     int index = FindInsertPosition(fileId);
  136.  
  137.     return GenNodeArray::Insert(gn, index);
  138. }
  139.  
  140. int MgrNodeArraySorted::Index (GenericNode* gn) {
  141. //    if(debug_level >= PrintFunctionTrace)
  142. //    cout << "MgrNodeArraySorted::Index()\n";
  143.     // since gn is really a MgrNode
  144.     return MgrNodeIndex(((MgrNode *)gn)->GetFileId());
  145. }
  146.  
  147. int MgrNodeArraySorted::Index (GenericNode** gn) {
  148. //    if(debug_level >= PrintFunctionTrace)
  149. //    cout << "MgrNodeArraySorted::Index()\n";
  150.     // since gn is really a MgrNode
  151.     return MgrNodeIndex(((MgrNode *)(*gn))->GetFileId());
  152. }
  153.  
  154. void MgrNodeArraySorted::ClearEntries()
  155. {
  156.     if(debug_level >= PrintFunctionTrace)
  157.     cout << "MgrNodeArraySorted::ClearEntries()\n";
  158.     int i;
  159.     for(i = 0 ; i < _count; i++)
  160.     _buf[i] = 0;
  161.     _count = 0;
  162. }
  163.  
  164. /*****************************************************************************/
  165.  
  166. void MgrNodeArraySorted::DeleteEntries()
  167. {
  168.     if(debug_level >= PrintFunctionTrace)
  169.     cout << "MgrNodeArraySorted::DeleteEntries()\n";
  170.     int i;
  171.     for(i = 0 ; i < _count; i++)
  172.     delete ((MgrNode *)_buf[i]);
  173.     _count = 0;
  174. }
  175.  
  176. /*****************************************************************************/
  177.  
  178.     // the reason this is written this way is because most of the
  179.     // time the file id will be higher than any seen so far and
  180.     // thus the insert position will be at the end
  181. int MgrNodeArraySorted::FindInsertPosition(const int fileId)
  182. {
  183.     if(debug_level >= PrintFunctionTrace)
  184.     cout << "MgrNodeArraySorted::FindInsertPosition()\n";
  185.     register int i;
  186.     int curFileId;
  187.  
  188.     for (i = _count-1; i >= 0; --i) {
  189.     curFileId = ((MgrNode *)_buf[i])->GetSTEPentity()->GetFileId();
  190.         if (curFileId < fileId /*|| curFileId == fileId*/)
  191.     {
  192.             return i + 1;
  193.         }
  194.     }
  195.     return 0;
  196. }
  197.  
  198. /*****************************************************************************/
  199.  
  200. int MgrNodeArraySorted::MgrNodeIndex(int fileId) {
  201. // this function assumes that _buf[0] to _buf[_count] ALL point to MgrNodes
  202. // that are sorted by fileId
  203.  
  204.     if(debug_level >= PrintFunctionTrace)
  205.     cout << "MgrNodeArraySorted::MgrNodeIndex()\n";
  206.     int low = 0;
  207.     int high = _count - 1;
  208.     int mid;
  209.     int found = 0;
  210.     int curFileId;
  211.  
  212.     while(!found && (low <= high))
  213.     {
  214.     mid = (low + high) / 2;
  215.     curFileId = ((MgrNode *)_buf[mid])->GetSTEPentity()->GetFileId();
  216.     if(curFileId == fileId)
  217.     {
  218.         found = 1;
  219.     }
  220.     else if(curFileId < fileId)
  221.     {
  222.         low = mid + 1;
  223.     }
  224.     else
  225.     {
  226.         high = mid - 1;
  227.     }
  228.     }
  229.     if(found)
  230.     return mid;
  231.     return -1;
  232. }
  233.