#ifndef TYPEDESCRIPTOR_H

#define TYPEDESCRIPTOR_H

#include "schRename.h"

#include "whereRule.h"

#include "clstepcore/dictSchema.h"

#include "sc_export.h"

/**

* TypeDescriptor

* This class and the classes inherited from this class are used to describe

* all types (base types and created types). There will be an instance of this

* class generated for each type found in the schema.

* A TypeDescriptor will be generated in three contexts:

* 1) to describe a base type - e.g. INTEGER, REAL, STRING. There is only one

* TypeDescriptor created for each Express base type. Each of these will

* be pointed to by several other AttrDescriptors and TypeDescriptors)

* 2) to describe a type created by an Express TYPE statement.

* e.g. TYPE label = STRING END_TYPE;

* These TypeDescriptors will be pointed to by other AttrDescriptors (and

* TypeDescriptors) representing attributes (and Express TYPEs) that are

* of the type created by this Express TYPE.

* 3) to describe a type created in an attribute definition

* e.g. part_label_grouping : ARRAY [1.10] label;

* or part_codes : ARRAY [1.10] INTEGER;

* In this #3 context there will not be a name associated with the type.

* The TypeDescriptor created in this case will only be pointed to by the

* single AttrDescriptor associated with the attribute it was created for.

*

* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

*

* \var _name

* \brief the name of the type.

* In the case of the TypeDescriptors representing the Express base

* types this will be the name of the base type.

* In the case where this TypeDescriptor is representing an Express

* TYPE it is the LEFT side of an Express TYPE statement (i.e. label

* as in TYPE label = STRING END_TYPE;) This name would in turn be

* found on the RIGHT side of an Express attribute definition (e.g.

* attr defined as part_label : label; )

* In the case where this TypeDescriptor was generated to describe a

* type created in an attr definition, it will be a null pointer (e.g

* attr defined as part_label_grouping : ARRAY [1..10] label)

* \var _fundamentalType

* the 'type' of the type being represented by

* the TypeDescriptor . i.e. the following 2 stmts

* would cause 2 TypeDescriptors to be generated - the 1st having

* _fundamentalType set to STRING_TYPE and for the 2nd to

* REFERENCE_TYPE.

* TYPE label = STRING END_TYPE;

* TYPE part_label = label END_TYPE;

* part_label and label would be the value of the respective

* _name member variables for the 2 TypeDescriptors.

* \var _referentType

* will point at another TypeDescriptor further specifying

* the type in all cases except when the type is directly

* an enum or select. i.e. in the following... _referentType for

* the 1st type does not point at anything and for the 2nd it does:

* TYPE color = ENUMERATION OF (red, blue); END_TYPE;

* TYPE color_ref = color; END_TYPE;

** var _fundamentalType

* being REFERENCE_TYPE (as would be the case for

* part_label and color_ref above) means that the _referentType

* member variable points at a TypeDescriptor representing a type

* that has been defined in an Express TYPE stmt.

* Otherwise _fundamental type reflects

* the type directly as in the type label above. type label above

* has a _referentType that points at a TypeDescriptor for STRING

* described in the next sentence (also see #1 above).

* A TypeDescriptor would be generated for each of the EXPRESS base

* types (int, string, real, etc) having _fundamentalType member

* variables set to match the EXPRESS base type being represented.

** var _referentType

* For the TypeDescriptors describing the EXPRESS base types this will

* be a null pointer. For all other TypeDescriptors this will point

* to another TypeDescriptor which further describes the type. e.g.

* TYPE part_label = label END_TYPE; TYPE label = STRING END_TYPE;

* part_label's _referentType will point to the TypeDescriptor for

* label. label's _referentType will point to the TypeDescriptor

* for STRING. The _fundamentalType for part_label will be

* REFERENCE_TYPE and for label will be STRING_TYPE.

* The _fundamentalType for the EXPRESS base type STRING's

* TypeDescriptor will be STRING_TYPE.

* The _referentType member variable will in most cases point to

* a subtype of TypeDescriptor.

* \var _description

* This is the string description of the type as found in the

* EXPRESS file. e.g. aggr of [aggr of ...] [list of ...] someType

* It is the RIGHT side of an Express TYPE statement

* (i.e. LIST OF STRING as in

* TYPE label_group = LIST OF STRING END_TYPE;)

* It is the same as _name for EXPRESS base types TypeDescriptors (with

* the possible exception of upper or lower case differences).

*/

class SC_CORE_EXPORT TypeDescriptor {

protected:

/// the name of the type (see above)

///

/// NOTE - memory is not allocated for this, or for _description

/// below. It is assumed that at creation, _name will be made

/// to point to a static location in memory. The exp2cxx

/// generated code, for example, places a literal string in its

/// TypeDesc constructor calls. This creates a location in me-

/// mory static throughout the lifetime of the calling program.

const char * _name ;

/// an alternate name of type - such as one given by a different

/// schema which USEs/ REFERENCEs this. (A complete list of

/// alternate names is stored in altNames below. _altname pro-

/// vides storage space for the currently used one.)

char _altname[BUFSIZ+1];

/// contains list of renamings of type - used by other schemas

/// which USE/ REFERENCE this

const SchRename * altNames;

/// the type of the type (see above).

/// it is an enum see file clstepcore/baseType.h

PrimitiveType _fundamentalType;

const Schema * _originatingSchema;

/// further describes the type (see above)

/// most often (or always) points at a subtype.

const TypeDescriptor * _referentType;

/// Express file description (see above)

/// e.g. the right side of an Express TYPE stmt

/// (See note above by _name regarding memory allocation.)

const char * _description;

public:

/// a Where_rule may contain only a comment

Where_rule__list_var _where_rules; // initially a null pointer

Where_rule__list_var & where_rules_() {

return _where_rules;

}

void where_rules_( Where_rule__list * wrl ) {

_where_rules = wrl;

}

protected:

/// Functions used to check the current name of the type (may

/// != _name if altNames has diff name for current schema).

bool PossName( const char * ) const;

bool OurName( const char * ) const;

bool AltName( const char * ) const;

public:

TypeDescriptor( const char * nm, PrimitiveType ft, const char * d );

TypeDescriptor( const char * nm, PrimitiveType ft,

Schema * origSchema, const char * d );

TypeDescriptor( );

virtual ~TypeDescriptor();

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

/// The name of this type. If schnm != NULL, the name we're

/// referred to by schema schnm (may be diff name in our alt-

/// names list (based on schnm's USE/REF list)).

const char * Name( const char * schnm = NULL ) const;

/// The name that would be found on the right side of an

/// attribute definition. In the case of a type defined like

/// TYPE name = STRING END_TYPE;

/// with attribute definition employee_name : name;

/// it would be the _name member variable. If it was a type

/// defined in an attribute it will be the _description

/// member variable since _name will be null. e.g. attr. def.

/// project_names : ARRAY [1..10] name;

void AttrTypeName( std::string & buf, const char * schnm = NULL ) const;

/// Linked link of alternate names for the type:

const SchRename * AltNameList() const {

return altNames;

}

/// 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 * TypeString( std::string & s ) const;

/// This TypeDescriptor's type

PrimitiveType Type() const {

return _fundamentalType;

}

void Type( const PrimitiveType type ) {

_fundamentalType = type;

}

/// This is the underlying Express base type of this type. It will

/// be the type of the last TypeDescriptor following the

/// _referentType member variable pointers. e.g.

/// 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, PrimitiveType BaseType() will return INTEGER_TYPE.

/// TypeDescriptor *BaseTypeDescriptor() returns the TypeDescriptor

/// for Integer.

PrimitiveType BaseType() const;

const TypeDescriptor * BaseTypeDescriptor() const;

const char * BaseTypeName() 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?

PrimitiveType NonRefType() const;

const TypeDescriptor * NonRefTypeDescriptor() const;

int IsAggrType() const;

PrimitiveType AggrElemType() const;

const TypeDescriptor * AggrElemTypeDescriptor() const;

PrimitiveType FundamentalType() const {

return _fundamentalType;

}

void FundamentalType( PrimitiveType ftype ) {

_fundamentalType = ftype;

}

/// The TypeDescriptor for the type this type is based on

const TypeDescriptor * ReferentType() const {

return _referentType;

}

void ReferentType( const TypeDescriptor * rtype ) {

_referentType = rtype;

}

const Schema * OriginatingSchema() const {

return _originatingSchema;

}

void OriginatingSchema( const Schema * os ) {

_originatingSchema = os;

}

const char * schemaName() const {

if( _originatingSchema ) {

return _originatingSchema->Name();

} else {

return "";

}

}

/// A description of this type's type. Basically you

/// get the right side of a TYPE statement minus END_TYPE.

/// For base type TypeDescriptors it is the same as _name.

const char * Description() const {

return _description;

}

void Description( const char * desc ) {

_description = desc;

}

virtual const TypeDescriptor * IsA( const TypeDescriptor * ) const;

virtual const TypeDescriptor * BaseTypeIsA( const TypeDescriptor * )

const;

virtual const TypeDescriptor * IsA( const char * ) const;

virtual const TypeDescriptor * CanBe( const TypeDescriptor * n ) const {

return IsA( n );

}

virtual const TypeDescriptor * CanBe( const char * n ) const {

return IsA( n );

}

virtual const TypeDescriptor * CanBeSet( const char * n,

const char * schNm = 0 ) const {

return ( CurrName( n, schNm ) ? this : 0 );

}

bool CurrName( const char *, const char * = 0 ) const;

/// Adds an additional name, newnm, to be use when schema schnm is USE/REFERENCE'ing us (added to altNames).

void addAltName( const char * schnm, const char * newnm );

};

#endif //TYPEDESCRIPTOR_H