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 / EXPDICT.CPP < prev    next >
C/C++ Source or Header  |  1994-08-06  |  16KB  |  615 lines
  1.  
  2. /*
  3. * NIST STEP Core Class Library
  4. * clstepcore/ExpDict.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: ExpDict.cc,v 2.0.1.4 1994/04/05 16:39:11 sauderd Exp $  */ 
  14.  
  15. #include <ExpDict.h> 
  16. #include <aggregat.h> 
  17.  
  18. /*
  19. const TypeDescriptor * const t_INTEGER_TYPE = & TypeDescriptor
  20.                        ("INTEGER",     // Name
  21.                INTEGER_TYPE, // FundamentalType
  22.                "INTEGER");   // Description
  23. extern const TypeDescriptor _t_INTEGER_TYPE
  24.                        ("INTEGER",     // Name
  25.                INTEGER_TYPE, // FundamentalType
  26.                "INTEGER");   // Description
  27.                */
  28. /*const TypeDescriptor * const t_INTEGER_TYPE = &_t_INTEGER_TYPE;*/
  29.  
  30. /*extern const TypeDescriptor _t_REAL_TYPE ("REAL", REAL_TYPE, "Real");*/
  31. /*const TypeDescriptor * const t_REAL_TYPE = &_t_REAL_TYPE;*/
  32.  
  33. /*extern const TypeDescriptor _t_STRING_TYPE ("STRING", STRING_TYPE, "String");*/
  34. /*const TypeDescriptor * const t_STRING_TYPE = &_t_STRING_TYPE;*/
  35.  
  36. /*extern const TypeDescriptor _t_BINARY_TYPE ("BINARY", BINARY_TYPE, "Binary") ;*/
  37. /*const TypeDescriptor * const t_BINARY_TYPE = &_t_BINARY_TYPE;*/
  38.  
  39. /*extern const TypeDescriptor _t_BOOLEAN_TYPE ("BOOLEAN", BOOLEAN_TYPE, "Boolean") ;*/
  40. /*const TypeDescriptor * const t_BOOLEAN_TYPE = &_t_BOOLEAN_TYPE;*/
  41.  
  42. /*extern const TypeDescriptor _t_LOGICAL_TYPE ("LOGICAL", LOGICAL_TYPE, "Logical") ;*/
  43. /*const TypeDescriptor * const t_LOGICAL_TYPE = &_t_LOGICAL_TYPE;*/
  44.  
  45. /*extern const TypeDescriptor _t_NUMBER_TYPE ("NUMBER", NUMBER_TYPE, "Number") ;*/
  46. /*const TypeDescriptor * const t_NUMBER_TYPE = &_t_NUMBER_TYPE;*/
  47.  
  48. /*extern const TypeDescriptor _t_GENERIC_TYPE ("GENERIC", GENERIC_TYPE, "Generic") ;*/
  49. /*const TypeDescriptor * const t_GENERIC_TYPE = &_t_GENERIC_TYPE;*/
  50.  
  51.  
  52. const EntityDescriptor * 
  53. EntityDescItr::NextEntityDesc()
  54. {
  55.     if(cur)
  56.     {
  57.     const EntityDescriptor *ed = cur->EntityDesc();
  58.     cur = (EntityDescLinkNode *)( cur->NextNode() );
  59.     return ed;
  60.     }
  61.     return 0;
  62. } 
  63.  
  64. const AttrDescriptor * 
  65. AttrDescItr::NextAttrDesc()
  66. {
  67.     if(cur)
  68.     {
  69.     const AttrDescriptor *ad = cur->AttrDesc();
  70.     cur = (AttrDescLinkNode *)( cur->NextNode() );
  71.     return ad;
  72.     }
  73.     return 0;
  74. } 
  75.  
  76. const InverseAttrDescriptor * 
  77. InverseADItr::NextInverseAttrDesc()
  78. {
  79.     if(cur)
  80.     {
  81.     const InverseAttrDescriptor *iad = cur->InverseAttrDesc();
  82.     cur = (InverseAttrDescLinkNode *)( cur->NextNode() );
  83.     return iad;
  84.     }
  85.     return 0;
  86. } 
  87.  
  88. const TypeDescriptor * 
  89. TypeDescItr::NextTypeDesc()
  90. {
  91.     if(cur)
  92.     {
  93.     const TypeDescriptor *td = cur->TypeDesc();
  94.     cur = (TypeDescLinkNode *)( cur->NextNode() );
  95.     return td;
  96.     }
  97.     return 0;
  98. } 
  99.  
  100. ///////////////////////////////////////////////////////////////////////////////
  101. // AttrDescriptor functions
  102. ///////////////////////////////////////////////////////////////////////////////
  103.  
  104. const char *
  105. AttrDescriptor::AttrExprDefStr(SCLstring & s) const
  106. {
  107.   s = Name ();
  108.   s.Append (" : ");
  109.   if(_optional.asInt() == T)
  110.     s.Append( "OPTIONAL ");
  111.   if(DomainType())
  112.     s.Append (DomainType()->AttrTypeName());
  113.   return s.chars();
  114. }    
  115.  
  116. const BASE_TYPE 
  117. AttrDescriptor::BaseType() const
  118. {
  119.     if(_domainType)
  120.     return _domainType->BaseType();
  121.     return UNKNOWN_TYPE;
  122. }
  123.  
  124. const BASE_TYPE 
  125. AttrDescriptor::AggrElemType() const
  126. {
  127.     if(NonRefType() == AGGREGATE_TYPE)
  128.     {
  129.     return ReferentType()->AggrElemType();
  130.     }
  131.     return UNKNOWN_TYPE;
  132. }
  133.  
  134. const TypeDescriptor *
  135. AttrDescriptor::AggrElemTypeDescriptor() const
  136. {
  137.     if(NonRefType() == AGGREGATE_TYPE)
  138.     {
  139.     return ReferentType()->AggrElemTypeDescriptor();
  140.     }
  141.     return 0;
  142. }
  143.  
  144. const TypeDescriptor * 
  145. AttrDescriptor::NonRefTypeDescriptor() const
  146. {
  147.     if(_domainType)
  148.     return _domainType->NonRefTypeDescriptor();
  149.     return 0;
  150. }
  151.  
  152. const BASE_TYPE 
  153. AttrDescriptor::NonRefType() const
  154. {
  155.     if(_domainType)
  156.     return _domainType->NonRefType();
  157.     return UNKNOWN_TYPE;
  158. }
  159.  
  160. const BASE_TYPE 
  161. AttrDescriptor::Type() const
  162. {
  163.     if(_domainType)
  164.     return _domainType->Type();
  165.     return UNKNOWN_TYPE;
  166. }
  167.  
  168.     // right side of attr def
  169. // NOTE this returns a \'const char * \' instead of an SCLstring
  170. const char *
  171. AttrDescriptor::TypeName() const
  172. {
  173.     if(_domainType)
  174.     return _domainType->AttrTypeName();
  175.     else
  176.     return "";
  177. }
  178.  
  179.     // an expanded right side of attr def
  180. const char *
  181. AttrDescriptor::ExpandedTypeName(SCLstring & s) const
  182. {
  183.     s.set_null();
  184.     if ((LOGICAL) Derived () == sdaiTRUE) s = "DERIVE  ";
  185.     if(_domainType)
  186.     {
  187.     SCLstring tmp;
  188.     return s.Append (_domainType->TypeString(tmp));
  189.     }
  190.     else
  191.     return 0;
  192. }
  193.  
  194. ///////////////////////////////////////////////////////////////////////////////
  195. // InverseAttrDescriptor functions
  196. ///////////////////////////////////////////////////////////////////////////////
  197.  
  198.  
  199. ///////////////////////////////////////////////////////////////////////////////
  200. // EntityDescriptor functions
  201. ///////////////////////////////////////////////////////////////////////////////
  202.  
  203. EntityDescriptor::EntityDescriptor ( ) : _abstractEntity("U")
  204. {
  205.     _originatingSchema = 0;
  206. //    _derivedAttr = new StringAggregate;
  207. /*
  208.     _subtypes = 0;
  209.     _supertypes = 0;
  210.     _explicitAttr = 0;
  211.     _inverseAttr = 0;
  212. */
  213. }
  214.  
  215. EntityDescriptor::EntityDescriptor (const char * name, // i.e. char *
  216.                     SchemaDescriptor *origSchema, 
  217.                     LOGICAL abstractEntity, // F U or T
  218.                     Creator f
  219. /*
  220.                     EntityDescriptorList *subtypes,
  221.                     EntityDescriptorList *supertypes,
  222.                     AttrDescriptorList *explicitAttr,
  223.                     StringAggregate *derivedAttr,
  224.                     InverseAttrDescriptorList *inverseAttr
  225. */
  226.                     ) 
  227. : TypeDescriptor (name, ENTITY_TYPE, name), _originatingSchema (origSchema),  
  228.   _abstractEntity(abstractEntity), NewSTEPentity(f)
  229. {
  230. /*
  231.     _subtypes = subtypes;
  232.     _supertypes = supertypes;
  233.     _explicitAttr = explicitAttr;
  234.     _derivedAttr = derivedAttr;
  235.     _inverseAttr = inverseAttr;
  236. */
  237. }
  238.  
  239. EntityDescriptor::~EntityDescriptor ()  
  240. {
  241. }
  242.  
  243. const TypeDescriptor * 
  244. EntityDescriptor::IsA (const TypeDescriptor * td) const 
  245. { if (td -> NonRefType () == ENTITY_TYPE)
  246.     return IsA ((EntityDescriptor *) td);
  247.   else return 0;
  248. }
  249.  
  250. const EntityDescriptor * 
  251. EntityDescriptor::IsA (const EntityDescriptor * other)  const {
  252.   const EntityDescriptor * found =0;
  253.   const EntityDescLinkNode * link = (const EntityDescLinkNode *) (GetSupertypes ().GetHead());
  254.  
  255.   if (this == other) return other;
  256.   else {
  257.     while (link && ! found)  {
  258.       found = link -> EntityDesc() -> IsA (other);
  259.       link = (EntityDescLinkNode *) link -> NextNode ();
  260.     }
  261.   }
  262.   return found;
  263. }
  264. /*
  265. EntityDescriptor::FindLongestAttribute()
  266. {
  267.     AttrDescLinkNode *attrPtr = 
  268.           (AttrDescLinkNode *)(ed->ExplicitAttr().GetHead());
  269.     while( attrPtr != 0)
  270.     {
  271.     if(attrPtr->AttrDesc()->IsEntityType())
  272.         maxAttrLen = max(maxAttrLen, 
  273.             (strlen(attrPtr->AttrDesc()->EntityType()->Name()) +
  274.               strlen(attrPtr->AttrDesc()->Name()) + 3
  275.              )
  276.             );
  277.     else
  278.         maxAttrLen = max(maxAttrLen, 
  279.           (strlen(attrPtr->AttrDesc()->DomainType()->NameOrDescription()) +
  280.            strlen(attrPtr->AttrDesc()->Name()) + 3
  281.           )
  282.             );
  283.     attrPtr = (AttrDescLinkNode *)attrPtr->NextNode();
  284.     }
  285. }
  286. */
  287. ///////////////////////////////////////////////////////////////////////////////
  288. // TypeDescriptor functions
  289. ///////////////////////////////////////////////////////////////////////////////
  290.  
  291.     ///////////////////////////////////////////////////////////////////////
  292.     // This is a fully expanded description of the type.
  293.     // This returns a string like the _description member variable
  294.     // except it is more thorough of a description where possible
  295.     // e.g. if the description contains a TYPE name it will also
  296.     // be explained.
  297.     ///////////////////////////////////////////////////////////////////////
  298. const char *
  299. TypeDescriptor::TypeString(SCLstring & s) const
  300. {
  301.     switch(Type())
  302.     {
  303.       case REFERENCE_TYPE:
  304.         if(Name())
  305.         {
  306.           s.Append ( "TYPE ");
  307.           s.Append (Name());
  308.           s.Append ( " = ");
  309.         }
  310.         if(Description())
  311.           s.Append ( Description ());
  312.         if(ReferentType())
  313.         {
  314.           s.Append ( " -- ");
  315.           SCLstring tmp;
  316.           s.Append ( ReferentType()->TypeString(tmp));
  317.         }
  318.         return s;
  319.  
  320.       case INTEGER_TYPE:
  321.         s.set_null();
  322.         if(_referentType != 0)
  323.         {
  324.             s = "TYPE ";
  325.             s.Append (Name());
  326.             s.Append ( " = ");
  327.         }
  328.         s.Append("Integer");
  329.         break;
  330.  
  331.       case STRING_TYPE:
  332.         s.set_null();
  333.         if(_referentType != 0)
  334.         {
  335.             s = "TYPE ";
  336.             s.Append (Name());
  337.             s.Append ( " = ");
  338.         }
  339.         s.Append("String");
  340.         break;
  341.  
  342.       case REAL_TYPE:
  343.         s.set_null();
  344.         if(_referentType != 0)
  345.         {
  346.             s = "TYPE ";
  347.             s.Append (Name());
  348.             s.Append ( " = ");
  349.         }
  350.         s.Append("Real");
  351.         break;
  352.  
  353.       case ENUM_TYPE:
  354.         s = "Enumeration: ";
  355.         if(Name())
  356.         {
  357.           s.Append ( "TYPE ");
  358.           s.Append (Name());
  359.           s.Append ( " = ");
  360.         }
  361.         if(Description())
  362.           s.Append ( Description ());
  363.         break;
  364.  
  365.       case BOOLEAN_TYPE:
  366.         s.set_null();
  367.         if(_referentType != 0)
  368.         {
  369.             s = "TYPE ";
  370.             s.Append (Name());
  371.             s.Append ( " = ");
  372.         }
  373.         s.Append("Boolean: F, T");
  374.         break;
  375.       case LOGICAL_TYPE:
  376.         s.set_null();
  377.         if(_referentType != 0)
  378.         {
  379.             s = "TYPE ";
  380.             s.Append (Name());
  381.             s.Append ( " = ");
  382.         }
  383.         s.Append("Logical: F, T, U");
  384.         break;
  385.       case NUMBER_TYPE:
  386.         s.set_null();
  387.         if(_referentType != 0)
  388.         {
  389.             s = "TYPE ";
  390.             s.Append (Name());
  391.             s.Append ( " = ");
  392.         }
  393.         s.Append("Number");
  394.         break;
  395.       case BINARY_TYPE:
  396.         s.set_null();
  397.         if(_referentType != 0)
  398.         {
  399.             s = "TYPE ";
  400.             s.Append (Name());
  401.             s.Append ( " = ");
  402.         }
  403.         s.Append("Binary");
  404.         break;
  405.       case ENTITY_TYPE:
  406.         s = "Entity: ";
  407.         if(Name())
  408.           s.Append (Name());
  409.         break;
  410.       case AGGREGATE_TYPE:
  411.         s = Description();
  412.         if(ReferentType())
  413.         {
  414.           s.Append ( " -- ");
  415.           SCLstring tmp;
  416.           s.Append ( ReferentType()->TypeString(tmp));
  417.         }
  418.         break;
  419.       case SELECT_TYPE:
  420.           s.Append ( Description ());
  421.         break;
  422.       case GENERIC_TYPE:
  423.       case UNKNOWN_TYPE:
  424.         s = "Unknown";
  425.         break;
  426.     } // end switch
  427.   return s;
  428.  
  429. }
  430. /* this works
  431.     if( ( (ReferentType() != 0) || (ReferentEntity() != 0) ) && Name())
  432.     {
  433.     strcat(tStr, "TYPE ");
  434.     strcat(tStr, Name());
  435.     strcat(tStr, " = ");
  436.     }
  437.     if(Description())
  438.     strcat(tStr, Description());
  439.     if(ReferentType())
  440.     {
  441.     strcat(tStr, " -- ");
  442.     SCLstring tmp;
  443.     strcat(tStr, ReferentType()->TypeString(tmp));
  444.     }
  445.     else if(ReferentEntity())
  446.     {
  447.     strcat(tStr, " -- ");
  448.     strcat(tStr, "Entity: ");
  449.     strcat(tStr, ReferentEntity()->Name());
  450.     }
  451.     return tStr;
  452. }
  453. */
  454.  
  455.  
  456. const TypeDescriptor * 
  457. TypeDescriptor::IsA (const TypeDescriptor * other)  const {
  458.   if (this == other)  return other;
  459.   return 0;
  460. }
  461.  
  462. const TypeDescriptor * 
  463. TypeDescriptor::IsA (const char * other) const  {
  464.   if (!Name())  return 0;
  465.   if (!strcmp (Name (), PrettyTmpName (other)))  // this is the type
  466.     return this;
  467.   return (ReferentType () ? ReferentType () -> IsA (other) : 0);
  468. }
  469.  
  470.     ///////////////////////////////////////////////////////////////////////
  471.     // the first BASE_TYPE that is not REFERENCE_TYPE (the first 
  472.     // TypeDescriptor *_referentType that does not have REFERENCE_TYPE 
  473.     // for it's fundamentalType variable).  This would return the same 
  474.     // as BaseType() for fundamental types.  An aggregate type
  475.     // would return AGGREGATE_TYPE then you could find out the type of
  476.     // an element by calling AggrElemType().  Select types
  477.     // would work the same?
  478.     ///////////////////////////////////////////////////////////////////////
  479.  
  480. const BASE_TYPE 
  481. TypeDescriptor::NonRefType() const
  482. {
  483.     const TypeDescriptor *td = NonRefTypeDescriptor();
  484.     if(td)
  485.     return td->FundamentalType();
  486.     return UNKNOWN_TYPE;
  487. }
  488.  
  489.  
  490. const TypeDescriptor *
  491. TypeDescriptor::NonRefTypeDescriptor() const
  492. {  
  493.     const TypeDescriptor *td = this;
  494.  
  495.     while ( td->ReferentType() ) {
  496.       if (td->Type() != REFERENCE_TYPE) 
  497.       return td;
  498.       td = td->ReferentType();
  499.     }
  500.  
  501.     return td;
  502. }
  503.  
  504.     ///////////////////////////////////////////////////////////////////////
  505.     // This returns the BASE_TYPE of the first non-aggregate element of 
  506.     // an aggregate
  507.     ///////////////////////////////////////////////////////////////////////
  508.  
  509. const BASE_TYPE 
  510. TypeDescriptor::AggrElemType() const
  511. {
  512.     const TypeDescriptor *aggrElemTD = AggrElemTypeDescriptor();
  513.     if(aggrElemTD)
  514.     {
  515.     return aggrElemTD->Type();
  516.     }
  517.     return UNKNOWN_TYPE;
  518. }
  519.  
  520. const TypeDescriptor *
  521. TypeDescriptor::AggrElemTypeDescriptor() const
  522. {
  523.     const TypeDescriptor *aggrTD = NonRefTypeDescriptor();
  524.     const TypeDescriptor *aggrElemTD = aggrTD->ReferentType();
  525.     if(aggrElemTD)
  526.     {
  527.     aggrElemTD = aggrElemTD->NonRefTypeDescriptor();
  528.     }
  529.     return aggrElemTD;
  530. }
  531.  
  532.     ////////////////////////////////////////////////////////////
  533.     // This is the underlying type of this type. For instance:
  534.     // TYPE count = INTEGER;
  535.     // TYPE ref_count = count;
  536.     // TYPE count_set = SET OF ref_count;
  537.     //  each of the above will generate a TypeDescriptor and for 
  538.     //  each one, BASE_TYPE BaseType() will return INTEGER_TYPE
  539.     //  TypeDescriptor *BaseTypeDescriptor() returns the TypeDescriptor 
  540.     //  for Integer
  541.     ////////////////////////////////////////////////////////////
  542.  
  543. const BASE_TYPE
  544. TypeDescriptor::BaseType() const
  545. {
  546.     const TypeDescriptor *td = BaseTypeDescriptor();
  547.     if(td)
  548.     return td->FundamentalType();
  549.     else
  550.     return ENTITY_TYPE;
  551. }
  552.  
  553. const TypeDescriptor *
  554. TypeDescriptor::BaseTypeDescriptor() const
  555. {
  556.     const TypeDescriptor *td = this;
  557.  
  558.     while (td -> ReferentType ()) td = td->ReferentType ();
  559.     return td;
  560. }
  561. #ifdef NOT_YET
  562. ///////////////////////////////////////////////////////////////////////////////
  563. // EnumerationTypeDescriptor functions
  564. ///////////////////////////////////////////////////////////////////////////////
  565. EnumerationTypeDescriptor::EnumerationTypeDescriptor( ) 
  566. {
  567.     _elements = new StringAggregate; 
  568. }
  569. #endif
  570. ///////////////////////////////////////////////////////////////////////////////
  571. // SelectTypeDescriptor functions
  572. ///////////////////////////////////////////////////////////////////////////////
  573. const TypeDescriptor *
  574. SelectTypeDescriptor::IsA (const TypeDescriptor * other) const
  575. {  return TypeDescriptor::IsA (other);  }
  576.  
  577. const TypeDescriptor *
  578. SelectTypeDescriptor::CanBe (const TypeDescriptor * other) const
  579. {
  580.   const TypeDescriptor * found =0;
  581.   TypeDescItr elements (GetElements()) ;
  582.   const TypeDescriptor * td =0;
  583.  
  584.   if (this == other) return other;
  585.   while (td = elements.NextTypeDesc ())  {
  586.     if (found = (td -> CanBe (other))) return found;
  587.   }
  588.   return 0;
  589. }
  590.  
  591. ///////////////////////////////////////////////////////////////////////////////
  592. // AggregateTypeDescriptor functions
  593. ///////////////////////////////////////////////////////////////////////////////
  594.  
  595. AggregateTypeDescriptor::AggregateTypeDescriptor( ) : 
  596.         _uniqueElements("UNKNOWN_TYPE")
  597. {
  598.     _bound1 = -1;
  599.     _bound2 = -1;
  600.     _aggrDomainType = 0;
  601. }
  602.  
  603. AggregateTypeDescriptor::AggregateTypeDescriptor(SdaiInteger b1, 
  604.                          SdaiInteger b2, 
  605.                          LOGICAL uniqElem, 
  606.                          TypeDescriptor *aggrDomType)
  607.           : _bound1(b1), _bound2(b2), _uniqueElements(uniqElem)
  608. {
  609.     _aggrDomainType = aggrDomType;
  610. }
  611.  
  612. AggregateTypeDescriptor::~AggregateTypeDescriptor()
  613. {
  614. }
  615.