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