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 >
Wrap
C/C++ Source or Header
|
1994-08-06
|
16KB
|
615 lines
/*
* NIST STEP Core Class Library
* clstepcore/ExpDict.cc
* February, 1994
* K. C. Morris
* David Sauder
* Development of this software was funded by the United States Government,
* and is not subject to copyright.
*/
/* $Id: ExpDict.cc,v 2.0.1.4 1994/04/05 16:39:11 sauderd Exp $ */
#include <ExpDict.h>
#include <aggregat.h>
/*
const TypeDescriptor * const t_INTEGER_TYPE = & TypeDescriptor
("INTEGER", // Name
INTEGER_TYPE, // FundamentalType
"INTEGER"); // Description
extern const TypeDescriptor _t_INTEGER_TYPE
("INTEGER", // Name
INTEGER_TYPE, // FundamentalType
"INTEGER"); // Description
*/
/*const TypeDescriptor * const t_INTEGER_TYPE = &_t_INTEGER_TYPE;*/
/*extern const TypeDescriptor _t_REAL_TYPE ("REAL", REAL_TYPE, "Real");*/
/*const TypeDescriptor * const t_REAL_TYPE = &_t_REAL_TYPE;*/
/*extern const TypeDescriptor _t_STRING_TYPE ("STRING", STRING_TYPE, "String");*/
/*const TypeDescriptor * const t_STRING_TYPE = &_t_STRING_TYPE;*/
/*extern const TypeDescriptor _t_BINARY_TYPE ("BINARY", BINARY_TYPE, "Binary") ;*/
/*const TypeDescriptor * const t_BINARY_TYPE = &_t_BINARY_TYPE;*/
/*extern const TypeDescriptor _t_BOOLEAN_TYPE ("BOOLEAN", BOOLEAN_TYPE, "Boolean") ;*/
/*const TypeDescriptor * const t_BOOLEAN_TYPE = &_t_BOOLEAN_TYPE;*/
/*extern const TypeDescriptor _t_LOGICAL_TYPE ("LOGICAL", LOGICAL_TYPE, "Logical") ;*/
/*const TypeDescriptor * const t_LOGICAL_TYPE = &_t_LOGICAL_TYPE;*/
/*extern const TypeDescriptor _t_NUMBER_TYPE ("NUMBER", NUMBER_TYPE, "Number") ;*/
/*const TypeDescriptor * const t_NUMBER_TYPE = &_t_NUMBER_TYPE;*/
/*extern const TypeDescriptor _t_GENERIC_TYPE ("GENERIC", GENERIC_TYPE, "Generic") ;*/
/*const TypeDescriptor * const t_GENERIC_TYPE = &_t_GENERIC_TYPE;*/
const EntityDescriptor *
EntityDescItr::NextEntityDesc()
{
if(cur)
{
const EntityDescriptor *ed = cur->EntityDesc();
cur = (EntityDescLinkNode *)( cur->NextNode() );
return ed;
}
return 0;
}
const AttrDescriptor *
AttrDescItr::NextAttrDesc()
{
if(cur)
{
const AttrDescriptor *ad = cur->AttrDesc();
cur = (AttrDescLinkNode *)( cur->NextNode() );
return ad;
}
return 0;
}
const InverseAttrDescriptor *
InverseADItr::NextInverseAttrDesc()
{
if(cur)
{
const InverseAttrDescriptor *iad = cur->InverseAttrDesc();
cur = (InverseAttrDescLinkNode *)( cur->NextNode() );
return iad;
}
return 0;
}
const TypeDescriptor *
TypeDescItr::NextTypeDesc()
{
if(cur)
{
const TypeDescriptor *td = cur->TypeDesc();
cur = (TypeDescLinkNode *)( cur->NextNode() );
return td;
}
return 0;
}
///////////////////////////////////////////////////////////////////////////////
// AttrDescriptor functions
///////////////////////////////////////////////////////////////////////////////
const char *
AttrDescriptor::AttrExprDefStr(SCLstring & s) const
{
s = Name ();
s.Append (" : ");
if(_optional.asInt() == T)
s.Append( "OPTIONAL ");
if(DomainType())
s.Append (DomainType()->AttrTypeName());
return s.chars();
}
const BASE_TYPE
AttrDescriptor::BaseType() const
{
if(_domainType)
return _domainType->BaseType();
return UNKNOWN_TYPE;
}
const BASE_TYPE
AttrDescriptor::AggrElemType() const
{
if(NonRefType() == AGGREGATE_TYPE)
{
return ReferentType()->AggrElemType();
}
return UNKNOWN_TYPE;
}
const TypeDescriptor *
AttrDescriptor::AggrElemTypeDescriptor() const
{
if(NonRefType() == AGGREGATE_TYPE)
{
return ReferentType()->AggrElemTypeDescriptor();
}
return 0;
}
const TypeDescriptor *
AttrDescriptor::NonRefTypeDescriptor() const
{
if(_domainType)
return _domainType->NonRefTypeDescriptor();
return 0;
}
const BASE_TYPE
AttrDescriptor::NonRefType() const
{
if(_domainType)
return _domainType->NonRefType();
return UNKNOWN_TYPE;
}
const BASE_TYPE
AttrDescriptor::Type() const
{
if(_domainType)
return _domainType->Type();
return UNKNOWN_TYPE;
}
// right side of attr def
// NOTE this returns a \'const char * \' instead of an SCLstring
const char *
AttrDescriptor::TypeName() const
{
if(_domainType)
return _domainType->AttrTypeName();
else
return "";
}
// an expanded right side of attr def
const char *
AttrDescriptor::ExpandedTypeName(SCLstring & s) const
{
s.set_null();
if ((LOGICAL) Derived () == sdaiTRUE) s = "DERIVE ";
if(_domainType)
{
SCLstring tmp;
return s.Append (_domainType->TypeString(tmp));
}
else
return 0;
}
///////////////////////////////////////////////////////////////////////////////
// InverseAttrDescriptor functions
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// EntityDescriptor functions
///////////////////////////////////////////////////////////////////////////////
EntityDescriptor::EntityDescriptor ( ) : _abstractEntity("U")
{
_originatingSchema = 0;
// _derivedAttr = new StringAggregate;
/*
_subtypes = 0;
_supertypes = 0;
_explicitAttr = 0;
_inverseAttr = 0;
*/
}
EntityDescriptor::EntityDescriptor (const char * name, // i.e. char *
SchemaDescriptor *origSchema,
LOGICAL abstractEntity, // F U or T
Creator f
/*
EntityDescriptorList *subtypes,
EntityDescriptorList *supertypes,
AttrDescriptorList *explicitAttr,
StringAggregate *derivedAttr,
InverseAttrDescriptorList *inverseAttr
*/
)
: TypeDescriptor (name, ENTITY_TYPE, name), _originatingSchema (origSchema),
_abstractEntity(abstractEntity), NewSTEPentity(f)
{
/*
_subtypes = subtypes;
_supertypes = supertypes;
_explicitAttr = explicitAttr;
_derivedAttr = derivedAttr;
_inverseAttr = inverseAttr;
*/
}
EntityDescriptor::~EntityDescriptor ()
{
}
const TypeDescriptor *
EntityDescriptor::IsA (const TypeDescriptor * td) const
{ if (td -> NonRefType () == ENTITY_TYPE)
return IsA ((EntityDescriptor *) td);
else return 0;
}
const EntityDescriptor *
EntityDescriptor::IsA (const EntityDescriptor * other) const {
const EntityDescriptor * found =0;
const EntityDescLinkNode * link = (const EntityDescLinkNode *) (GetSupertypes ().GetHead());
if (this == other) return other;
else {
while (link && ! found) {
found = link -> EntityDesc() -> IsA (other);
link = (EntityDescLinkNode *) link -> NextNode ();
}
}
return found;
}
/*
EntityDescriptor::FindLongestAttribute()
{
AttrDescLinkNode *attrPtr =
(AttrDescLinkNode *)(ed->ExplicitAttr().GetHead());
while( attrPtr != 0)
{
if(attrPtr->AttrDesc()->IsEntityType())
maxAttrLen = max(maxAttrLen,
(strlen(attrPtr->AttrDesc()->EntityType()->Name()) +
strlen(attrPtr->AttrDesc()->Name()) + 3
)
);
else
maxAttrLen = max(maxAttrLen,
(strlen(attrPtr->AttrDesc()->DomainType()->NameOrDescription()) +
strlen(attrPtr->AttrDesc()->Name()) + 3
)
);
attrPtr = (AttrDescLinkNode *)attrPtr->NextNode();
}
}
*/
///////////////////////////////////////////////////////////////////////////////
// TypeDescriptor functions
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////
// This is a fully expanded description of the type.
// This returns a string like the _description member variable
// except it is more thorough of a description where possible
// e.g. if the description contains a TYPE name it will also
// be explained.
///////////////////////////////////////////////////////////////////////
const char *
TypeDescriptor::TypeString(SCLstring & s) const
{
switch(Type())
{
case REFERENCE_TYPE:
if(Name())
{
s.Append ( "TYPE ");
s.Append (Name());
s.Append ( " = ");
}
if(Description())
s.Append ( Description ());
if(ReferentType())
{
s.Append ( " -- ");
SCLstring tmp;
s.Append ( ReferentType()->TypeString(tmp));
}
return s;
case INTEGER_TYPE:
s.set_null();
if(_referentType != 0)
{
s = "TYPE ";
s.Append (Name());
s.Append ( " = ");
}
s.Append("Integer");
break;
case STRING_TYPE:
s.set_null();
if(_referentType != 0)
{
s = "TYPE ";
s.Append (Name());
s.Append ( " = ");
}
s.Append("String");
break;
case REAL_TYPE:
s.set_null();
if(_referentType != 0)
{
s = "TYPE ";
s.Append (Name());
s.Append ( " = ");
}
s.Append("Real");
break;
case ENUM_TYPE:
s = "Enumeration: ";
if(Name())
{
s.Append ( "TYPE ");
s.Append (Name());
s.Append ( " = ");
}
if(Description())
s.Append ( Description ());
break;
case BOOLEAN_TYPE:
s.set_null();
if(_referentType != 0)
{
s = "TYPE ";
s.Append (Name());
s.Append ( " = ");
}
s.Append("Boolean: F, T");
break;
case LOGICAL_TYPE:
s.set_null();
if(_referentType != 0)
{
s = "TYPE ";
s.Append (Name());
s.Append ( " = ");
}
s.Append("Logical: F, T, U");
break;
case NUMBER_TYPE:
s.set_null();
if(_referentType != 0)
{
s = "TYPE ";
s.Append (Name());
s.Append ( " = ");
}
s.Append("Number");
break;
case BINARY_TYPE:
s.set_null();
if(_referentType != 0)
{
s = "TYPE ";
s.Append (Name());
s.Append ( " = ");
}
s.Append("Binary");
break;
case ENTITY_TYPE:
s = "Entity: ";
if(Name())
s.Append (Name());
break;
case AGGREGATE_TYPE:
s = Description();
if(ReferentType())
{
s.Append ( " -- ");
SCLstring tmp;
s.Append ( ReferentType()->TypeString(tmp));
}
break;
case SELECT_TYPE:
s.Append ( Description ());
break;
case GENERIC_TYPE:
case UNKNOWN_TYPE:
s = "Unknown";
break;
} // end switch
return s;
}
/* this works
if( ( (ReferentType() != 0) || (ReferentEntity() != 0) ) && Name())
{
strcat(tStr, "TYPE ");
strcat(tStr, Name());
strcat(tStr, " = ");
}
if(Description())
strcat(tStr, Description());
if(ReferentType())
{
strcat(tStr, " -- ");
SCLstring tmp;
strcat(tStr, ReferentType()->TypeString(tmp));
}
else if(ReferentEntity())
{
strcat(tStr, " -- ");
strcat(tStr, "Entity: ");
strcat(tStr, ReferentEntity()->Name());
}
return tStr;
}
*/
const TypeDescriptor *
TypeDescriptor::IsA (const TypeDescriptor * other) const {
if (this == other) return other;
return 0;
}
const TypeDescriptor *
TypeDescriptor::IsA (const char * other) const {
if (!Name()) return 0;
if (!strcmp (Name (), PrettyTmpName (other))) // this is the type
return this;
return (ReferentType () ? ReferentType () -> IsA (other) : 0);
}
///////////////////////////////////////////////////////////////////////
// the first BASE_TYPE that is not REFERENCE_TYPE (the first
// TypeDescriptor *_referentType that does not have REFERENCE_TYPE
// for it's fundamentalType variable). This would return the same
// as BaseType() for fundamental types. An aggregate type
// would return AGGREGATE_TYPE then you could find out the type of
// an element by calling AggrElemType(). Select types
// would work the same?
///////////////////////////////////////////////////////////////////////
const BASE_TYPE
TypeDescriptor::NonRefType() const
{
const TypeDescriptor *td = NonRefTypeDescriptor();
if(td)
return td->FundamentalType();
return UNKNOWN_TYPE;
}
const TypeDescriptor *
TypeDescriptor::NonRefTypeDescriptor() const
{
const TypeDescriptor *td = this;
while ( td->ReferentType() ) {
if (td->Type() != REFERENCE_TYPE)
return td;
td = td->ReferentType();
}
return td;
}
///////////////////////////////////////////////////////////////////////
// This returns the BASE_TYPE of the first non-aggregate element of
// an aggregate
///////////////////////////////////////////////////////////////////////
const BASE_TYPE
TypeDescriptor::AggrElemType() const
{
const TypeDescriptor *aggrElemTD = AggrElemTypeDescriptor();
if(aggrElemTD)
{
return aggrElemTD->Type();
}
return UNKNOWN_TYPE;
}
const TypeDescriptor *
TypeDescriptor::AggrElemTypeDescriptor() const
{
const TypeDescriptor *aggrTD = NonRefTypeDescriptor();
const TypeDescriptor *aggrElemTD = aggrTD->ReferentType();
if(aggrElemTD)
{
aggrElemTD = aggrElemTD->NonRefTypeDescriptor();
}
return aggrElemTD;
}
////////////////////////////////////////////////////////////
// This is the underlying type of this type. For instance:
// TYPE count = INTEGER;
// TYPE ref_count = count;
// TYPE count_set = SET OF ref_count;
// each of the above will generate a TypeDescriptor and for
// each one, BASE_TYPE BaseType() will return INTEGER_TYPE
// TypeDescriptor *BaseTypeDescriptor() returns the TypeDescriptor
// for Integer
////////////////////////////////////////////////////////////
const BASE_TYPE
TypeDescriptor::BaseType() const
{
const TypeDescriptor *td = BaseTypeDescriptor();
if(td)
return td->FundamentalType();
else
return ENTITY_TYPE;
}
const TypeDescriptor *
TypeDescriptor::BaseTypeDescriptor() const
{
const TypeDescriptor *td = this;
while (td -> ReferentType ()) td = td->ReferentType ();
return td;
}
#ifdef NOT_YET
///////////////////////////////////////////////////////////////////////////////
// EnumerationTypeDescriptor functions
///////////////////////////////////////////////////////////////////////////////
EnumerationTypeDescriptor::EnumerationTypeDescriptor( )
{
_elements = new StringAggregate;
}
#endif
///////////////////////////////////////////////////////////////////////////////
// SelectTypeDescriptor functions
///////////////////////////////////////////////////////////////////////////////
const TypeDescriptor *
SelectTypeDescriptor::IsA (const TypeDescriptor * other) const
{ return TypeDescriptor::IsA (other); }
const TypeDescriptor *
SelectTypeDescriptor::CanBe (const TypeDescriptor * other) const
{
const TypeDescriptor * found =0;
TypeDescItr elements (GetElements()) ;
const TypeDescriptor * td =0;
if (this == other) return other;
while (td = elements.NextTypeDesc ()) {
if (found = (td -> CanBe (other))) return found;
}
return 0;
}
///////////////////////////////////////////////////////////////////////////////
// AggregateTypeDescriptor functions
///////////////////////////////////////////////////////////////////////////////
AggregateTypeDescriptor::AggregateTypeDescriptor( ) :
_uniqueElements("UNKNOWN_TYPE")
{
_bound1 = -1;
_bound2 = -1;
_aggrDomainType = 0;
}
AggregateTypeDescriptor::AggregateTypeDescriptor(SdaiInteger b1,
SdaiInteger b2,
LOGICAL uniqElem,
TypeDescriptor *aggrDomType)
: _bound1(b1), _bound2(b2), _uniqueElements(uniqElem)
{
_aggrDomainType = aggrDomType;
}
AggregateTypeDescriptor::~AggregateTypeDescriptor()
{
}