1 #ifndef STEPAGGREGATE_H 2 #define STEPAGGREGATE_H 3 4 /* 5 * NIST STEP Core Class Library 6 * clstepcore/STEPaggregate.h 7 * April 1997 8 * K. C. Morris 9 * David Sauder 10 11 * Development of this software was funded by the United States Government, 12 * and is not subject to copyright. 13 */ 14 15 class InstMgrBase; 16 class STEPaggregate; 17 class TypeDescriptor; 18 19 #include <sc_export.h> 20 #include <errordesc.h> 21 #include <SingleLinkList.h> 22 #include <baseType.h> 23 #include <sdai.h> 24 #include <STEPundefined.h> 25 #include <string> 26 27 #define AGGR_NULL &NilSTEPaggregate 28 extern STEPaggregate NilSTEPaggregate; 29 30 class SingleLinkNode; 31 32 33 typedef STEPaggregate * STEPaggregateH; 34 typedef STEPaggregate * STEPaggregate_ptr; 35 typedef STEPaggregate_ptr STEPaggregate_var; 36 37 class SC_CORE_EXPORT STEPaggregate : public SingleLinkList { 38 protected: 39 int _null; 40 41 protected: 42 43 virtual Severity ReadValue( istream & in, ErrorDescriptor * err, 44 const TypeDescriptor * elem_type, 45 InstMgrBase * insts, int addFileId = 0, 46 int assignVal = 1, int ExchangeFileFormat = 1, 47 const char * currSch = 0 ); 48 public: 49 is_null()50 int is_null() { 51 return _null; 52 } 53 54 virtual Severity AggrValidLevel( const char * value, ErrorDescriptor * err, 55 const TypeDescriptor * elem_type, InstMgrBase * insts, 56 int optional, char * tokenList, int addFileId = 0, 57 int clearError = 0 ); 58 59 virtual Severity AggrValidLevel( istream & in, ErrorDescriptor * err, 60 const TypeDescriptor * elem_type, InstMgrBase * insts, 61 int optional, char * tokenList, int addFileId = 0, 62 int clearError = 0 ); 63 64 // INPUT 65 virtual Severity StrToVal( const char * s, ErrorDescriptor * err = 0, 66 const TypeDescriptor * elem_type = 0, 67 InstMgrBase * insts = 0, int addFileId = 0 ); 68 virtual Severity STEPread( istream & in, ErrorDescriptor * err, 69 const TypeDescriptor * elem_type = 0, 70 InstMgrBase * insts = 0, int addFileId = 0, 71 const char * currSch = 0 ); 72 // OUTPUT 73 virtual const char * asStr( std::string & s ) const; 74 virtual void STEPwrite( ostream & out = cout, const char * = 0 ) const; 75 76 virtual SingleLinkNode * NewNode(); 77 void AddNode( SingleLinkNode * ); 78 void Empty(); 79 80 STEPaggregate(); 81 virtual ~STEPaggregate(); 82 83 // COPY - defined in subtypes 84 virtual STEPaggregate & ShallowCopy( const STEPaggregate & ); 85 }; 86 87 /****************************************************************//** 88 ** \class GenericAggregate 89 ** This class supports LIST OF: 90 ** SELECT_TYPE, BINARY_TYPE, GENERIC_TYPE, ENUM_TYPE, UNKNOWN_TYPE type 91 ** FIXME this class, as well as SelectAggregate, for SELECTs?! 92 ******************************************************************/ 93 class SC_CORE_EXPORT GenericAggregate : public STEPaggregate { 94 public: 95 virtual SingleLinkNode * NewNode(); 96 virtual STEPaggregate & ShallowCopy( const STEPaggregate & ); 97 98 GenericAggregate(); 99 virtual ~GenericAggregate(); 100 }; 101 typedef GenericAggregate * GenericAggregateH; 102 typedef GenericAggregate * GenericAggregate_ptr; 103 typedef const GenericAggregate * GenericAggregate_ptr_c; 104 typedef GenericAggregate_ptr GenericAggregate_var; 105 106 /****************************************************************************** 107 ** 108 *****************************************************************************/ 109 110 class SC_CORE_EXPORT EntityAggregate : public STEPaggregate { 111 public: 112 virtual Severity ReadValue( istream & in, ErrorDescriptor * err, 113 const TypeDescriptor * elem_type, 114 InstMgrBase * insts, int addFileId = 0, 115 int assignVal = 1, int ExchangeFileFormat = 1, 116 const char * currSch = 0 ); 117 118 virtual SingleLinkNode * NewNode(); 119 virtual STEPaggregate & ShallowCopy( const STEPaggregate & ); 120 121 EntityAggregate(); 122 virtual ~EntityAggregate(); 123 }; 124 typedef EntityAggregate * EntityAggregateH; 125 typedef EntityAggregate * EntityAggregate_ptr; 126 typedef const EntityAggregate * EntityAggregate_ptr_c; 127 typedef EntityAggregate_ptr EntityAggregate_var; 128 129 /****************************************************************//** 130 ** \class SelectAggregate 131 ** This is a minimal represention for a collection of SDAI_Select 132 ******************************************************************/ 133 class SC_CORE_EXPORT SelectAggregate : public STEPaggregate { 134 public: 135 virtual Severity ReadValue( istream & in, ErrorDescriptor * err, 136 const TypeDescriptor * elem_type, 137 InstMgrBase * insts, int addFileId = 0, 138 int assignVal = 1, int ExchangeFileFormat = 1, 139 const char * currSch = 0 ); 140 141 virtual SingleLinkNode * NewNode(); 142 virtual STEPaggregate & ShallowCopy( const STEPaggregate & ); 143 144 SelectAggregate(); 145 virtual ~SelectAggregate(); 146 }; 147 typedef SelectAggregate * SelectAggregateH; 148 typedef SelectAggregate * SelectAggregate_ptr; 149 typedef const SelectAggregate * SelectAggregate_ptr_c; 150 typedef SelectAggregate_ptr SelectAggregate_var; 151 152 /****************************************************************//** 153 ** \class StringAggregate 154 ** This class supports LIST OF STRING type 155 ******************************************************************/ 156 class SC_CORE_EXPORT StringAggregate : public STEPaggregate { 157 public: 158 virtual SingleLinkNode * NewNode(); 159 virtual STEPaggregate & ShallowCopy( const STEPaggregate & ); 160 161 StringAggregate(); 162 virtual ~StringAggregate(); 163 }; 164 typedef StringAggregate * StringAggregateH; 165 typedef StringAggregate * StringAggregate_ptr; 166 typedef const StringAggregate * StringAggregate_ptr_c; 167 typedef StringAggregate_ptr StringAggregate_var; 168 169 170 /****************************************************************//** 171 ** \class BinaryAggregate 172 ** This class supports LIST OF BINARY type 173 ******************************************************************/ 174 class SC_CORE_EXPORT BinaryAggregate : public STEPaggregate { 175 public: 176 virtual SingleLinkNode * NewNode(); 177 virtual STEPaggregate & ShallowCopy( const STEPaggregate & ); 178 179 BinaryAggregate(); 180 virtual ~BinaryAggregate(); 181 }; 182 typedef BinaryAggregate * BinaryAggregateH; 183 typedef BinaryAggregate * BinaryAggregate_ptr; 184 typedef const BinaryAggregate * BinaryAggregate_ptr_c; 185 typedef BinaryAggregate_ptr BinaryAggregate_var; 186 187 /**************************************************************//** 188 ** \class EnumAggregate 189 ** This is a minimal representions for a collection ofSDAI_Enum 190 ******************************************************************/ 191 class SC_CORE_EXPORT EnumAggregate : public STEPaggregate { 192 public: 193 virtual SingleLinkNode * NewNode(); 194 virtual STEPaggregate & ShallowCopy( const STEPaggregate & ); 195 196 EnumAggregate(); 197 virtual ~EnumAggregate(); 198 }; 199 typedef EnumAggregate * EnumAggregateH; 200 typedef EnumAggregate * EnumAggregate_ptr; 201 typedef const EnumAggregate * EnumAggregate_ptr_c; 202 typedef EnumAggregate_ptr EnumAggregate_var; 203 204 class SC_CORE_EXPORT LOGICALS : public EnumAggregate { 205 public: 206 virtual SingleLinkNode * NewNode(); 207 208 LOGICALS(); 209 virtual ~LOGICALS(); 210 }; 211 typedef LOGICALS * LogicalsH; 212 typedef LOGICALS * LOGICALS_ptr; 213 typedef const LOGICALS * LOGICALS_ptr_c; 214 typedef LOGICALS_ptr LOGICALS_var; 215 SC_CORE_EXPORT LOGICALS * create_LOGICALS(); 216 217 218 class SC_CORE_EXPORT BOOLEANS : public EnumAggregate { 219 public: 220 virtual SingleLinkNode * NewNode(); 221 222 BOOLEANS(); 223 virtual ~BOOLEANS(); 224 }; 225 226 typedef BOOLEANS * BOOLEANS_ptr; 227 typedef const BOOLEANS * BOOLEANS_ptr_c; 228 typedef BOOLEANS_ptr BOOLEANS_var; 229 230 SC_CORE_EXPORT BOOLEANS * create_BOOLEANS(); 231 232 class SC_CORE_EXPORT RealAggregate : public STEPaggregate { 233 234 public: 235 virtual SingleLinkNode * NewNode(); 236 virtual STEPaggregate & ShallowCopy( const STEPaggregate & ); 237 238 RealAggregate(); 239 virtual ~RealAggregate(); 240 }; 241 typedef RealAggregate * RealAggregateH; 242 typedef RealAggregate * RealAggregate_ptr; 243 typedef const RealAggregate * RealAggregate_ptr_c; 244 typedef RealAggregate_ptr RealAggregate_var; 245 246 class SC_CORE_EXPORT IntAggregate : public STEPaggregate { 247 248 public: 249 virtual SingleLinkNode * NewNode(); 250 virtual STEPaggregate & ShallowCopy( const STEPaggregate & ); 251 252 IntAggregate(); 253 virtual ~IntAggregate(); 254 }; 255 typedef IntAggregate * IntAggregateH; 256 typedef IntAggregate * IntAggregate_ptr; 257 typedef const IntAggregate * IntAggregate_ptr_c; 258 typedef IntAggregate_ptr IntAggregate_var; 259 260 /////////////////////////////////////////////////////////////////////////////// 261 262 class SC_CORE_EXPORT STEPnode : public SingleLinkNode { 263 protected: 264 int _null; 265 266 public: is_null()267 int is_null() { 268 return _null; 269 } set_null()270 void set_null() { 271 _null = 1; 272 } 273 274 // INPUT 275 virtual Severity StrToVal( const char * s, ErrorDescriptor * err ); 276 virtual Severity StrToVal( istream & in, ErrorDescriptor * err ); 277 278 virtual Severity STEPread( const char * s, ErrorDescriptor * err ); 279 virtual Severity STEPread( istream & in, ErrorDescriptor * err ); 280 281 // OUTPUT 282 virtual const char * asStr( std::string & s ); 283 virtual const char * STEPwrite( std::string & s, const char * = 0 ); 284 virtual void STEPwrite( ostream & out = cout ); 285 }; 286 287 /**************************************************************//** 288 ** \class GenericAggregate 289 ** This class is for the Nodes of GenericAggregates 290 ******************************************************************/ 291 typedef STEPnode * STEPnodeH; 292 class SC_CORE_EXPORT GenericAggrNode : public STEPnode { 293 public: 294 SCLundefined value; 295 // INPUT 296 virtual Severity StrToVal( const char * s, ErrorDescriptor * err ); 297 virtual Severity StrToVal( istream & in, ErrorDescriptor * err ); 298 299 virtual Severity STEPread( const char * s, ErrorDescriptor * err ); 300 virtual Severity STEPread( istream & in, ErrorDescriptor * err ); 301 302 // OUTPUT 303 virtual const char * asStr( std::string & s ); 304 virtual const char * STEPwrite( std::string & s, const char * = 0 ); 305 virtual void STEPwrite( ostream & out = cout ); 306 307 // CONSTRUCTORS 308 GenericAggrNode( const char * str ); 309 GenericAggrNode( GenericAggrNode & gan ); 310 GenericAggrNode(); 311 ~GenericAggrNode(); 312 313 virtual SingleLinkNode * NewNode(); 314 }; 315 316 ///////////////////////////////////////////////////////////////////////////// 317 318 class SC_CORE_EXPORT EntityNode : public STEPnode { 319 public: 320 SDAI_Application_instance * node; 321 322 // INPUT 323 virtual Severity StrToVal( const char * s, ErrorDescriptor * err, 324 const TypeDescriptor * elem_type, 325 InstMgrBase * insts, int addFileId = 0 ); 326 virtual Severity StrToVal( istream & in, ErrorDescriptor * err, 327 const TypeDescriptor * elem_type, 328 InstMgrBase * insts, int addFileId = 0 ); 329 330 virtual Severity STEPread( const char * s, ErrorDescriptor * err, 331 const TypeDescriptor * elem_type, 332 InstMgrBase * insts, int addFileId = 0 ); 333 virtual Severity STEPread( istream & in, ErrorDescriptor * err, 334 const TypeDescriptor * elem_type, 335 InstMgrBase * insts, int addFileId = 0 ); 336 // OUTPUT 337 virtual const char * asStr( std::string & s ); 338 virtual const char * STEPwrite( std::string & s, const char * = 0 ); 339 virtual void STEPwrite( ostream & out = cout ); 340 341 // CONSTRUCTORS 342 EntityNode( SDAI_Application_instance * e ); 343 EntityNode(); 344 ~EntityNode(); 345 346 virtual SingleLinkNode * NewNode(); 347 348 // Calling these funtions is an error. StrToVal(const char * s,ErrorDescriptor * err)349 Severity StrToVal( const char * s, ErrorDescriptor * err ) { 350 cerr << "Internal error: " << __FILE__ << __LINE__ 351 << "\n" << _POC_ "\n"; 352 return StrToVal( s, err, 0, 0, 0 ); 353 } StrToVal(istream & in,ErrorDescriptor * err)354 Severity StrToVal( istream & in, ErrorDescriptor * err ) { 355 cerr << "Internal error: " << __FILE__ << __LINE__ 356 << "\n" << _POC_ "\n"; 357 return StrToVal( in, err, 0, 0, 0 ); 358 } 359 STEPread(const char * s,ErrorDescriptor * err)360 Severity STEPread( const char * s, ErrorDescriptor * err ) { 361 cerr << "Internal error: " << __FILE__ << __LINE__ 362 << "\n" << _POC_ "\n"; 363 return STEPread( s, err, 0, 0, 0 ); 364 } STEPread(istream & in,ErrorDescriptor * err)365 Severity STEPread( istream & in, ErrorDescriptor * err ) { 366 cerr << "Internal error: " << __FILE__ << __LINE__ 367 << "\n" << _POC_ "\n"; 368 return STEPread( in, err, 0, 0, 0 ); 369 } 370 }; 371 372 /////////////////////////////////////////////////////////////////////////// 373 374 /**************************************************************//** 375 ** \class SelectNode 376 ** This is a minimal representions for node in lists of SDAI_Select 377 ******************************************************************/ 378 class SC_CORE_EXPORT SelectNode : public STEPnode { 379 public: 380 SDAI_Select * node; 381 // INPUT 382 virtual Severity StrToVal( const char * s, ErrorDescriptor * err, 383 const TypeDescriptor * elem_type, 384 InstMgrBase * insts, int addFileId = 0 ); 385 virtual Severity StrToVal( istream & in, ErrorDescriptor * err, 386 const TypeDescriptor * elem_type, 387 InstMgrBase * insts, int addFileId = 0, 388 const char * currSch = 0 ); 389 390 virtual Severity STEPread( const char * s, ErrorDescriptor * err, 391 const TypeDescriptor * elem_type, 392 InstMgrBase * insts, int addFileId = 0 ); 393 virtual Severity STEPread( istream & in, ErrorDescriptor * err, 394 const TypeDescriptor * elem_type, 395 InstMgrBase * insts, int addFileId = 0, 396 const char * currSch = 0 ); 397 // OUTPUT 398 virtual const char * asStr( std::string & s ); 399 virtual const char * STEPwrite( std::string & s, const char * = 0 ); 400 virtual void STEPwrite( ostream & out = cout ); 401 402 // CONSTRUCTORS 403 SelectNode( SDAI_Select * s ); 404 SelectNode(); 405 ~SelectNode(); 406 407 virtual SingleLinkNode * NewNode(); 408 409 // Calling these funtions is an error. StrToVal(const char * s,ErrorDescriptor * err)410 Severity StrToVal( const char * s, ErrorDescriptor * err ) { 411 cerr << "Internal error: " << __FILE__ << __LINE__ 412 << "\n" << _POC_ "\n"; 413 return StrToVal( s, err, 0, 0, 0 ); 414 } StrToVal(istream & in,ErrorDescriptor * err)415 Severity StrToVal( istream & in, ErrorDescriptor * err ) { 416 cerr << "Internal error: " << __FILE__ << __LINE__ 417 << "\n" << _POC_ "\n"; 418 return StrToVal( in, err, 0, 0, 0 ); 419 } 420 STEPread(const char * s,ErrorDescriptor * err)421 Severity STEPread( const char * s, ErrorDescriptor * err ) { 422 cerr << "Internal error: " << __FILE__ << __LINE__ 423 << "\n" << _POC_ "\n"; 424 return STEPread( s, err, 0, 0, 0 ); 425 } STEPread(istream & in,ErrorDescriptor * err)426 Severity STEPread( istream & in, ErrorDescriptor * err ) { 427 cerr << "Internal error: " << __FILE__ << __LINE__ 428 << "\n" << _POC_ "\n"; 429 return STEPread( in, err, 0, 0, 0 ); 430 } 431 }; 432 433 /**************************************************************//** 434 ** \class StringNode 435 ** This class is for the Nodes of StringAggregates 436 ******************************************************************/ 437 class SC_CORE_EXPORT StringNode : public STEPnode { 438 public: 439 SDAI_String value; 440 // INPUT 441 virtual Severity StrToVal( const char * s, ErrorDescriptor * err ); 442 virtual Severity StrToVal( istream & in, ErrorDescriptor * err ); 443 444 virtual Severity STEPread( const char * s, ErrorDescriptor * err ); 445 virtual Severity STEPread( istream & in, ErrorDescriptor * err ); 446 447 // OUTPUT 448 virtual const char * asStr( std::string & s ); 449 virtual const char * STEPwrite( std::string & s, const char * = 0 ); 450 virtual void STEPwrite( ostream & out = cout ); 451 452 // CONSTRUCTORS 453 StringNode( StringNode & sn ); 454 StringNode( const char * sStr ); 455 StringNode(); 456 ~StringNode(); 457 458 virtual SingleLinkNode * NewNode(); 459 }; 460 461 /////////////////////////////////////////////////////////////////////////// 462 463 /**************************************************************//** 464 ** \class BinaryNode 465 ** This class is for the Nodes of BinaryAggregates 466 ******************************************************************/ 467 class SC_CORE_EXPORT BinaryNode : public STEPnode { 468 public: 469 SDAI_Binary value; 470 // INPUT 471 virtual Severity StrToVal( const char * s, ErrorDescriptor * err ); 472 virtual Severity StrToVal( istream & in, ErrorDescriptor * err ); 473 474 virtual Severity STEPread( const char * s, ErrorDescriptor * err ); 475 virtual Severity STEPread( istream & in, ErrorDescriptor * err ); 476 477 // OUTPUT 478 virtual const char * asStr( std::string & s ); 479 virtual const char * STEPwrite( std::string & s, const char * = 0 ); 480 virtual void STEPwrite( ostream & out = cout ); 481 482 // CONSTRUCTORS 483 BinaryNode( BinaryNode & bn ); 484 BinaryNode( const char * sStr ); 485 BinaryNode(); 486 ~BinaryNode(); 487 488 virtual SingleLinkNode * NewNode(); 489 }; 490 491 /**************************************************************//** 492 ** \class EnumNode 493 ** This is a minimal representions for node in lists of SDAI_Enum 494 ******************************************************************/ 495 class SC_CORE_EXPORT EnumNode : public STEPnode { 496 public: 497 SDAI_Enum * node; 498 // INPUT 499 virtual Severity StrToVal( const char * s, ErrorDescriptor * err ); 500 virtual Severity StrToVal( istream & in, ErrorDescriptor * err ); 501 502 virtual Severity STEPread( const char * s, ErrorDescriptor * err ); 503 virtual Severity STEPread( istream & in, ErrorDescriptor * err ); 504 505 // OUTPUT 506 virtual const char * asStr( std::string & s ); 507 virtual const char * STEPwrite( std::string & s, const char * = 0 ); 508 virtual void STEPwrite( ostream & out = cout ); 509 510 // CONSTRUCTORS 511 EnumNode( SDAI_Enum * e ); 512 EnumNode(); 513 ~EnumNode(); 514 515 virtual SingleLinkNode * NewNode(); 516 }; 517 518 class SC_CORE_EXPORT RealNode : public STEPnode { 519 public: 520 SDAI_Real value; // double 521 // INPUT 522 virtual Severity StrToVal( const char * s, ErrorDescriptor * err ); 523 virtual Severity StrToVal( istream & in, ErrorDescriptor * err ); 524 525 virtual Severity STEPread( const char * s, ErrorDescriptor * err ); 526 virtual Severity STEPread( istream & in, ErrorDescriptor * err ); 527 528 // OUTPUT 529 virtual const char * asStr( std::string & s ); 530 virtual const char * STEPwrite( std::string & s, const char * = 0 ); 531 virtual void STEPwrite( ostream & out = cout ); 532 533 // CONSTRUCTORS 534 RealNode( SDAI_Real v ); 535 RealNode(); 536 ~RealNode(); 537 538 virtual SingleLinkNode * NewNode(); 539 }; 540 541 class SC_CORE_EXPORT IntNode : public STEPnode { 542 public: 543 SDAI_Integer value; // long int 544 // INPUT 545 virtual Severity StrToVal( const char * s, ErrorDescriptor * err ); 546 virtual Severity StrToVal( istream & in, ErrorDescriptor * err ); 547 548 virtual Severity STEPread( const char * s, ErrorDescriptor * err ); 549 virtual Severity STEPread( istream & in, ErrorDescriptor * err ); 550 551 // OUTPUT 552 virtual const char * asStr( std::string & s ); 553 virtual const char * STEPwrite( std::string & s, const char * = 0 ); 554 virtual void STEPwrite( ostream & out = cout ); 555 556 // CONSTRUCTORS 557 IntNode( SDAI_Integer v ); 558 IntNode(); 559 ~IntNode(); 560 561 virtual SingleLinkNode * NewNode(); 562 }; 563 564 /****************************************************************** 565 ** FIXME The following classes are currently stubs 566 ** 567 **/ 568 /* 569 class Array : public STEPaggregate { 570 public: 571 int lowerBound; 572 int upperBound; 573 }; 574 575 class Bag : public STEPaggregate { 576 public: 577 int min_ele; 578 int max_ele; 579 }; 580 581 class List : public STEPaggregate { 582 int min_ele; 583 int max_ele; 584 List *prev; 585 }; 586 587 class Set : 588 public STEPaggregate { 589 int cnt; 590 }; 591 */ 592 #endif 593