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

// Created on: 1992-06-24
// Created by: Gilles DEBARBOUILLE
// Copyright (c) 1992-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.

// 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

//		Mauvaise construction d'un token par copie
//		plantatoire sur HP.

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

//=======================================================================
//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.);
}

//=======================================================================
//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.);
}

//=======================================================================
//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.);
}

//=======================================================================
//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.);
}

//=======================================================================
//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());
}

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

Handle(Units_Token) Units_Token::Creates() const
{
  TCollection_AsciiString word = Word();
  TCollection_AsciiString mean = Mean();
  return new Units_Token(word.ToCString(),mean.ToCString(),Value(),Dimensions());
}

//=======================================================================
//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 OCCT_DEBUG
    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 " << this << 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 () {

}
Commit	Line	Data
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
d5f74e42	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
973c2be1	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()," ", thevalueatoken->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	}