b311480e |
1 | // Created on: 1992-06-24 |
2 | // Created by: Gilles DEBARBOUILLE |
3 | // Copyright (c) 1992-1999 Matra Datavision |
973c2be1 |
4 | // Copyright (c) 1999-2014 OPEN CASCADE SAS |
b311480e |
5 | // |
973c2be1 |
6 | // This file is part of Open CASCADE Technology software library. |
b311480e |
7 | // |
d5f74e42 |
8 | // This library is free software; you can redistribute it and/or modify it under |
9 | // the terms of the GNU Lesser General Public License version 2.1 as published |
973c2be1 |
10 | // by the Free Software Foundation, with special exception defined in the file |
11 | // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT |
12 | // distribution for complete text of the license and disclaimer of any warranty. |
b311480e |
13 | // |
973c2be1 |
14 | // Alternatively, this file may be used under the terms of Open CASCADE |
15 | // commercial license or contractual agreement. |
b311480e |
16 | |
7fd59977 |
17 | // Updated: Gerard GRAS le 090597 |
18 | // reason is PRO6934 -> plantage sur HP 10.2 |
19 | // changes are : Replace the field theword,themean from HAsciiString |
20 | // to AsciiString. |
21 | // because the compiler try to destroies the handle of HAsciiString to early |
22 | // due to inline use probably. |
23 | // See also Units_Token.lxx |
24 | |
7fd59977 |
25 | // Mauvaise construction d'un token par copie |
26 | // plantatoire sur HP. |
27 | |
28 | #include <Units_Token.ixx> |
29 | #include <TCollection_AsciiString.hxx> |
30 | #include <Units_Operators.hxx> |
31 | |
7fd59977 |
32 | //======================================================================= |
33 | //function : Units_Token |
34 | //purpose : |
35 | //======================================================================= |
36 | |
37 | Units_Token::Units_Token() |
38 | { |
39 | theword=" "; |
40 | themean=" "; |
41 | thevalue=0.; |
42 | thedimensions=new Units_Dimensions(0.,0.,0.,0.,0.,0.,0.,0.,0.); |
7fd59977 |
43 | } |
44 | |
45 | //======================================================================= |
46 | //function : Units_Token |
47 | //purpose : |
48 | //======================================================================= |
49 | |
50 | Units_Token::Units_Token(const Standard_CString aword) |
51 | { |
52 | theword=aword; |
53 | themean=" "; |
54 | thevalue=0.; |
55 | thedimensions=new Units_Dimensions(0.,0.,0.,0.,0.,0.,0.,0.,0.); |
7fd59977 |
56 | } |
57 | |
58 | //======================================================================= |
59 | //function : Units_Token |
60 | //purpose : |
61 | //======================================================================= |
62 | |
63 | Units_Token::Units_Token(const Standard_CString aword, |
64 | const Standard_CString amean) |
65 | { |
66 | theword=aword; |
67 | themean=amean; |
68 | thevalue=0.; |
69 | thedimensions=new Units_Dimensions(0.,0.,0.,0.,0.,0.,0.,0.,0.); |
7fd59977 |
70 | } |
71 | |
72 | //======================================================================= |
73 | //function : Units_Token |
74 | //purpose : |
75 | //======================================================================= |
76 | |
77 | Units_Token::Units_Token(const Standard_CString aword, |
78 | const Standard_CString amean, |
79 | const Standard_Real avalue) |
80 | { |
81 | theword=aword; |
82 | themean=amean; |
83 | thevalue=avalue; |
84 | thedimensions=new Units_Dimensions(0.,0.,0.,0.,0.,0.,0.,0.,0.); |
7fd59977 |
85 | } |
86 | |
87 | //======================================================================= |
88 | //function : Units_Token |
89 | //purpose : |
90 | //======================================================================= |
91 | |
92 | Units_Token::Units_Token(const Standard_CString aword, |
93 | const Standard_CString amean, |
94 | const Standard_Real avalue, |
95 | const Handle(Units_Dimensions)& adimensions) |
96 | { |
97 | theword=aword; |
98 | themean=amean; |
99 | thevalue=avalue; |
100 | if(adimensions.IsNull()) |
101 | thedimensions = new Units_Dimensions(0.,0.,0.,0.,0.,0.,0.,0.,0.); |
102 | else |
103 | thedimensions = new Units_Dimensions(adimensions->Mass(), |
104 | adimensions->Length(), |
105 | adimensions->Time(), |
106 | adimensions->ElectricCurrent(), |
107 | adimensions->ThermodynamicTemperature(), |
108 | adimensions->AmountOfSubstance(), |
109 | adimensions->LuminousIntensity(), |
110 | adimensions->PlaneAngle(), |
111 | adimensions->SolidAngle()); |
7fd59977 |
112 | } |
113 | |
114 | //======================================================================= |
115 | //function : Creates |
116 | //purpose : |
117 | //======================================================================= |
118 | |
119 | Handle(Units_Token) Units_Token::Creates() const |
120 | { |
7fd59977 |
121 | TCollection_AsciiString word = Word(); |
122 | TCollection_AsciiString mean = Mean(); |
123 | return new Units_Token(word.ToCString(),mean.ToCString(),Value(),Dimensions()); |
7fd59977 |
124 | } |
125 | |
126 | //======================================================================= |
127 | //function : Length |
128 | //purpose : |
129 | //======================================================================= |
130 | |
131 | Standard_Integer Units_Token::Length() const |
132 | { |
133 | return theword.Length(); |
134 | } |
135 | |
136 | //======================================================================= |
137 | //function : Dimensions |
138 | //purpose : |
139 | //======================================================================= |
140 | |
141 | void Units_Token::Dimensions(const Handle(Units_Dimensions)& adimensions) |
142 | { |
143 | if(adimensions.IsNull()) |
144 | thedimensions = new Units_Dimensions(0.,0.,0.,0.,0.,0.,0.,0.,0.); |
145 | else |
146 | thedimensions = new Units_Dimensions(adimensions->Mass(), |
147 | adimensions->Length(), |
148 | adimensions->Time(), |
149 | adimensions->ElectricCurrent(), |
150 | adimensions->ThermodynamicTemperature(), |
151 | adimensions->AmountOfSubstance(), |
152 | adimensions->LuminousIntensity(), |
153 | adimensions->PlaneAngle(), |
154 | adimensions->SolidAngle()); |
155 | } |
156 | |
157 | //======================================================================= |
158 | //function : Units_Token |
159 | //purpose : |
160 | //======================================================================= |
161 | |
162 | Units_Token::Units_Token(const Handle(Units_Token)& atoken) |
163 | { |
164 | theword = atoken->Word(); |
165 | themean = atoken->Mean(); |
166 | thevalue = atoken->Value(); |
167 | thedimensions = atoken->Dimensions(); |
168 | } |
169 | |
170 | //======================================================================= |
171 | //function : Update |
172 | //purpose : |
173 | //======================================================================= |
174 | |
175 | void Units_Token::Update(const Standard_CString amean) |
176 | { |
177 | TCollection_AsciiString string = Mean(); |
178 | if(string.Search(amean) != -1) |
179 | cout<<Word()<<" encountered twice with the same signification : "<<amean<<endl; |
180 | string = string + amean; |
181 | themean = string; |
182 | } |
183 | |
184 | //======================================================================= |
185 | //function : Add |
186 | //purpose : |
187 | //======================================================================= |
188 | |
189 | Handle(Units_Token) Units_Token::Add (const Standard_Integer) const |
190 | { |
191 | // Standard_CString s=new char[thelength+1]; |
192 | // strcpy(s,theword); |
193 | // s[thelength-1]=s[thelength-1]+int(i); |
194 | return new Units_Token(); |
195 | } |
196 | |
197 | //======================================================================= |
198 | //function : Add |
199 | //purpose : |
200 | //======================================================================= |
201 | |
202 | Handle(Units_Token) Units_Token::Add (const Handle(Units_Token)& atoken) const |
203 | { |
204 | TCollection_AsciiString word = Word(); |
205 | if(thedimensions->IsEqual(atoken->Dimensions())) |
206 | return new Units_Token(word.ToCString(), " ", thevalue+atoken->Value(), thedimensions); |
207 | else |
208 | return new Units_Token(" "); |
209 | } |
210 | |
211 | //======================================================================= |
212 | //function : Subtract |
213 | //purpose : |
214 | //======================================================================= |
215 | |
216 | Handle(Units_Token) Units_Token::Subtract (const Handle(Units_Token)& atoken) const |
217 | { |
218 | TCollection_AsciiString word = Word(); |
219 | if(thedimensions->IsEqual(atoken->Dimensions())) |
220 | return new Units_Token(word.ToCString(), " ", thevalue-atoken->Value(), thedimensions); |
221 | else |
222 | return new Units_Token(" "); |
223 | } |
224 | |
225 | //======================================================================= |
226 | //function : Multiply |
227 | //purpose : |
228 | //======================================================================= |
229 | |
230 | Handle(Units_Token) Units_Token::Multiply (const Handle(Units_Token)& atoken) const |
231 | { |
232 | TCollection_AsciiString string = Word(); |
233 | string.Insert(1,'('); |
234 | string = string + ")*("; |
235 | string = string + atoken->Word(); |
236 | string = string + ")"; |
237 | return new Units_Token |
238 | (string.ToCString()," ", thevalue*atoken->Value(), thedimensions * (atoken->Dimensions())); |
239 | } |
240 | |
241 | //======================================================================= |
242 | //function : Multiplied |
243 | //purpose : |
244 | //======================================================================= |
245 | |
246 | Standard_Real Units_Token::Multiplied (const Standard_Real avalue) const |
247 | { |
248 | return avalue * thevalue; |
249 | } |
250 | |
251 | //======================================================================= |
252 | //function : Divide |
253 | //purpose : |
254 | //======================================================================= |
255 | |
256 | Handle(Units_Token) Units_Token::Divide (const Handle(Units_Token)& atoken) |
257 | const |
258 | { |
259 | if(fabs(atoken->Value())<1.e-40) { |
0797d9d3 |
260 | #ifdef OCCT_DEBUG |
7fd59977 |
261 | cout<<"Warning: division on token with value=0 => return initial token."<<endl; |
262 | #endif |
263 | return this; |
264 | } |
265 | TCollection_AsciiString string = Word(); |
266 | string.Insert(1,'('); |
267 | string = string + ")/("; |
268 | string = string + atoken->Word(); |
269 | string = string + ")"; |
270 | return new Units_Token |
271 | (string.ToCString()," ", thevalue/atoken->Value(), thedimensions / (atoken->Dimensions())); |
272 | } |
273 | |
274 | //======================================================================= |
275 | //function : Divided |
276 | //purpose : |
277 | //======================================================================= |
278 | |
279 | Standard_Real Units_Token::Divided (const Standard_Real avalue) const |
280 | { |
281 | return avalue / thevalue; |
282 | } |
283 | |
284 | //======================================================================= |
285 | //function : Power |
286 | //purpose : |
287 | //======================================================================= |
288 | |
289 | Handle(Units_Token) Units_Token::Power(const Handle(Units_Token)& atoken) const |
290 | { |
291 | TCollection_AsciiString string = Word(); |
292 | string.Insert(1,'('); |
293 | string = string + ")**("; |
294 | string = string + atoken->Word(); |
295 | string = string + ")"; |
296 | return new Units_Token |
297 | (string.ToCString()," ",pow(thevalue,atoken->Value()),pow(thedimensions,atoken->Value())); |
298 | } |
299 | |
300 | //======================================================================= |
301 | //function : Power |
302 | //purpose : |
303 | //======================================================================= |
304 | |
305 | Handle(Units_Token) Units_Token::Power(const Standard_Real anexponent) const |
306 | { |
307 | TCollection_AsciiString exponent(anexponent); |
308 | TCollection_AsciiString string = Word(); |
309 | string.Insert(1,'('); |
310 | string = string + ")**("; |
311 | string = string + exponent; |
312 | string = string + ")"; |
313 | return new Units_Token |
314 | (string.ToCString()," ",pow(thevalue,anexponent),pow(thedimensions,anexponent)); |
315 | } |
316 | |
317 | //======================================================================= |
318 | //function : IsEqual |
319 | //purpose : |
320 | //======================================================================= |
321 | |
322 | Standard_Boolean Units_Token::IsEqual (const Standard_CString astring) const |
323 | { |
324 | TCollection_AsciiString string = Word(); |
325 | #ifdef UNX |
326 | Standard_Integer length = string.Length(); |
327 | #else |
328 | unsigned int length = string.Length(); |
329 | #endif |
330 | if(strlen(astring) == length) |
331 | return (strncmp(string.ToCString(),astring,unsigned(length)) == 0) |
332 | ? Standard_True : Standard_False; |
333 | else |
334 | return Standard_False; |
335 | } |
336 | |
337 | //======================================================================= |
338 | //function : IsEqual |
339 | //purpose : |
340 | //======================================================================= |
341 | |
342 | Standard_Boolean Units_Token::IsEqual (const Handle(Units_Token)& atoken) const |
343 | { |
344 | TCollection_AsciiString string1 = Word(); |
345 | TCollection_AsciiString string2 = atoken->Word(); |
346 | Standard_Integer length = string1.Length(); |
347 | if(length == atoken->Length()) |
348 | return (strcmp(string1.ToCString(),string2.ToCString()) == 0) ? Standard_True : Standard_False; |
349 | else |
350 | return Standard_False; |
351 | } |
352 | |
353 | //======================================================================= |
354 | //function : Dump |
355 | //purpose : |
356 | //======================================================================= |
357 | |
358 | void Units_Token::Dump(const Standard_Integer ashift, |
359 | const Standard_Integer alevel) const |
360 | { |
361 | int i; |
362 | TCollection_AsciiString word = Word(); |
363 | TCollection_AsciiString mean = Mean(); |
364 | |
365 | for(i=0; i<ashift; i++)cout<<" "; |
f1a5afa2 |
366 | cout << "Units_Token::Dump of " << this << endl; |
7fd59977 |
367 | for(i=0; i<ashift; i++)cout<<" "; |
368 | cout<<word.ToCString()<<endl; |
369 | for(i=0; i<ashift; i++)cout<<" "; |
370 | cout<<" value : "<<thevalue<<endl; |
371 | for(i=0; i<ashift; i++)cout<<" "; |
372 | cout<<" mean : "<<mean.ToCString()<<endl; |
373 | if(alevel)thedimensions->Dump(ashift); |
374 | } |
375 | |
376 | //======================================================================= |
377 | //function : operator + |
378 | //purpose : |
379 | //======================================================================= |
380 | |
381 | Handle(Units_Token) operator +(const Handle(Units_Token)& atoken,const Standard_Integer aninteger) |
382 | { |
383 | return atoken->Add(aninteger); |
384 | } |
385 | |
386 | //======================================================================= |
387 | //function : operator + |
388 | //purpose : |
389 | //======================================================================= |
390 | |
391 | Handle(Units_Token) operator +(const Handle(Units_Token)& atoken1,const Handle(Units_Token)& atoken2) |
392 | { |
393 | return atoken1->Add(atoken2); |
394 | } |
395 | |
396 | //======================================================================= |
397 | //function : operator - |
398 | //purpose : |
399 | //======================================================================= |
400 | |
401 | Handle(Units_Token) operator -(const Handle(Units_Token)& atoken1,const Handle(Units_Token)& atoken2) |
402 | { |
403 | return atoken1->Subtract(atoken2); |
404 | } |
405 | |
406 | //======================================================================= |
407 | //function : operator * |
408 | //purpose : |
409 | //======================================================================= |
410 | |
411 | Handle(Units_Token) operator *(const Handle(Units_Token)& atoken1,const Handle(Units_Token)& atoken2) |
412 | { |
413 | return atoken1->Multiply(atoken2); |
414 | } |
415 | |
416 | //======================================================================= |
417 | //function : operator / |
418 | //purpose : |
419 | //======================================================================= |
420 | |
421 | Handle(Units_Token) operator /(const Handle(Units_Token)& atoken1,const Handle(Units_Token)& atoken2) |
422 | { |
423 | return atoken1->Divide(atoken2); |
424 | } |
425 | |
426 | //======================================================================= |
427 | //function : pow |
428 | //purpose : |
429 | //======================================================================= |
430 | |
431 | Handle(Units_Token) pow(const Handle(Units_Token)& atoken1, const Handle(Units_Token)& atoken2) |
432 | { |
433 | return atoken1->Power(atoken2); |
434 | } |
435 | |
436 | //======================================================================= |
437 | //function : pow |
438 | //purpose : |
439 | //======================================================================= |
440 | |
441 | Handle(Units_Token) pow(const Handle(Units_Token)& atoken,const Standard_Real areal) |
442 | { |
443 | return atoken->Power(areal); |
444 | } |
445 | |
446 | //======================================================================= |
447 | //function : operator == |
448 | //purpose : |
449 | //======================================================================= |
450 | |
451 | Standard_Boolean operator ==(const Handle(Units_Token)& atoken,const Standard_CString astring) |
452 | { |
453 | return atoken->IsEqual(astring); |
454 | } |
455 | |
456 | //======================================================================= |
457 | //function : operator == |
458 | //purpose : |
459 | //======================================================================= |
460 | |
461 | //Standard_Boolean operator ==(const Handle(Units_Token)& atoken1,const Handle(Units_Token)& atoken2) |
462 | //{ |
463 | // return atoken1->IsEqual(atoken2); |
464 | //} |
465 | |
466 | //======================================================================= |
467 | //function : operator != |
468 | //purpose : |
469 | //======================================================================= |
470 | |
471 | Standard_Boolean operator !=(const Handle(Units_Token)& atoken,const Standard_CString astring) |
472 | { |
473 | return atoken->IsNotEqual(astring); |
474 | } |
475 | |
476 | //======================================================================= |
477 | //function : operator != |
478 | //purpose : |
479 | //======================================================================= |
480 | |
481 | //Standard_Boolean operator !=(const Handle(Units_Token)& atoken1,const Handle(Units_Token)& atoken2) |
482 | //{ |
483 | // return atoken1->IsNotEqual(atoken2); |
484 | //} |
485 | |
486 | //======================================================================= |
487 | //function : operator <= |
488 | //purpose : |
489 | //======================================================================= |
490 | |
491 | Standard_Boolean operator <=(const Handle(Units_Token)& atoken,const Standard_CString astring) |
492 | { |
493 | return atoken->IsLessOrEqual(astring); |
494 | } |
495 | |
496 | //======================================================================= |
497 | //function : operator > |
498 | //purpose : |
499 | //======================================================================= |
500 | |
501 | Standard_Boolean operator >(const Handle(Units_Token)& atoken,const Standard_CString astring) |
502 | { |
503 | return atoken->IsGreater(astring); |
504 | } |
505 | |
506 | //======================================================================= |
507 | //function : operator > |
508 | //purpose : |
509 | //======================================================================= |
510 | |
511 | Standard_Boolean operator >(const Handle(Units_Token)& atoken1,const Handle(Units_Token)& atoken2) |
512 | { |
513 | return atoken1->IsGreater(atoken2); |
514 | } |
515 | |
516 | //======================================================================= |
517 | //function : operator >= |
518 | //purpose : |
519 | //======================================================================= |
520 | |
521 | Standard_Boolean operator >=(const Handle(Units_Token)& atoken1,const Handle(Units_Token)& atoken2) |
522 | { |
523 | return atoken1->IsGreaterOrEqual(atoken2); |
524 | } |
525 | |
526 | void Units_Token::Destroy () { |
527 | |
7fd59977 |
528 | } |