-
Notifications
You must be signed in to change notification settings - Fork 131
Expand file tree
/
Copy pathSTEPaggrEnum.cc
More file actions
145 lines (116 loc) · 3.49 KB
/
STEPaggrEnum.cc
File metadata and controls
145 lines (116 loc) · 3.49 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
#include "clstepcore/STEPaggrEnum.h"
#include <sstream>
/** \file StepaggrEnum.cc
* implement classes EnumAggregate, LOGICALS, BOOLEANS, EnumNode
*/
/// COPY
STEPaggregate & EnumAggregate::ShallowCopy( const STEPaggregate & a ) {
const EnumNode * tmp = ( const EnumNode * ) a.GetHead();
EnumNode * to;
while( tmp ) {
to = ( EnumNode * ) NewNode();
to -> node -> put( tmp -> node ->asInt() );
AddNode( to );
tmp = ( const EnumNode * ) tmp -> NextNode();
}
if( head ) {
_null = 0;
} else {
_null = 1;
}
return *this;
}
EnumAggregate::EnumAggregate() {
}
EnumAggregate::~EnumAggregate() {
}
/******************************************************************
* * \returns a new EnumNode which is of the correct derived type
** \details creates a node to put in an list of enumerated values
** function is virtual so that the right node will be
** created
** Status: ok 2/91
******************************************************************/
SingleLinkNode * EnumAggregate::NewNode() {
// defined in subclass
cerr << "Internal error: " << __FILE__ << ": " << __LINE__ << "\n" ;
cerr << "function: EnumAggregate::NewNode () called instead of virtual function. \n"
<< _POC_ << "\n";
return 0;
}
LOGICALS::LOGICALS() {
}
LOGICALS::~LOGICALS() {
}
SingleLinkNode * LOGICALS::NewNode() {
return new EnumNode( new SDAI_LOGICAL );
}
LOGICALS * create_LOGICALS() {
return new LOGICALS;
}
BOOLEANS::BOOLEANS() {
}
BOOLEANS::~BOOLEANS() {
}
SingleLinkNode * BOOLEANS::NewNode() {
return new EnumNode( new SDAI_BOOLEAN );
}
BOOLEANS * create_BOOLEANS() {
return new BOOLEANS ;
}
EnumNode::EnumNode( SDAI_Enum * e ) : node( e ) {
}
EnumNode::EnumNode() {
}
EnumNode::~EnumNode() {
}
/// defined in subclass
SingleLinkNode * EnumNode::NewNode() {
cerr << "Internal error: " << __FILE__ << ": " << __LINE__ << "\n" ;
cerr << "function: EnumNode::NewNode () called instead of virtual function. \n"
<< _POC_ << "\n";
return 0;
}
/**
* non-whitespace chars following s are considered garbage and is an error.
* a valid value will still be assigned if it exists before the garbage.
*/
Severity EnumNode::StrToVal( const char * s, ErrorDescriptor * err ) {
return STEPread( s, err );
}
/**
* this function assumes you will check for garbage following input
*/
Severity EnumNode::StrToVal( istream & in, ErrorDescriptor * err ) {
return node->STEPread( in, err );
}
/**
* non-whitespace chars following s are considered garbage and is an error.
* a valid value will still be assigned if it exists before the garbage.
*/
Severity EnumNode::STEPread( const char * s, ErrorDescriptor * err ) {
istringstream in( ( char * )s ); // sz defaults to length of s
int nullable = 0;
node->STEPread( in, err, nullable );
CheckRemainingInput( in, err, "enumeration", ",)" );
return err->severity();
}
/**
* this function assumes you will check for garbage following input
*/
Severity EnumNode::STEPread( istream & in, ErrorDescriptor * err ) {
int nullable = 0;
node->STEPread( in, err, nullable );
return err->severity();
}
const char * EnumNode::asStr( std::string & s ) {
node -> asStr( s );
return const_cast<char *>( s.c_str() );
}
const char * EnumNode::STEPwrite( std::string & s, const char * ) {
node->STEPwrite( s );
return const_cast<char *>( s.c_str() );
}
void EnumNode::STEPwrite( ostream & out ) {
node->STEPwrite( out );
}