/*

* scl2html.cc

*

* Ian Soboroff, NIST

* June, 1994

*

* scl2html is a program to lay out a given schema in HTML, suitable for

* hypertext browsing using Mosaic or any other HTML viewer/WWW surfboard.

* While this particular code as designed is linked to the Example schema

* (via tests.h), it can be "fed" any exp2cxx-compiled schema and give

* appropriate output.

*

* The Makefile defaults to building the app to use the example schema. To

* link to another schema, build the appropriate libraries for it and

* 'make SCHEMA_NAME=my-schema'. See the Makefile for more details.

*

* The executable is named after the schema you use, e.g., scl2html.example.

* This can be renamed to whatever you want.

*

* This program works by using the registry to walk through each entity type.

* At each entity, the supertypes, subtypes, and attributes are probed out

* and mapped into a relatively nifty-looking HTML format.

*

* This code was heavily inspired by the original scltest program,

* distributed with the DataProbe, v2.0.x.

*/

/* Since scl2html doesn't use any schema-specific things except the init

function, we don't need to include the schema's header file inside

tests.h */

#define DONT_NEED_HEADER

#include "../tests.h"

/* STEPentity* Iterator class definition */

#include "../SEarritr.h"

// PrintAttrTypeWithAnchor()

// Given an attribute, print out its immediate type (not fundamental).

// Ah, but if life were so simple. If this attribute is _not_ of a

// fundamental type, put in an anchor to somewhere with info on the type.

// This could be either the index page Type list, or an entity's page if

// the attribute is an entity.

// BUGS: (sort of) IMHO, the handling of aggregates here is a kludge, but

// it's a kludge without a solution I can see. While the dictionary has

// ways to show you what kinds of things an aggregate holds, it won't tell

// you what kind of _aggragation_ (no pun intended) you have, as in giving

// you a code or "Bag" or something by itself. It probably doesn't work

// aesthetically for compound aggregates (i.e., a list of lists).

void PrintAttrTypeWithAnchor( const TypeDescriptor * typeDesc, ofstream & outhtml ) {

std::string buf;

// The type. See clstepcore/baseType.h for info

PrimitiveType base = typeDesc->Type();

// the type descriptor for the "referent type," if any.

// This is NULL if the attribute is a fundamental type.

// All we use it for now is checking for NULL.

const TypeDescriptor * reference = typeDesc->ReferentType();

// Do we need an anchor?

int anchor = 0;

// First, figure out if we need an anchor...

if( reference ) { // if this has a referent type (i.e., is a non-base type)

if( base != sdaiAGGR ) { // anchor all non-bases except for aggregates

anchor = 1; // which we'll take care of recursively

}

} else {

// entities and enumerations show up as base, but we want to

// anchor them anyway

if( base == sdaiENUMERATION || base == sdaiINSTANCE ) {

anchor = 1;

}

}

// Now, print type, with anchor if necessary

if( anchor && base != sdaiINSTANCE ) {

// for regular TYPEs, anchor to the index at that definition

outhtml << "<A HREF=\"" << "index.html#";

outhtml << typeDesc->Name() << "\">";

} else if( anchor && base == sdaiINSTANCE ) {

// for entities, anchor to that entity's page

outhtml << "<A HREF=\"" << typeDesc->Name();

outhtml << ".html\">";

}

typeDesc->AttrTypeName( buf );

outhtml << buf;

if( base == sdaiAGGR ) {

outhtml << " (contains elements of type ";

PrintAttrTypeWithAnchor( typeDesc->AggrElemTypeDescriptor(), outhtml );

outhtml << ")" << endl;

}

if( anchor ) {

outhtml << "</A>";

}

}

// PrintAttrsHTML()

// Given an entity, print out to the HTML file an unordered list of

// the entity's attributes and their types. It returns the number of

// explicit attributes that the entity has.

int PrintAttrsHTML( const EntityDescriptor * ent, ofstream & outhtml ) {

int attrCount = 0;

// To traverse the attributes of the entity, we're going to use

// an iterator native to the class library. This could also have

// been done using GetHead() and NextNode() of the entity's attribute

// list (nearly identical to how the entity lists are traversed), see

// PrintParentAttrsHTML() and also main() below.

AttrDescItr aditr( ent->ExplicitAttr() );

const AttrDescriptor * attrDesc = aditr.NextAttrDesc();

if( attrDesc != 0 ) {

outhtml << "\n<! -- These are the attributes for entity ";

outhtml << ent->Name() << " >\n\n";

outhtml << "<UL>" << endl;

while( attrDesc != 0 ) {

attrCount++;

outhtml << "<LI>" << attrDesc->Name() << " : ";

if( ( attrDesc->Optional() ) == SDAI_LOGICAL( LTrue ) ) {

outhtml << "optional ";

}

PrintAttrTypeWithAnchor( attrDesc->ReferentType(), outhtml );

outhtml << endl;

attrDesc = aditr.NextAttrDesc();

}

outhtml << "</UL>" << endl;

}

return attrCount;

}

// PrintParentAttrsHTML()

// This function, given an entity and its parent, recursively travels up

// the inheritance tree of the entity, printing to the HTML file a

// description-list structure showing all ancestors. For each ancestor,

// the attributes are printed using the PrintAttrsHTML() function above.

void PrintParentAttrsHTML( const EntityDescriptor * ent,

const EntityDescriptor * parent, ofstream & outhtml ) {

// Passing this function the pointer to ent is really cosmetic, so

// we can easily print out this 'header' information.

outhtml << "\n<! -- This is a parent of " << ent->Name() << ">\n\n";

outhtml << "<DL>" << endl;

outhtml << "<DT>" << ent->Name() << " inherits from ";

outhtml << "<A HREF=\"" << parent->Name() << ".html\">";

outhtml << parent->Name() << "</A>" << endl;

// Here we're going to traverse the list of supertypes of the parent

// using the EntityDescriptorList

const EntityDescriptorList * grandpaList = &( parent->Supertypes() );

EntityDescLinkNode * grandpaNode =

( EntityDescLinkNode * )grandpaList->GetHead();

while( grandpaNode ) {

// for each "grandparent" of ent, inside a descriptor body (<DD>)

// recursively call this function... the 'while' takes care of

// multiple inheritance: for each grandparent, trace back.

outhtml << "<DD>" << endl;

const EntityDescriptor * grandpa = grandpaNode->EntityDesc();

PrintParentAttrsHTML( parent, grandpa, outhtml );

grandpaNode = ( EntityDescLinkNode * )grandpaNode->NextNode();

}

// Now print the parent's attributes. This calls PrintAttrsHTML() to

// actually print any existing attributes, but to see if there are

// any, we'll check to see if the head of the attribute descriptor list

// exists. Conversely, once grabbing the head we could print out

// the attributes by following the list (attrNode->NextNode()).

const AttrDescriptorList * attrList = &( parent->ExplicitAttr() );

AttrDescLinkNode * attrNode = ( AttrDescLinkNode * )attrList->GetHead();

if( attrNode ) {

outhtml << "<DT>" << parent->Name();

outhtml << " has the following attributes" << endl;

outhtml << "<DD>" << endl;

if( PrintAttrsHTML( parent, outhtml ) == 0 ) {

outhtml << "<EM>none</EM>" << endl;

}

}

outhtml << "</DL>" << endl;

}

/******************** main() ****************************/

main() {

// This has to be done before anything else. This initializes

// all of the registry information for the schema you are using.

// The SchemaInit() function is generated by exp2cxx... see

// extern statement above.

Registry * registry = new Registry( SchemaInit );

// Rather than using the standard Registry class here, as in the treg

// example, we are using MyRegistry, which is derived from the original.

// Registry doesn`t contain a facility for browsing the types, as it

// does schemas and entities... so I added it. See the file

// MyRegistry.h for details on how this was done.

// "Reset" has tables for browsing

registry->ResetEntities();

registry->ResetSchemas();

registry->ResetTypes();

const SchemaDescriptor * schema = registry->NextSchema();

int num_ents = registry->GetEntityCnt();

cout << "Processing schema " << schema->Name();

cout << " with " << num_ents << " entities." << endl;

// Set up root-level index of the schema, in a file called

// "index.html". In this document are links to all objects in

// the schema.

cout << "Creating 'index.html'" << endl;

ofstream root( "index.html" );

root << "<TITLE>" << schema->Name() << "</TITLE>" << endl;

root << "<H1>Schema: " << schema->Name() << "</H1>" << endl;

// Do Type-list

cout << "Processing types ";

root << "<HR>" << endl;

root << "<H2>Types</H2>" << endl;

root << "<UL>" << endl;

const TypeDescriptor * type;

type = registry->NextType();

root << "<! -- The following is a list of types, which are>\n";

root << "<! -- cross-referenced from the entities.>\n";

while( type != 0 ) {

cout << ".";

root << "<LI><A NAME=\"" << type->Name() << "\">";

root << type->Name() << "</A>: ";

root << type->Description() << endl;

type = registry->NextType();

}

root << "</UL>" << endl;

cout << endl;

// Do entity root-section and pages

root << "<HR>" << endl;

root << "<H2>Entities</H2>" << endl;

root << "<UL>" << endl;

root << "<! -- These all lead to a page for each entity>\n";

// These are all pointers we need to wander around the registry

// information. We'll want to not only look at the current entity

// and its attributes, but also which entities are super- and subclasses

// of the current entity. Here, supers isn't really used beyond checking

// for ancestors, but we'll use subs to list subclasses and make links

// to them.

const EntityDescriptor * ent;

const EntityDescriptorList * supers;

const EntityDescriptorList * subs;

EntityDescLinkNode * entNode;

for( int i = 0; i < num_ents; i++ ) {

ent = registry->NextEntity();

cout << "Processing " << ent->Name() << endl;

// add anchor to root page

root << "<LI><A HREF=\"" << ent->Name() << ".html\">";

root << ent->Name() << "</A>" << endl;

// construct page for entity

char * tmpstr = new char[strlen( ent->Name() ) + 6];

ofstream entout( strcat( strcpy( tmpstr, ent->Name() ), ".html" ) );

delete [] tmpstr;

entout << "<TITLE>Entity " << ent->Name() << "</TITLE>" << endl;

entout << "<H1>" << ent->Name() << "</H1>" << endl;

// supertypes

entout << "<HR>\n<H2>Inherited Attributes</H2>" << endl;

entout << "<! -- Below is the direct ancestry (if any) of ";

entout << ent->Name() << ">\n";

supers = &( ent->Supertypes() );

entNode = ( EntityDescLinkNode * )supers->GetHead();

if( !entNode ) {

entout << "<EM>none</EM>" << endl;

}

while( entNode ) {

// call PrintParentAttrsHTML to explore the parents

// of the entity, for each parent.

const EntityDescriptor * parent = entNode->EntityDesc();

PrintParentAttrsHTML( ent, parent, entout );

entNode = ( EntityDescLinkNode * )entNode->NextNode();

}

// local attributes

entout << "<HR>\n<H2>Local Attributes</H2>" << endl;

if( PrintAttrsHTML( ent, entout ) == 0 ) {

entout << "<EM>none</EM>" << endl;

}

// subtypes

// We're going to traverse the subtypes by using the subtype list

// of the entity, a little more simply than in PrintParentAttrsHTML()

entout << "<HR>\n<H2>Subtypes</H2>" << endl;

entout << "<! -- The following entities inherit from this one>\n";

subs = &( ent->Subtypes() );

entNode = ( EntityDescLinkNode * )subs->GetHead();

if( entNode ) {

entout << "<UL>" << endl;

EntityDescriptor * child;

while( entNode ) {

child = entNode->EntityDesc();

entout << "<LI><A HREF=\"" << child->Name() << ".html\">";

entout << child->Name() << "</A>" << endl;

entNode = ( EntityDescLinkNode * )entNode->NextNode();

}

entout << "</UL>" << endl;

} else {

entout << "<EM>none</EM>" << endl;

}

entout << "<HR>" << endl;

entout << "Click <A HREF=\"index.html\">here</A> to ";

entout << "return to the index." << endl;

}

root << "</UL>" << endl;

cout << "Done!" << endl;

}