#ifndef EXPDICT_H

#define EXPDICT_H

/*

* NIST STEP Core Class Library

* clstepcore/ExpDict.h

* April, 1997

* K. C. Morris

* David Sauder

* Development of this software was funded by the United States Government,

* and is not subject to copyright.

*/

#include <scl_export.h>

#include <sdai.h>

#include <deque>

#include <string>

#include <assert.h>

typedef SDAI_Application_instance * ( * Creator )() ;

enum AttrType_Enum {

AttrType_Explicit = 0,

AttrType_Inverse,

AttrType_Deriving,

AttrType_Redefining

};

enum AggrBoundTypeEnum {

bound_unset = 0,

bound_constant,

bound_runtime,

bound_funcall

};

#include <SingleLinkList.h>

#include <baseType.h>

#include <dictdefs.h>

#include <Str.h>

// defined and created in Registry.inline.cc

extern SCL_CORE_EXPORT const TypeDescriptor * t_sdaiINTEGER;

extern SCL_CORE_EXPORT const TypeDescriptor * t_sdaiREAL;

extern SCL_CORE_EXPORT const TypeDescriptor * t_sdaiNUMBER;

extern SCL_CORE_EXPORT const TypeDescriptor * t_sdaiSTRING;

extern SCL_CORE_EXPORT const TypeDescriptor * t_sdaiBINARY;

extern SCL_CORE_EXPORT const TypeDescriptor * t_sdaiBOOLEAN;

extern SCL_CORE_EXPORT const TypeDescriptor * t_sdaiLOGICAL;

///////////////////////////////////////////////////////////////////////////////

// Dictionary_instance

///////////////////////////////////////////////////////////////////////////////

class SCL_CORE_EXPORT Dictionary_instance {

protected:

Dictionary_instance() {}

Dictionary_instance( const Dictionary_instance & ) {}

virtual ~Dictionary_instance();

};

///////////////////////////////////////////////////////////////////////////////

class SCL_CORE_EXPORT TypeDescLinkNode : public SingleLinkNode {

private:

protected:

TypeDescriptor * _typeDesc;

public:

TypeDescLinkNode();

virtual ~TypeDescLinkNode();

const TypeDescriptor * TypeDesc() const {

return _typeDesc;

}

void TypeDesc( TypeDescriptor * td ) {

_typeDesc = td;

}

};

class SCL_CORE_EXPORT TypeDescriptorList : public SingleLinkList {

private:

protected:

public:

TypeDescriptorList();

virtual ~TypeDescriptorList();

virtual SingleLinkNode * NewNode() {

return new TypeDescLinkNode;

}

TypeDescLinkNode * AddNode( TypeDescriptor * td ) {

TypeDescLinkNode * node = ( TypeDescLinkNode * ) NewNode();

node->TypeDesc( td );

SingleLinkList::AppendNode( node );

return node;

}

};

class SCL_CORE_EXPORT TypeDescItr {

protected:

const TypeDescriptorList & tdl;

const TypeDescLinkNode * cur;

public:

TypeDescItr( const TypeDescriptorList & tdList );

virtual ~TypeDescItr();

void ResetItr() {

cur = ( TypeDescLinkNode * )( tdl.GetHead() );

}

const TypeDescriptor * NextTypeDesc();

};

///////////////////////////////////////////////////////////////////////////////

class SCL_CORE_EXPORT EntityDescLinkNode : public SingleLinkNode {

private:

protected:

EntityDescriptor * _entityDesc;

public:

EntityDescLinkNode();

virtual ~EntityDescLinkNode();

EntityDescriptor * EntityDesc() const {

return _entityDesc;

}

void EntityDesc( EntityDescriptor * ed ) {

_entityDesc = ed;

}

};

class SCL_CORE_EXPORT EntityDescriptorList : public SingleLinkList {

private:

protected:

public:

EntityDescriptorList();

virtual ~EntityDescriptorList();

virtual SingleLinkNode * NewNode() {

return new EntityDescLinkNode;

}

EntityDescLinkNode * AddNode( EntityDescriptor * ed ) {

EntityDescLinkNode * node = ( EntityDescLinkNode * ) NewNode();

node->EntityDesc( ed );

SingleLinkList::AppendNode( node );

return node;

}

};

typedef EntityDescriptorList * Entity__set_ptr;

typedef Entity__set_ptr Entity__set_var;

class SCL_CORE_EXPORT EntityDescItr {

protected:

const EntityDescriptorList & edl;

const EntityDescLinkNode * cur;

public:

EntityDescItr( const EntityDescriptorList & edList );

virtual ~EntityDescItr();

void ResetItr() {

cur = ( EntityDescLinkNode * )( edl.GetHead() );

}

const EntityDescriptor * NextEntityDesc();

};

///////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////

// Interfaced_item

///////////////////////////////////////////////////////////////////////////////

class SCL_CORE_EXPORT Interfaced_item : public Dictionary_instance {

protected:

Interfaced_item();

Interfaced_item( const Interfaced_item & );

Interfaced_item( const char * foreign_schema );

virtual ~Interfaced_item();

public:

Express_id _foreign_schema;

const Express_id foreign_schema_();

// private:

void foreign_schema_( const Express_id & );

};

///////////////////////////////////////////////////////////////////////////////

// Explicit_item_id

///////////////////////////////////////////////////////////////////////////////

class SCL_CORE_EXPORT Explicit_item_id : public Interfaced_item {

protected:

Explicit_item_id();

Explicit_item_id( const Explicit_item_id & );

Explicit_item_id( const char * foreign_schema, TypeDescriptor * ld,

const char * oi, const char * ni )

: Interfaced_item( foreign_schema ), _local_definition( ld ), _original_id( oi ), _new_id( ni ) {}

virtual ~Explicit_item_id();

public:

// definition in the local schema. The TypeDescriptor (or subtype) is not

// implemented quite right - the name in it is the original (foreign

// schema) name. The USE or REFERENCED renames are listed in

// TypeDescriptor's altNames member variable.

// Warning: This is currently a null ptr for objects other than

// types and entities - that is - if this is a USEd FUNCTION or PROCEDURE

// this ptr will be null.

const TypeDescriptor * _local_definition;

// name in originating schema - only exists if it has been renamed.

Express_id _original_id;

Express_id _new_id; // original or renamed name via USE or REFERENCE (non-SDAI)

const TypeDescriptor * local_definition_() const {

return _local_definition;

}

const Express_id original_id_() const {

return _original_id;

}

// non-sdai, renamed name

const Express_id new_id_() const {

return _new_id;

}

// return string "USE" or "REFERENCE"

virtual const char * EXPRESS_type() = 0;

// private:

void local_definition_( const TypeDescriptor * td ) {

_local_definition = td;

}

void original_id_( const Express_id & ei ) {

_original_id = ei;

}

// non-sdai

void new_id_( const Express_id & ni ) {

_new_id = ni;

}

};

typedef Explicit_item_id * Explicit_item_id_ptr;

class SCL_CORE_EXPORT Used_item : public Explicit_item_id {

public:

Used_item() {}

Used_item( const char * foreign_schema, TypeDescriptor * ld,

const char * oi, const char * ni )

: Explicit_item_id( foreign_schema, ld, oi, ni ) {}

virtual ~Used_item();

const char * EXPRESS_type() {

return "USE";

}

};

typedef Used_item * Used_item_ptr;

class SCL_CORE_EXPORT Referenced_item : public Explicit_item_id {

public:

Referenced_item() {}

Referenced_item( const char * foreign_schema, TypeDescriptor * ld,

const char * oi, const char * ni )

: Explicit_item_id( foreign_schema, ld, oi, ni ) {}

virtual ~Referenced_item();

const char * EXPRESS_type() {

return "REFERENCE";

}

};

typedef Referenced_item * Referenced_item_ptr;

class SCL_CORE_EXPORT Explicit_item_id__set {

public:

Explicit_item_id__set( int = 16 );

~Explicit_item_id__set();

Explicit_item_id_ptr & operator[]( int index );

void Insert( Explicit_item_id_ptr, int index );

void Append( Explicit_item_id_ptr );

void Remove( int index );

int Index( Explicit_item_id_ptr );

int Count();

void Clear();

private:

void Check( int index );

private:

Explicit_item_id_ptr * _buf;

int _bufsize;

int _count;

};

typedef Explicit_item_id__set * Explicit_item_id__set_ptr;

typedef Explicit_item_id__set_ptr Explicit_item_id__set_var;

///////////////////////////////////////////////////////////////////////////////

// Implicit_item_id

///////////////////////////////////////////////////////////////////////////////

class SCL_CORE_EXPORT Implicit_item_id : public Interfaced_item {

protected:

Implicit_item_id();

Implicit_item_id( Implicit_item_id & );

virtual ~Implicit_item_id();

public:

const TypeDescriptor * _local_definition;

const TypeDescriptor * local_definition_() const {

return _local_definition;

}

// private:

void local_definition_( const TypeDescriptor * td ) {

_local_definition = td;

}

};

typedef Implicit_item_id * Implicit_item_id_ptr;

///////////////////////////////////////////////////////////////////////////////

// Implicit_item_id__set

///////////////////////////////////////////////////////////////////////////////

class SCL_CORE_EXPORT Implicit_item_id__set {

public:

Implicit_item_id__set( int = 16 );

~Implicit_item_id__set();

Implicit_item_id_ptr & operator[]( int index );

void Insert( Implicit_item_id_ptr, int index );

void Append( Implicit_item_id_ptr );

void Remove( int index );

int Index( Implicit_item_id_ptr );

int Count();

void Clear();

private:

void Check( int index );

private:

Implicit_item_id_ptr * _buf;

int _bufsize;

int _count;

};

typedef Implicit_item_id__set * Implicit_item_id__set_ptr;

typedef Implicit_item_id__set_ptr Implicit_item_id__set_var;

///////////////////////////////////////////////////////////////////////////////

// Interface_spec

///////////////////////////////////////////////////////////////////////////////

class SCL_CORE_EXPORT Interface_spec : public Dictionary_instance {

public:

Express_id _current_schema_id; // schema containing the USE/REF stmt

// set of objects from USE/REFERENCE stmt(s)

Explicit_item_id__set_var _explicit_items;

Implicit_item_id__set_var _implicit_items; //not yet initialized for schema

// non-SDAI, not useful for SDAI use of Interface_spec (it would need to

// be a list).

// schema that defined the USE/REFd objects

Express_id _foreign_schema_id;

// non-SDAI, not useful for SDAI use of Interface_spec (it would need to

// be a list of ints).

// schema USEs or REFERENCEs all objects from foreign schema

int _all_objects;

Interface_spec();

Interface_spec( Interface_spec & ); // not tested

Interface_spec( const char * cur_sch_id, const char * foreign_sch_id,

int all_objects = 0 );

virtual ~Interface_spec();

Express_id current_schema_id_() {

return _current_schema_id;

}

Express_id foreign_schema_id_() {

return _foreign_schema_id;

}

Explicit_item_id__set_var explicit_items_() {

return _explicit_items;

}

// this is not yet initialized for the schema

Implicit_item_id__set_var implicit_items_() {

return _implicit_items;

}

// private:

void current_schema_id_( const Express_id & ei ) {

_current_schema_id = ei;

}

void foreign_schema_id_( const Express_id & fi ) {

_foreign_schema_id = fi;

}

int all_objects_() {

return _all_objects;

}

void all_objects_( int ao ) {

_all_objects = ao;

}

};

typedef Interface_spec * Interface_spec_ptr;

class SCL_CORE_EXPORT Interface_spec__set {

public:

Interface_spec__set( int = 16 );

~Interface_spec__set();

Interface_spec_ptr & operator[]( int index );

void Insert( Interface_spec_ptr, int index );

void Append( Interface_spec_ptr );

void Remove( int index );

int Index( Interface_spec_ptr );

int Count();

void Clear();

private:

void Check( int index );

private:

Interface_spec_ptr * _buf;

int _bufsize;

int _count;

};

typedef Interface_spec__set * Interface_spec__set_ptr;

typedef Interface_spec__set_ptr Interface_spec__set_var;

class SCL_CORE_EXPORT Type_or_rule : public Dictionary_instance {

public:

Type_or_rule();

Type_or_rule( const Type_or_rule & );

virtual ~Type_or_rule();

};

typedef Type_or_rule * Type_or_rule_ptr;

typedef Type_or_rule_ptr Type_or_rule_var;

class SCL_CORE_EXPORT Where_rule : public Dictionary_instance {

public:

Express_id _label;

Type_or_rule_var _type_or_rule;

// non-SDAI

std::string _comment; // Comment contained in the EXPRESS.

// Should be properly formatted to include (* *)

// Will be written to EXPRESS as-is (w/out formatting)

Where_rule();

Where_rule( const Where_rule & );

Where_rule( const char * label, Type_or_rule_var tor = 0 )

: _label( label ), _type_or_rule( tor ) { }

virtual ~Where_rule();

Express_id label_() const {

return _label;

}

const Type_or_rule_var parent_item() const {

return _type_or_rule;

}

std::string comment_() const {

return _comment;

}

void label_( const Express_id & ei ) {

_label = ei;

}

void parent_item( const Type_or_rule_var & tor ) {

_type_or_rule = tor;

}

void comment_( const char * c ) {

_comment = c;

}

};

typedef Where_rule * Where_rule_ptr;

class SCL_CORE_EXPORT Where_rule__list {

public:

Where_rule__list( int = 16 );

~Where_rule__list();

Where_rule_ptr & operator[]( int index );

void Insert( Where_rule_ptr, int index );

void Append( Where_rule_ptr );

void Remove( int index );

int Index( Where_rule_ptr );

int Count();

void Clear();

private:

void Check( int index );

private:

Where_rule_ptr * _buf;

int _bufsize;

int _count;

};

typedef Where_rule__list * Where_rule__list_ptr;

typedef Where_rule__list_ptr Where_rule__list_var;

class SCL_CORE_EXPORT Global_rule : public Dictionary_instance {

public:

Express_id _name;

Entity__set_var _entities; // not implemented

Where_rule__list_var _where_rules;

Schema_ptr _parent_schema;

std::string _rule_text; // non-SDAI

Global_rule();

Global_rule( const char * n, Schema_ptr parent_sch, const std::string & rt );

Global_rule( Global_rule & ); // not fully implemented

virtual ~Global_rule();

Express_id name_() const {

return _name;

}

const Entity__set_var entities_() const {

return _entities;

}

const Where_rule__list_var where_rules_() const {

return _where_rules;

}

const Schema_ptr parent_schema_() const {

return _parent_schema;

}

const char * rule_text_() {

return const_cast<char *>( _rule_text.c_str() );

}

void name_( Express_id & n ) {

_name = n;

}

void entities_( const Entity__set_var & e ); // not implemented

void where_rules_( const Where_rule__list_var & wrl ); // not implemented

void parent_schema_( const Schema_ptr & s ) {

_parent_schema = s;

}

void rule_text_( const char * rt ) {

_rule_text = rt;

}

};

typedef Global_rule * Global_rule_ptr;

class SCL_CORE_EXPORT Global_rule__set {

public:

Global_rule__set( int = 16 );

~Global_rule__set();

Global_rule_ptr & operator[]( int index );

void Insert( Global_rule_ptr, int index );

void Append( Global_rule_ptr );

void Remove( int index );

int Index( Global_rule_ptr );

int Count();

void Clear();

private:

void Check( int index );

private:

Global_rule_ptr * _buf;

int _bufsize;

int _count;

};

typedef Global_rule__set * Global_rule__set_ptr;

typedef Global_rule__set_ptr Global_rule__set_var;

class SCL_CORE_EXPORT Uniqueness_rule : public Dictionary_instance {

public:

Express_id _label;

const EntityDescriptor * _parent_entity;

// non-SDAI

std::string _comment; // Comment contained in the EXPRESS.

// Should be properly formatted to include (* *)

// Will be written to EXPRESS as-is (w/out formatting)

Uniqueness_rule();

Uniqueness_rule( const Uniqueness_rule & );

Uniqueness_rule( const char * label, EntityDescriptor * pe = 0 )

: _label( label ), _parent_entity( pe ) { }

virtual ~Uniqueness_rule();

Express_id label_() const {

return _label;

}

const EntityDescriptor * parent_() const {

return _parent_entity;

}

std::string & comment_() {

return _comment;

}

void label_( const Express_id & ei ) {

_label = ei;

}

void parent_( const EntityDescriptor * pe ) {

_parent_entity = pe;

}

void comment_( const char * c ) {

_comment = c;

}

};

typedef Uniqueness_rule * Uniqueness_rule_ptr;

class SCL_CORE_EXPORT Uniqueness_rule__set {

public:

Uniqueness_rule__set( int = 16 );

~Uniqueness_rule__set();

Uniqueness_rule_ptr & operator[]( int index );

void Insert( Uniqueness_rule_ptr, int index );

void Append( Uniqueness_rule_ptr );

void Remove( int index );

int Index( Uniqueness_rule_ptr );

int Count();

void Clear();

private:

void Check( int index );

private:

Uniqueness_rule_ptr * _buf;

int _bufsize;

int _count;

};

typedef Uniqueness_rule__set * Uniqueness_rule__set_ptr;

typedef Uniqueness_rule__set_ptr Uniqueness_rule__set_var;

typedef SDAI_Model_contents_ptr( * ModelContentsCreator )() ;

/**

* \class Schema (was SchemaDescriptor) - a class of this type is generated and contains schema info.

*/

class SCL_CORE_EXPORT Schema : public Dictionary_instance {

protected:

const char * _name ;

EntityDescriptorList _entList; // list of entities in the schema

TypeDescriptorList _typeList; // list of types in the schema

TypeDescriptorList _unnamed_typeList; // list of unnamed types in the schema (for cleanup)

Interface_spec _interface; // list of USE and REF interfaces (SDAI)

// non-SDAI lists

Interface_spec__set_var _use_interface_list; // list of USE interfaces

Interface_spec__set_var _ref_interface_list; // list of REFERENCE interfaces

std::deque< std::string > _function_list; // of EXPRESS functions

std::deque< std::string > _procedure_list; // of EXPRESS procedures

Global_rule__set_var _global_rules;

public:

ModelContentsCreator CreateNewModelContents;

Schema( const char * schemaName );

virtual ~Schema();

void AssignModelContentsCreator( ModelContentsCreator f = 0 ) {

CreateNewModelContents = f;

}

const char * Name() const {

return _name;

}

void Name( const char * n ) {

_name = n;

}

Interface_spec & interface_() {

return _interface;

}

Interface_spec__set_var use_interface_list_() {

return

_use_interface_list;

}

Interface_spec__set_var ref_interface_list_() {

return _ref_interface_list;

}

std::deque< std::string > function_list_() {

return _function_list;

}

void AddFunction( const std::string & f );

Global_rule__set_var global_rules_() { // const

return _global_rules;

}

void AddGlobal_rule( Global_rule_ptr gr );

void global_rules_( Global_rule__set_var & grs ); // not implemented

std::deque< std::string > procedure_list_() {

return _procedure_list;

}

void AddProcedure( const std::string & p );

EntityDescLinkNode * AddEntity( EntityDescriptor * ed ) {

return _entList.AddNode( ed );

}

TypeDescLinkNode * AddType( TypeDescriptor * td ) {

return _typeList.AddNode( td );

}

TypeDescLinkNode * AddUnnamedType( TypeDescriptor * td ) {

return _unnamed_typeList.AddNode( td );

}

// the whole schema

void GenerateExpress( ostream & out ) const;

// USE, REFERENCE definitions

void GenerateUseRefExpress( ostream & out ) const;

// TYPE definitions

void GenerateTypesExpress( ostream & out ) const;

// Entity definitions

void GenerateEntitiesExpress( ostream & out ) const;

};

typedef Schema SchemaDescriptor;

///////////////////////////////////////////////////////////////////////////////

class SCL_CORE_EXPORT AttrDescLinkNode : public SingleLinkNode {

private:

protected:

AttrDescriptor * _attrDesc;

public:

AttrDescLinkNode();

virtual ~AttrDescLinkNode();

const AttrDescriptor * AttrDesc() const {

return _attrDesc;

}

void AttrDesc( AttrDescriptor * ad ) {

_attrDesc = ad;

}

};

class SCL_CORE_EXPORT AttrDescriptorList : public SingleLinkList {

private:

protected:

public:

AttrDescriptorList();

virtual ~AttrDescriptorList();

virtual SingleLinkNode * NewNode() {

return new AttrDescLinkNode;

}

AttrDescLinkNode * AddNode( AttrDescriptor * ad );

};

class SCL_CORE_EXPORT AttrDescItr {

protected:

const AttrDescriptorList & adl;

const AttrDescLinkNode * cur;

public:

AttrDescItr( const AttrDescriptorList & adList );

virtual ~AttrDescItr();

void ResetItr() {

cur = ( AttrDescLinkNode * )( adl.GetHead() );

}

const AttrDescriptor * NextAttrDesc();

};

///////////////////////////////////////////////////////////////////////////////

class SCL_CORE_EXPORT Inverse_attributeLinkNode : public SingleLinkNode {

private:

protected:

Inverse_attribute * _invAttr;

public:

Inverse_attributeLinkNode();

virtual ~Inverse_attributeLinkNode();

const Inverse_attribute * Inverse_attr() const {

return _invAttr;

}

void Inverse_attr( Inverse_attribute * ia ) {

_invAttr = ia;

}

};

class SCL_CORE_EXPORT Inverse_attributeList : public SingleLinkList {

private:

protected:

public:

Inverse_attributeList();

virtual ~Inverse_attributeList();

virtual SingleLinkNode * NewNode() {

return new Inverse_attributeLinkNode;

}

Inverse_attributeLinkNode * AddNode( Inverse_attribute * ia );

};

class SCL_CORE_EXPORT InverseAItr {

protected:

const Inverse_attributeList & ial;

const Inverse_attributeLinkNode * cur;

public:

InverseAItr( const Inverse_attributeList & iaList );

virtual ~InverseAItr();

void ResetItr() {

cur = ( Inverse_attributeLinkNode * )( ial.GetHead() );

}

const Inverse_attribute * NextInverse_attribute();

};

/**

* \class AttrDescriptor

* An instance of this class will be generated for each attribute for

* an Entity. They will be pointed to by the EntityTypeDescriptors.

*/

class SCL_CORE_EXPORT AttrDescriptor {

protected:

const char * _name ; // the attributes name

// this defines the domain of the attribute

const TypeDescriptor * _domainType ;

SDAI_LOGICAL _optional;

SDAI_LOGICAL _unique;

AttrType_Enum _attrType; // former attribute _derived

const EntityDescriptor & _owner ; // the owning entityDescriptor

public:

AttrDescriptor(

const char * name, // i.e. char *

const TypeDescriptor * domainType,

Logical optional, // i.e. F U or T

Logical unique, // i.e. F U or T

AttrType_Enum at,// AttrType_Explicit, AttrType_Inverse,

// AttrType_Deriving,AttrType_Redefining

const EntityDescriptor & owner

);

virtual ~AttrDescriptor();

const char * GenerateExpress( std::string & buf ) const;

// the attribute Express def

virtual const char * AttrExprDefStr( std::string & s ) const;

// left side of attr def

const char * Name() const {

return _name;

}

void Name( const char * n ) {

_name = n;

}

// BaseType() is the underlying type of this attribute.

// NonRefType() is the first non REFERENCE_TYPE type

// e.g. Given attributes of each of the following types

// TYPE count = INTEGER;

// TYPE ref_count = count;

// TYPE count_set = SET OF ref_count;

// BaseType() will return INTEGER_TYPE for an attr of each type.

// BaseTypeDescriptor() returns the TypeDescriptor for Integer

// NonRefType() will return INTEGER_TYPE for the first two. For an

// attribute of type count_set NonRefType() would return

// AGGREGATE_TYPE

// NonRefTypeDescriptor() returns the TypeDescriptor for Integer

// for the first two and a TypeDescriptor for an

// aggregate for the last.

const PrimitiveType BaseType() const;

const TypeDescriptor * BaseTypeDescriptor() const;

// the first PrimitiveType 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 PrimitiveType NonRefType() const;

const TypeDescriptor * NonRefTypeDescriptor() const;

int IsAggrType() const;

const PrimitiveType AggrElemType() const;

const TypeDescriptor * AggrElemTypeDescriptor() const;

// The type of the attributes TypeDescriptor

const PrimitiveType Type() const;

const char * TypeName() const; // right side of attr def

// an expanded right side of attr def

const char * ExpandedTypeName( std::string & s ) const;

int RefersToType() const {

return !( _domainType == 0 );

}

const TypeDescriptor * ReferentType() const {

return _domainType;

}

const TypeDescriptor * DomainType() const {

return _domainType;

}

void DomainType( const TypeDescriptor * td ) {

_domainType = td;

}

void ReferentType( const TypeDescriptor * td ) {

_domainType = td;

}

const SDAI_LOGICAL & Optional() const {

return _optional;

}

void Optional( SDAI_LOGICAL & opt ) {

_optional.put( opt.asInt() );

}

void Optional( Logical opt ) {

_optional.put( opt );

}

void Optional( const char * opt ) {

_optional.put( opt );

}

const SDAI_LOGICAL & Unique() const {

return _unique;

}

void Unique( SDAI_LOGICAL uniq ) {

_unique.put( uniq.asInt() );

}

void Unique( Logical uniq ) {

_unique.put( uniq );

}

void Unique( const char * uniq ) {

_unique.put( uniq );

}

void AttrType( enum AttrType_Enum ate ) {

_attrType = ate;

}

enum AttrType_Enum AttrType() const {

return _attrType;

}

Logical Explicit() const;

Logical Inverse() const;

Logical Redefining() const;

Logical Deriving() const;

//outdated functions, use AttrType func above, new support of redefined

Logical Derived() const {

return Deriving();

}

void Derived( Logical x ); // outdated DAS

void Derived( SDAI_LOGICAL x ); // outdated DAS

void Derived( const char * x ); // outdated DAS

const SDAI_LOGICAL & Optionality() const {

return _optional;

}

void Optionality( SDAI_LOGICAL & opt ) {

_optional.put( opt.asInt() );