/*

* NIST STEP Core Class Library

* clstepcore/sdaiSelect.cc

* April 1997

* Dave Helfrick

* KC Morris

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

* and is not subject to copyright.

*/

#include <stdio.h> // to get the BUFSIZ #define

#include "clstepcore/ExpDict.h"

#include <sstream>

#include <string>

#include "clstepcore/sdai.h"

#include "clstepcore/STEPattribute.h"

#ifdef SC_LOGGING

#include <fstream.h>

extern ofstream * logStream;

#endif

/**********

(member) functions for the select class SDAI_Select

**********/

SDAI_Select::SDAI_Select( const SelectTypeDescriptor * s,

const TypeDescriptor * td )

: _type( s ), underlying_type( td ) {

#ifdef SC_LOGGING

*logStream << "Exiting SDAI_Select constructor." << endl;

#endif

}

SDAI_Select::SDAI_Select( const SDAI_Select & other ) {

underlying_type = other.underlying_type;

base_type = other.base_type;

_type = other._type;

#ifdef SC_LOGGING

*logStream << "Exiting SDAI_Select constructor." << endl;

#endif

}

SDAI_Select::~SDAI_Select() {

}

SDAI_Select & SDAI_Select::operator=( const SDAI_Select & other ) {

if( &other != this ) {

_error = other._error;

_type = other._type;

base_type = other.base_type;

underlying_type = other.underlying_type;

val = other.val;

}

return *this;

}

Severity SDAI_Select::severity() const {

return _error.severity();

}

Severity SDAI_Select::severity( Severity s ) {

return _error.severity( s );

}

std::string SDAI_Select::Error() {

return _error.DetailMsg();

}

void SDAI_Select::Error( const char * e ) {

_error.DetailMsg( e );

}

void SDAI_Select::ClearError() {

_error.ClearErrorMsg();

}

const TypeDescriptor *

SDAI_Select::CanBe( const char * n ) const {

return _type -> CanBe( n );

}

const TypeDescriptor *

SDAI_Select::CanBe( BASE_TYPE bt ) const {

const TypeDescLinkNode * tdn =

( const TypeDescLinkNode * ) _type -> GetElements().GetHead();

const TypeDescriptor * td = tdn -> TypeDesc();

BASE_TYPE bt_thisnode;

while( tdn ) {

td = tdn -> TypeDesc();

if( ( ( bt_thisnode = td -> NonRefType() ) == bt ) ||

( bt == AGGREGATE_TYPE && ( ( bt_thisnode == ARRAY_TYPE ) ||

( bt_thisnode == LIST_TYPE ) ||

( bt_thisnode == SET_TYPE ) ||

( bt_thisnode == BAG_TYPE ) ) ) ) {

return td; // they are the same

}

tdn = ( TypeDescLinkNode * )( tdn -> NextNode() );

}

return 0;

}

const TypeDescriptor *

SDAI_Select::CanBe( const TypeDescriptor * td ) const {

return _type -> CanBe( td );

}

const TypeDescriptor *

SDAI_Select::CanBeSet( const char * n, const char * schnm ) const {

return _type -> CanBeSet( n, schnm );

}

int

SDAI_Select::IsUnique( const BASE_TYPE bt ) const {

if( bt == ARRAY_TYPE ||

bt == LIST_TYPE ||

bt == BAG_TYPE ||

bt == SET_TYPE ) {

return ( ( _type->UniqueElements() ) & AGGREGATE_TYPE );

} else {

return ( ( _type->UniqueElements() ) & bt );

}

}

SDAI_String SDAI_Select::UnderlyingTypeName() const {

return underlying_type -> Name();

}

const TypeDescriptor * SDAI_Select::CurrentUnderlyingType() const {

return underlying_type;

}

const TypeDescriptor *

SDAI_Select::SetUnderlyingType( const TypeDescriptor * td ) {

// don\'t do anything if the descriptor is bad

if( !td || !( _type -> CanBe( td ) ) ) {

return 0;

}

base_type = td -> NonRefType();

return underlying_type = td;

}

bool SDAI_Select::exists() const {

return underlying_type != NULL;

}

void SDAI_Select::nullify() {

underlying_type = 0;

}

Severity SDAI_Select::SelectValidLevel( const char * attrValue, ErrorDescriptor * err,

InstMgrBase * im ) {

SDAI_Select * tmp = NewSelect();

Severity s = SEVERITY_NULL;

istringstream strtmp( attrValue );

s = tmp -> STEPread( strtmp, err, im );

delete tmp;

return s;

}

Severity SDAI_Select::StrToVal( const char * Val, const char * selectType,

ErrorDescriptor * err, InstMgrBase * instances ) {

severity( SEVERITY_NULL );

if( SetUnderlyingType( CanBe( selectType ) ) )

// the underlying type is set to a valid type

// call read on underlying type in subclass

switch( base_type ) {

case ENTITY_TYPE: {

STEPentity * tmp =

ReadEntityRef( Val, err, ",)", instances, 0 );

if( tmp && ( tmp != ENTITY_NULL ) ) {

AssignEntity( tmp );

return severity();

} else {

err->AppendToDetailMsg(

"Reference to entity that is not a valid type for SELECT.\n" );

nullify();

err->GreaterSeverity( SEVERITY_WARNING );

return SEVERITY_WARNING;

}

}

// call StrToVal on the contents

case STRING_TYPE:

case AGGREGATE_TYPE:

case ARRAY_TYPE: // DAS

case BAG_TYPE: // DAS

case SET_TYPE: // DAS

case LIST_TYPE: // DAS

case ENUM_TYPE:

case SELECT_TYPE:

case BOOLEAN_TYPE:

case LOGICAL_TYPE: {

err->GreaterSeverity( StrToVal_content( Val, instances ) );

if( _error.severity() != SEVERITY_NULL ) {

err->AppendFromErrorArg( &_error );

}

return err->severity();

}

// do the same as STEPread_content

case BINARY_TYPE:

case NUMBER_TYPE:

case REAL_TYPE:

case INTEGER_TYPE:

default: {

istringstream strtmp( Val );

err->GreaterSeverity( STEPread_content( strtmp ) );

if( _error.severity() != SEVERITY_NULL ) {

err->AppendFromErrorArg( &_error );

}

return err->severity();

}

}

return SEVERITY_INPUT_ERROR;

}

/** updated to Technical Corrigendum. DAS 2/4/97

* This function does the following:

*/

Severity SDAI_Select::STEPread( istream & in, ErrorDescriptor * err,

InstMgrBase * instances, const char * utype,

int addFileId, const char * currSch ) {

char c = '\0';

std::string tmp;

#ifdef SC_LOGGING

// *logStream << "DAVE ERR Entering SDAI_Select::STEPread." << endl;

#endif

// find out what case we have

// NOTE case C falls out of recursive calls in cases A and B

/**

** This section of code is used to read a value belonging to a select

** contained in another select. If you have read the text part of the

** TYPED_PARAMETER and it needs to fall down through some levels of contained

** select types, then the text is passed down to each select in the utype

** parameter as STEPread is called on each contained select type.DAS 2/4/97

*/

if( utype ) {

if( SetUnderlyingType( CanBeSet( utype, currSch ) ) ) {

// assign the value to the underlying type

in >> ws; // skip white space

if( ( underlying_type->Type() == REFERENCE_TYPE ) &&

( underlying_type->NonRefType() == sdaiSELECT ) ) {

// See comments below for a similar code segment.

STEPread_content( in, instances, 0, addFileId, currSch );

} else {

STEPread_content( in, instances, utype, addFileId, currSch );

}

err->AppendToDetailMsg( Error() );

err->GreaterSeverity( severity() );

}

return err->severity();

}

in >> ws;

in >> c;

/**

** the if part of this code reads a value according to the Technical

** Corrigendum for Part 21 (except for Entity instance refs which are read

** in the else part - everything else in the else stmt is invalid). The

** idea here is to read text and find out if it is specifying the final

** type or is a simple defined type which is typed to be a select some

** number of levels down. The first case will cause the value to be read

** directly by STEPread_content() or will cause STEPread_content() to pass

** the text naming the type to the underlying Select containing it. When

** the latter is the case, STEPread_content calls STEPread for the

** contained select and passes in the text. The convoluted case is when

** the text describes a simple defined type that translates directly into

** a select some number of levels down. In this case there will be more

** text inside the containing parens to indicate the type. Since the text

** specifying the type still needs to be read utype is passed as null which

** will cause the contained Select STEPread function to read it. DAS 2/4/97

*/

if( isalpha( c ) ) { // case B

int eot = 0; // end of token flag

// token is a type name - get the type

while( ( c != '(' ) && in.good() ) {

if( !eot && !( eot = isspace( c ) ) )

// as long as eot hasn\'t been reached keep appending

{

tmp += c;

}

in >> c;

}

// check for valid type and set the underlying type

if( SetUnderlyingType( CanBeSet( tmp.c_str(), currSch ) ) ) {

/**

** Assign the value to the underlying type. CanBeSet() is a

** slightly modified CanBe(). It ensures that a renamed select

** type (see big comment below) "CantBe" one of its member items.

** This is because such a select type requires its own name to

** appear first ("selX("), so even if we read a valid element of

** selX, selX can't be the underlying type. That can only be the

** case if "selX" appears first and is what we just read.

*/

in >> ws; // skip white space

if( ( underlying_type->Type() == REFERENCE_TYPE ) &&

( underlying_type->NonRefType() == sdaiSELECT ) ) {

/**

* This means (1) that the underlying type is itself a select

** (cond 2), and (2) it's not defined in the EXPRESS as a

** select, but as a renamed select. (E.g., TYPE sel2 = sel1.)

** In such a case, according to the TC, "sel2(" must appear in

** the text. (We must have found one for SetUnderlyingType()

** above to set underlying_type to sel2.) If all of the above

** is true, we read "sel2" but not the value of sel2. We

** therefore do not pass down what we read to STEPread_content

** below, so that we can still read the value of sel2. If,

** however, under_type was a non-renamed select, no "sel1"

** would appear (according to TC) and we already read the value

** of sel1. If so, we pass the already-read value down.

*/

STEPread_content( in, instances, 0, addFileId, currSch );

} else {

/**

** In most cases (see above note), we've already read the value

** we're interested in.

** This also handles all other cases? other than the if part

** above and elements of type entity ref?

*/

STEPread_content( in, instances, tmp.c_str(), addFileId,

currSch );

// STEPread_content uses the ErrorDesc data member from the

// SDAI_Select class

}

err->AppendToDetailMsg( Error() );

err->GreaterSeverity( severity() );

in >> ws >> c;

if( c != ')' ) {

err->AppendToDetailMsg(

"Bad data or missing closing ')' for SELECT type.\n" );

err->GreaterSeverity( SEVERITY_WARNING );

in.putback( c );

#ifdef SC_LOGGING

// *logStream << "DAVE ERR Exiting SDAI_Select::STEPread for " << _type->Name() << endl;

#endif

return SEVERITY_WARNING;

}

#ifdef SC_LOGGING

// *logStream << "DAVE ERR Exiting SDAI_Select::STEPread for " << _type->Name() << endl;

#endif

return err->severity();

} else { // ERROR -- the type wasn't one of the choices

if( !in.good() ) {

err->GreaterSeverity( SEVERITY_INPUT_ERROR );

#ifdef SC_LOGGING

// *logStream << "DAVE ERR Exiting SDAI_Select::STEPread for " << _type->Name() << endl;

#endif

return SEVERITY_INPUT_ERROR;

} else {

err->AppendToDetailMsg(

"The type name for the SELECT type is not valid.\n" );

err->GreaterSeverity( SEVERITY_WARNING );

#ifdef SC_LOGGING

// *logStream << "DAVE ERR Exiting SDAI_Select::STEPread for " << _type->Name() << endl;

#endif

return SEVERITY_WARNING;

}

}

}

/**

** NOTE **** anything that gets read below here is invalid according to the

** Technical Corrigendum for Part 21 (except for reading an entity instance

** where below is the only place they get read). I am leaving all of this

** here since it is valuable to 'read what you can' and flag an error which

** is what it does (for every type but entity instance refs). DAS 2/4/97

*/

else { /// case A

switch( c ) {

case '$':

nullify();

err->GreaterSeverity( SEVERITY_INCOMPLETE );

#ifdef SC_LOGGING

// *logStream << "DAVE ERR Exiting SDAI_Select::STEPread for " << _type->Name() << endl;

#endif

return SEVERITY_INCOMPLETE;

case ',':

case '\0':

// ERROR IN INPUT

in.putback( c );

err->AppendToDetailMsg( "No value found for SELECT type.\n" );

err->GreaterSeverity( SEVERITY_WARNING );

#ifdef SC_LOGGING

// *logStream << "DAVE ERR Exiting SDAI_Select::STEPread for " << _type->Name() << endl;

#endif

return SEVERITY_WARNING;

case '.': // assign enum

base_type = ENUM_TYPE;

err->AppendToDetailMsg( "Invalid Enumeration, Logical, or Boolean value in SELECT type.\n" );

err->GreaterSeverity( SEVERITY_WARNING );

break;

// set the underlying type

// call STEPread

// return

case '\'': // assign string

base_type = STRING_TYPE;

err->AppendToDetailMsg( "Invalid String value in SELECT type.\n" );

err->GreaterSeverity( SEVERITY_WARNING );

break;

case '"': // assign string

base_type = BINARY_TYPE;

err->AppendToDetailMsg( "Invalid Binary value in SELECT type.\n" );

err->GreaterSeverity( SEVERITY_WARNING );

break;

case '#':

base_type = ENTITY_TYPE;

break;

// call STEPread_reference

// set the underlying type

// assign entity

// read the reference

// match type to underlying type

// assign the value

// set the underlying type

case '(': {

err->AppendToDetailMsg( "Invalid aggregate value in SELECT type.\n" );

err->GreaterSeverity( SEVERITY_WARNING );

char n;

in >> n;

in.putback( n );

if( isalpha( n ) ) {

base_type = SELECT_TYPE;

} else {

base_type = AGGREGATE_TYPE;

}

break;

}

case '0':

case '1':

case '2':

case '3':

case '4':

case '5':

case '6':

case '7':

case '8':

case '9':

case '-':

err->AppendToDetailMsg( "Invalid Integer or Real value in SELECT type.\n" );

err->GreaterSeverity( SEVERITY_WARNING );

if( CanBe( REAL_TYPE ) ) {

base_type = REAL_TYPE;

} else {

base_type = INTEGER_TYPE;

}

break;

default:

// ambiguous - ERROR: underlying type should have been set

err->AppendToDetailMsg(

"type for SELECT could not be determined from value.\n" );

nullify();

in.putback( c );

err->GreaterSeverity( SEVERITY_WARNING );

#ifdef SC_LOGGING

// *logStream << "DAVE ERR Exiting SDAI_Select::STEPread for " << _type->Name() << endl;

#endif

return SEVERITY_WARNING;

}

in.putback( c );

// now the type descriptor should be derivable from the base_type

// if it's not issue a warning

if( _type && !( IsUnique( base_type ) ) ) {

err->AppendToDetailMsg( "Value for SELECT will be assigned to first possible choice.\n" );

err->GreaterSeverity( SEVERITY_USERMSG );

}

if( base_type == ENTITY_TYPE ) {

// you don't know if this is an ENTITY or a SELECT

// have to do this here - not in STEPread_content

STEPentity * temp =

ReadEntityRef( in, err, ",)", instances, addFileId );

if( temp && ( temp != ENTITY_NULL ) && AssignEntity( temp ) ) {

#ifdef SC_LOGGING

// *logStream << "DAVE ERR Exiting SDAI_Select::STEPread for " << _type->Name() << endl;

#endif

return SEVERITY_NULL;

} else {

err->AppendToDetailMsg(

"Reference to entity that is not a valid type for SELECT.\n" );

nullify();

err->GreaterSeverity( SEVERITY_WARNING );

#ifdef SC_LOGGING

// *logStream << "DAVE ERR Exiting SDAI_Select::STEPread for " << _type->Name() << endl;

#endif

return SEVERITY_WARNING;

}

} else if( SetUnderlyingType( CanBe( base_type ) ) ) {

STEPread_content( in, instances, 0, addFileId );

}

else { // ERROR -- the type wasn't one of the choices

err->AppendToDetailMsg(

"The type of the SELECT type is not valid.\n" );

err->GreaterSeverity( SEVERITY_WARNING );

#ifdef SC_LOGGING

// *logStream << "DAVE ERR Exiting SDAI_Select::STEPread for " << _type->Name() << endl;

#endif

return SEVERITY_WARNING;

}

}

// if (!in.good()) severity (SEVERITY_INPUT_ERROR);

#ifdef SC_LOGGING

// *logStream << "DAVE ERR Exiting SDAI_Select::STEPread for " << _type->Name() << endl;

#endif

return err->severity();

}

/// updated to Technical Corrigendum DAS Feb 4, 1997

void SDAI_Select::STEPwrite( ostream & out, const char * currSch ) const {

if( !exists() ) {

out << "$";

return;

}

switch( underlying_type->NonRefType() ) {

case sdaiINSTANCE: {

STEPwrite_content( out );

break;

}

case sdaiSELECT: { // The name of a select is never written DAS 1/31/97

if( underlying_type->Type() == REFERENCE_TYPE ) {

std::string s;

out << StrToUpper( underlying_type->Name( currSch ), s ) << "(";

STEPwrite_content( out, currSch );

out << ")";

} else {

STEPwrite_content( out, currSch );

}

break;

}

case sdaiNUMBER:

case sdaiREAL:

case sdaiINTEGER:

case sdaiSTRING:

case sdaiBOOLEAN:

case sdaiLOGICAL:

case sdaiBINARY:

case sdaiENUMERATION:

case sdaiAGGR:

case ARRAY_TYPE:

case BAG_TYPE:

case SET_TYPE:

case LIST_TYPE: {

STEPwrite_verbose( out, currSch );

break;

}

case REFERENCE_TYPE: // this should never happen? DAS

default:

out << "ERROR Should not have gone here in SDAI_Select::STEPwrite()"

<< endl;

}

}

void SDAI_Select::STEPwrite_verbose( ostream & out, const char * currSch ) const {

std::string tmp;

out << StrToUpper( CurrentUnderlyingType()->Name( currSch ), tmp ) << "(";

STEPwrite_content( out );

out << ")";

}

const char * SDAI_Select::STEPwrite( std::string & s, const char * currSch ) const {

ostringstream buf;

STEPwrite( buf, currSch );

buf << ends; // add the terminating \0 char

s = buf.str();

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

}

bool SDAI_Select::set_null() {

nullify();

return true;

}

bool SDAI_Select::is_null() {

return ( !exists() );

}