[occt.git] / src / Units / Units_Token.cxx

// File:	Units_Token.cxx
// Created:	Wed Jun 24 12:49:08 1992
// Author:	Gilles DEBARBOUILLE
//		<gde@phobox>
// Updated:	Gerard GRAS le 090597 
//		reason is PRO6934 -> plantage sur HP 10.2
//		changes are : Replace the field theword,themean from HAsciiString
//			      to AsciiString.
//		because the compiler try to destroies the handle of HAsciiString to early
//		due to inline use probably.
//		See also Units_Token.lxx

#define PRO8727	//GG_180697
//		Mauvaise construction d'un token par copie
//		plantatoire sur HP.

#include <Units_Token.ixx>
#include <TCollection_AsciiString.hxx>
#include <Units_Operators.hxx>

#define XTRACE 1

//=======================================================================
//function : Units_Token
//purpose  : 
//=======================================================================

Units_Token::Units_Token()
{
  theword=" ";
  themean=" ";
  thevalue=0.;
  thedimensions=new Units_Dimensions(0.,0.,0.,0.,0.,0.,0.,0.,0.);
#ifdef TRACE
  cout << " CREATES Token " << endl;
  Dump(0,0);
#endif
}

//=======================================================================
//function : Units_Token
//purpose  : 
//=======================================================================

Units_Token::Units_Token(const Standard_CString aword)
{
  theword=aword;
  themean=" ";
  thevalue=0.;
  thedimensions=new Units_Dimensions(0.,0.,0.,0.,0.,0.,0.,0.,0.);
#ifdef TRACE
  cout << " CREATES Token " << endl;
  Dump(0,0);
#endif
}

//=======================================================================
//function : Units_Token
//purpose  : 
//=======================================================================

Units_Token::Units_Token(const Standard_CString aword,
			 const Standard_CString amean)
{
  theword=aword;
  themean=amean;
  thevalue=0.;
  thedimensions=new Units_Dimensions(0.,0.,0.,0.,0.,0.,0.,0.,0.);
#ifdef TRACE
  cout << " CREATES Token " << endl;
  Dump(0,0);
#endif
}

//=======================================================================
//function : Units_Token
//purpose  : 
//=======================================================================

Units_Token::Units_Token(const Standard_CString aword,
			 const Standard_CString amean,
			 const Standard_Real avalue)
{
  theword=aword;
  themean=amean;
  thevalue=avalue;
  thedimensions=new Units_Dimensions(0.,0.,0.,0.,0.,0.,0.,0.,0.);
#ifdef TRACE
  cout << " CREATES Token " << endl;
  Dump(0,0);
#endif
}

//=======================================================================
//function : Units_Token
//purpose  : 
//=======================================================================

Units_Token::Units_Token(const Standard_CString aword,
			 const Standard_CString amean,
			 const Standard_Real avalue,
			 const Handle(Units_Dimensions)& adimensions)
{
  theword=aword;
  themean=amean;
  thevalue=avalue;
  if(adimensions.IsNull())
    thedimensions = new Units_Dimensions(0.,0.,0.,0.,0.,0.,0.,0.,0.);
  else
    thedimensions = new Units_Dimensions(adimensions->Mass(),
                                         adimensions->Length(),
                                         adimensions->Time(),
                                         adimensions->ElectricCurrent(),
                                         adimensions->ThermodynamicTemperature(),
                                         adimensions->AmountOfSubstance(),
                                         adimensions->LuminousIntensity(),
                                         adimensions->PlaneAngle(),
                                         adimensions->SolidAngle());
#ifdef TRACE
  cout << " CREATES Token " << endl;
  Dump(0,0);
#endif
}

//=======================================================================
//function : Creates
//purpose  : 
//=======================================================================

Handle(Units_Token) Units_Token::Creates() const
{
#ifdef PRO8727
  TCollection_AsciiString word = Word();
  TCollection_AsciiString mean = Mean();
  return new Units_Token(word.ToCString(),mean.ToCString(),Value(),Dimensions());
#else
  return new Units_Token(*this);
#endif
}

//=======================================================================
//function : Length
//purpose  : 
//=======================================================================

Standard_Integer Units_Token::Length() const
{
  return theword.Length();
}

//=======================================================================
//function : Dimensions
//purpose  : 
//=======================================================================

void Units_Token::Dimensions(const Handle(Units_Dimensions)& adimensions)
{
  if(adimensions.IsNull())
    thedimensions = new Units_Dimensions(0.,0.,0.,0.,0.,0.,0.,0.,0.);
  else
    thedimensions = new Units_Dimensions(adimensions->Mass(),
                                         adimensions->Length(),
                                         adimensions->Time(),
                                         adimensions->ElectricCurrent(),
                                         adimensions->ThermodynamicTemperature(),
                                         adimensions->AmountOfSubstance(),
                                         adimensions->LuminousIntensity(),
                                         adimensions->PlaneAngle(),
                                         adimensions->SolidAngle());
}

//=======================================================================
//function : Units_Token
//purpose  : 
//=======================================================================

Units_Token::Units_Token(const Handle(Units_Token)& atoken)
{
  theword       = atoken->Word();
  themean       = atoken->Mean();
  thevalue      = atoken->Value();
  thedimensions = atoken->Dimensions();
}

//=======================================================================
//function : Update
//purpose  : 
//=======================================================================

void Units_Token::Update(const Standard_CString amean)
{
  TCollection_AsciiString string = Mean();
  if(string.Search(amean) != -1)
    cout<<Word()<<" encountered twice with the same signification : "<<amean<<endl;
  string = string + amean;
  themean = string;
}

//=======================================================================
//function : Add
//purpose  : 
//=======================================================================

Handle(Units_Token) Units_Token::Add (const Standard_Integer) const
{
//  Standard_CString s=new char[thelength+1];
//  strcpy(s,theword);
//  s[thelength-1]=s[thelength-1]+int(i);
  return new Units_Token();
}

//=======================================================================
//function : Add
//purpose  : 
//=======================================================================

Handle(Units_Token) Units_Token::Add (const Handle(Units_Token)& atoken) const
{
  TCollection_AsciiString word = Word();
  if(thedimensions->IsEqual(atoken->Dimensions()))
    return new Units_Token(word.ToCString(), " ", thevalue+atoken->Value(), thedimensions);
  else
    return new Units_Token(" ");
}

//=======================================================================
//function : Subtract
//purpose  : 
//=======================================================================

Handle(Units_Token) Units_Token::Subtract (const Handle(Units_Token)& atoken) const
{
  TCollection_AsciiString word = Word();
  if(thedimensions->IsEqual(atoken->Dimensions()))
    return new Units_Token(word.ToCString(), " ", thevalue-atoken->Value(), thedimensions);
  else
    return new Units_Token(" ");
}

//=======================================================================
//function : Multiply
//purpose  : 
//=======================================================================

Handle(Units_Token) Units_Token::Multiply (const Handle(Units_Token)& atoken) const
{
  TCollection_AsciiString string = Word();
  string.Insert(1,'(');
  string = string + ")*(";
  string = string + atoken->Word();
  string = string + ")";
  return new Units_Token
    (string.ToCString()," ", thevalue*atoken->Value(), thedimensions * (atoken->Dimensions()));
}

//=======================================================================
//function : Multiplied
//purpose  : 
//=======================================================================

Standard_Real Units_Token::Multiplied (const Standard_Real avalue) const
{
  return avalue * thevalue;
}

//=======================================================================
//function : Divide
//purpose  : 
//=======================================================================

Handle(Units_Token) Units_Token::Divide (const Handle(Units_Token)& atoken)
     const
{
  if(fabs(atoken->Value())<1.e-40) {
#ifdef DEB
    cout<<"Warning: division on token with value=0 => return initial token."<<endl;
#endif
    return this;
  }
  TCollection_AsciiString string = Word();
  string.Insert(1,'(');
  string = string + ")/(";
  string = string + atoken->Word();
  string = string + ")";
  return new Units_Token
    (string.ToCString()," ", thevalue/atoken->Value(), thedimensions / (atoken->Dimensions()));
}

//=======================================================================
//function : Divided
//purpose  : 
//=======================================================================

Standard_Real Units_Token::Divided (const Standard_Real avalue) const
{
  return avalue / thevalue;
}

//=======================================================================
//function : Power
//purpose  : 
//=======================================================================

Handle(Units_Token) Units_Token::Power(const Handle(Units_Token)& atoken) const
{
  TCollection_AsciiString string = Word();
  string.Insert(1,'(');
  string = string + ")**(";
  string = string + atoken->Word();
  string = string + ")";
  return new Units_Token
    (string.ToCString()," ",pow(thevalue,atoken->Value()),pow(thedimensions,atoken->Value()));
}

//=======================================================================
//function : Power
//purpose  : 
//=======================================================================

Handle(Units_Token) Units_Token::Power(const Standard_Real anexponent) const
{
  TCollection_AsciiString exponent(anexponent);
  TCollection_AsciiString string = Word();
  string.Insert(1,'(');
  string = string + ")**(";
  string = string + exponent;
  string = string + ")";
  return new Units_Token
    (string.ToCString()," ",pow(thevalue,anexponent),pow(thedimensions,anexponent));
}

//=======================================================================
//function : IsEqual
//purpose  : 
//=======================================================================

Standard_Boolean Units_Token::IsEqual (const Standard_CString astring) const
{
  TCollection_AsciiString string = Word();
#ifdef UNX
  Standard_Integer length = string.Length();
#else
  unsigned int length = string.Length();
#endif
  if(strlen(astring) == length)
    return (strncmp(string.ToCString(),astring,unsigned(length)) == 0)
      ? Standard_True : Standard_False;
  else 
    return Standard_False;
}

//=======================================================================
//function : IsEqual
//purpose  : 
//=======================================================================

Standard_Boolean Units_Token::IsEqual (const Handle(Units_Token)& atoken) const
{
  TCollection_AsciiString string1 = Word();
  TCollection_AsciiString string2 = atoken->Word();
  Standard_Integer length = string1.Length();
  if(length == atoken->Length())
    return (strcmp(string1.ToCString(),string2.ToCString()) == 0) ? Standard_True : Standard_False;
  else
    return Standard_False;
}

//=======================================================================
//function : Dump
//purpose  : 
//=======================================================================

void Units_Token::Dump(const Standard_Integer ashift,
		       const Standard_Integer alevel) const
{
  int i;
  TCollection_AsciiString word = Word();
  TCollection_AsciiString mean = Mean();

  for(i=0; i<ashift; i++)cout<<"  ";
  cout << "Units_Token::Dump of " << hex << (long ) this << dec << endl;
  for(i=0; i<ashift; i++)cout<<"  ";
  cout<<word.ToCString()<<endl;
  for(i=0; i<ashift; i++)cout<<"  ";
  cout<<"  value : "<<thevalue<<endl;
  for(i=0; i<ashift; i++)cout<<"  ";
  cout<<"  mean  : "<<mean.ToCString()<<endl;
  if(alevel)thedimensions->Dump(ashift);
}

//=======================================================================
//function : operator +
//purpose  : 
//=======================================================================

Handle(Units_Token) operator +(const Handle(Units_Token)& atoken,const Standard_Integer aninteger)
{
  return atoken->Add(aninteger);
}

//=======================================================================
//function : operator +
//purpose  : 
//=======================================================================

Handle(Units_Token) operator +(const Handle(Units_Token)& atoken1,const Handle(Units_Token)& atoken2)
{
  return atoken1->Add(atoken2);
}

//=======================================================================
//function : operator -
//purpose  : 
//=======================================================================

Handle(Units_Token) operator -(const Handle(Units_Token)& atoken1,const Handle(Units_Token)& atoken2)
{
  return atoken1->Subtract(atoken2);
}

//=======================================================================
//function : operator *
//purpose  : 
//=======================================================================

Handle(Units_Token) operator *(const Handle(Units_Token)& atoken1,const Handle(Units_Token)& atoken2)
{
  return atoken1->Multiply(atoken2);
}

//=======================================================================
//function : operator /
//purpose  : 
//=======================================================================

Handle(Units_Token) operator /(const Handle(Units_Token)& atoken1,const Handle(Units_Token)& atoken2)
{
  return atoken1->Divide(atoken2);
}

//=======================================================================
//function : pow
//purpose  : 
//=======================================================================

Handle(Units_Token) pow(const Handle(Units_Token)& atoken1, const Handle(Units_Token)& atoken2)
{
  return atoken1->Power(atoken2);
}

//=======================================================================
//function : pow
//purpose  : 
//=======================================================================

Handle(Units_Token) pow(const Handle(Units_Token)& atoken,const Standard_Real areal)
{
  return atoken->Power(areal);
}

//=======================================================================
//function : operator ==
//purpose  : 
//=======================================================================

Standard_Boolean operator ==(const Handle(Units_Token)& atoken,const Standard_CString astring)
{
  return atoken->IsEqual(astring);
}

//=======================================================================
//function : operator ==
//purpose  : 
//=======================================================================

//Standard_Boolean operator ==(const Handle(Units_Token)& atoken1,const Handle(Units_Token)& atoken2)
//{
//  return atoken1->IsEqual(atoken2);
//}

//=======================================================================
//function : operator !=
//purpose  : 
//=======================================================================

Standard_Boolean operator !=(const Handle(Units_Token)& atoken,const Standard_CString astring)
{
  return atoken->IsNotEqual(astring);
}

//=======================================================================
//function : operator !=
//purpose  : 
//=======================================================================

//Standard_Boolean operator !=(const Handle(Units_Token)& atoken1,const Handle(Units_Token)& atoken2)
//{
//  return atoken1->IsNotEqual(atoken2);
//}

//=======================================================================
//function : operator <=
//purpose  : 
//=======================================================================

Standard_Boolean operator <=(const Handle(Units_Token)& atoken,const Standard_CString astring)
{
  return atoken->IsLessOrEqual(astring);
}

//=======================================================================
//function : operator >
//purpose  : 
//=======================================================================

Standard_Boolean operator >(const Handle(Units_Token)& atoken,const Standard_CString astring)
{
  return atoken->IsGreater(astring);
}

//=======================================================================
//function : operator >
//purpose  : 
//=======================================================================

Standard_Boolean operator >(const Handle(Units_Token)& atoken1,const Handle(Units_Token)& atoken2)
{
  return atoken1->IsGreater(atoken2);
}

//=======================================================================
//function : operator >=
//purpose  : 
//=======================================================================

Standard_Boolean operator >=(const Handle(Units_Token)& atoken1,const Handle(Units_Token)& atoken2)
{
  return atoken1->IsGreaterOrEqual(atoken2);
}

void Units_Token::Destroy () {

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