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 / REGISTRY.CPP < prev    next >
Text File  |  1994-08-06  |  5KB  |  196 lines
  1.  
  2. /*
  3. * NIST STEP Core Class Library
  4. * clstepcore/Registry.inline.cc
  5. * February, 1994
  6. * K. C. Morris
  7. * David Sauder
  8.  
  9. * Development of this software was funded by the United States Government,
  10. * and is not subject to copyright.
  11. */
  12.  
  13. /* $Id: Registry.inline.cc,v 2.0.1.2 1994/05/10 21:06:02 kc Exp $  */ 
  14.  
  15. #include <Registry.h>
  16.  
  17.  const TypeDescriptor *  t_INTEGER_TYPE;
  18.  const TypeDescriptor *  t_REAL_TYPE;
  19.  const TypeDescriptor *  t_NUMBER_TYPE;
  20.  const TypeDescriptor *  t_STRING_TYPE;
  21.  const TypeDescriptor *  t_BINARY_TYPE;
  22.  const TypeDescriptor *  t_BOOLEAN_TYPE;
  23.  const TypeDescriptor *  t_LOGICAL_TYPE;
  24.  
  25.  
  26. /* inline */ 
  27. Registry::Registry (CF_init initFunct) 
  28. : entity_cnt (0)
  29. { 
  30.     primordialSwamp = HASHcreate (1000);
  31.     active_schemas = HASHcreate (10);
  32.     active_types = HASHcreate (100);
  33.  
  34.     t_INTEGER_TYPE = new TypeDescriptor("INTEGER",     // Name
  35.                INTEGER_TYPE, // FundamentalType
  36.                "INTEGER");   // Description;
  37.  
  38.     t_REAL_TYPE = new TypeDescriptor("REAL", REAL_TYPE, "Real");
  39.  
  40.     t_STRING_TYPE = new TypeDescriptor("STRING", STRING_TYPE, "String");
  41.  
  42.     t_BINARY_TYPE = new TypeDescriptor("BINARY", BINARY_TYPE, "Binary");
  43.  
  44.     t_BOOLEAN_TYPE = new TypeDescriptor("BOOLEAN", BOOLEAN_TYPE, "Boolean");
  45.  
  46.     t_LOGICAL_TYPE = new TypeDescriptor("LOGICAL", LOGICAL_TYPE, "Logical");
  47.  
  48.     t_NUMBER_TYPE = new TypeDescriptor("NUMBER", NUMBER_TYPE, "Number");
  49.  
  50. /*    t_GENERIC_TYPE = new TypeDescriptor("GENERIC", GENERIC_TYPE, "Generic");*/
  51.  
  52.     initFunct (*this);  
  53.     HASHlistinit (primordialSwamp, &cur_entity);  // initialize cur\'s
  54.     HASHlistinit (active_schemas, &cur_schema);
  55. }
  56.  
  57. /* inline */ 
  58. Registry::~Registry  ()
  59. {
  60.     HASHdestroy (primordialSwamp);
  61.     HASHdestroy (active_schemas);
  62.     HASHdestroy (active_types);
  63. }
  64.  
  65. void 
  66. Registry::DeleteContents ()
  67. {
  68.   // entities first
  69.   HASHlistinit (primordialSwamp, &cur_entity);
  70.   while (HASHlist (&cur_entity))
  71.     delete (EntityDescriptor *) cur_entity.e->data;
  72.  
  73.   // schemas
  74.   HASHlistinit (active_schemas, &cur_schema);
  75.   while (HASHlist (&cur_schema))
  76.     delete (SchemaDescriptor *) cur_schema.e->data;
  77.  
  78.   // types 
  79.  
  80. }
  81.  
  82. /* inline */ const EntityDescriptor *
  83. Registry::FindEntity (const char * e, int check_case) const
  84. {
  85.     if (check_case) 
  86.     return
  87.         (const EntityDescriptor *) HASHfind (primordialSwamp, 
  88.                          (char *)PrettyTmpName (e));
  89.     else return (const EntityDescriptor *) HASHfind (primordialSwamp, (char *) e);
  90. }
  91.  
  92.  
  93. /* inline */ const SchemaDescriptor *
  94. Registry::FindSchema (const char * n, int check_case) const
  95. {
  96.     if (check_case) 
  97.        return (const SchemaDescriptor *) HASHfind (primordialSwamp, 
  98.                            (char *)PrettyTmpName (n));
  99.     return (const SchemaDescriptor *) HASHfind (active_schemas, (char *) n);
  100. }
  101.  
  102. /* inline */ const TypeDescriptor *
  103. Registry::FindType (const char * n, int check_case) const 
  104. {
  105.     if (check_case) 
  106.        return (const TypeDescriptor *) HASHfind (primordialSwamp, 
  107.                          (char *)PrettyTmpName (n));
  108.     return (const TypeDescriptor *) HASHfind (active_types, (char *) n);
  109. }
  110.     
  111. /* inline */ void     
  112. Registry::AddEntity (const EntityDescriptor& e)
  113. {
  114.     HASHinsert (primordialSwamp, (char *) e.Name (), (EntityDescriptor *) &e);
  115.     ++entity_cnt;
  116. }
  117.   
  118.  
  119. /* inline */ void    
  120. Registry::AddSchema (const SchemaDescriptor& d)
  121. {
  122.     HASHinsert (active_schemas, (char *) d.Name(), (SchemaDescriptor *) &d);
  123. }
  124.  
  125. /* inline */ void     
  126. Registry::AddType  (const TypeDescriptor& d)
  127. {
  128.     HASHinsert (active_types, (char *) d.Name(), (TypeDescriptor *) &d);
  129. }
  130.     
  131. /* inline */ void     
  132. Registry::RemoveEntity (const char * n)
  133. {
  134.     struct Element tmp;
  135.     tmp.key = (char *) n;
  136.     HASHsearch (primordialSwamp, &tmp, HASH_DELETE) ? --entity_cnt : 0;
  137.     
  138. }
  139.  
  140. /* inline */ void    
  141. Registry::RemoveSchema (const char * n)
  142. {
  143.     struct Element tmp;
  144.     tmp.key = (char *) n;
  145.     HASHsearch (active_schemas, &tmp, HASH_DELETE);
  146. }
  147.  
  148. /* inline */ void     
  149. Registry::RemoveType (const char * n)
  150. {
  151.     struct Element tmp;
  152.     tmp.key = (char *) n;
  153.     HASHsearch (active_types, &tmp, HASH_DELETE);
  154. }
  155.  
  156. /* inline */ STEPentity *
  157. Registry::ObjCreate (const char * nm, int check_case) const
  158. {    
  159.     const EntityDescriptor *  entd = FindEntity (nm, check_case);
  160.     if (entd) return ((EntityDescriptor *)entd) -> NewSTEPentity ();
  161.     else return ENTITY_NULL;
  162. }    
  163.  
  164. /* inline */ int
  165. Registry::GetEntityCnt ()  
  166. {
  167.     return entity_cnt;
  168. }
  169.  
  170. /* inline */ void
  171. Registry::ResetEntities ()  
  172. {
  173.     HASHlistinit (primordialSwamp, &cur_entity);
  174.     
  175. }
  176.  
  177. /* inline */ const EntityDescriptor *
  178. Registry::NextEntity () 
  179. {
  180.   if (0 == HASHlist (&cur_entity)) return 0;
  181.   return (const EntityDescriptor *) cur_entity.e->data;
  182. }    
  183.  
  184. /* inline */ void
  185. Registry::ResetSchemas ()  
  186. {
  187.     HASHlistinit (active_schemas, &cur_schema);
  188. }
  189.  
  190. /* inline */ const SchemaDescriptor *
  191. Registry::NextSchema () 
  192. {
  193.   if (0 == HASHlist (&cur_schema)) return 0;
  194.   return (const SchemaDescriptor *) cur_schema.e->data;
  195. }
  196.