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

// Created on: 1993-10-22
// Created by: Gilles DEBARBOUILLE
// Copyright (c) 1993-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.

#define PRO8619 //GG_160697
//              Convertir correctement les unites translatees

#include <Units_UnitsSystem.ixx>
#include <Units.hxx>
#include <Units_UnitsDictionary.hxx>
#include <Units_QuantitiesSequence.hxx>
#include <Units_Explorer.hxx>
#include <Units_Quantity.hxx>
#include <Units_UnitsSequence.hxx>
#include <Units_UnitSentence.hxx>
#include <Units_Unit.hxx>
#include <Units_ShiftedUnit.hxx>
#include <Units_Token.hxx>
#include <Units_ShiftedToken.hxx>
#include <Resource_Manager.hxx>
#include <TCollection_AsciiString.hxx>
#include <TColStd_HSequenceOfHAsciiString.hxx>
#include <Units_Operators.hxx>


//=======================================================================
//function : Units_UnitsSystem
//purpose  : 
//=======================================================================

Units_UnitsSystem::Units_UnitsSystem()
{
  thequantitiessequence = new Units_QuantitiesSequence();
  theactiveunitssequence = new TColStd_HSequenceOfInteger;
}


//=======================================================================
//function : Units_UnitsSystem
//purpose  : 
//=======================================================================

Units_UnitsSystem::Units_UnitsSystem(const Standard_CString aName,
                                     const Standard_Boolean Verbose)
{
  Handle(Resource_Manager) themanager = new Resource_Manager(aName,Verbose);

  thequantitiessequence = new Units_QuantitiesSequence();
  theactiveunitssequence = new TColStd_HSequenceOfInteger;
}


//=======================================================================
//function : QuantitiesSequence
//purpose  : 
//=======================================================================

Handle(Units_QuantitiesSequence) Units_UnitsSystem::QuantitiesSequence() const
{
  return thequantitiessequence;
}


//=======================================================================
//function : ActiveUnitsSequence
//purpose  : 
//=======================================================================

Handle(TColStd_HSequenceOfInteger) Units_UnitsSystem::ActiveUnitsSequence() const
{
  return theactiveunitssequence;
}


//=======================================================================
//function : Specify
//purpose  : 
//=======================================================================

void Units_UnitsSystem::Specify(const Standard_CString aquantity,const Standard_CString aunit)
{
  Standard_Integer index;
  Handle(Units_Unit) unit;
  Handle(Units_UnitsSequence) unitssequence;
  Handle(Units_Quantity) quantity;
  Handle(Units_Quantity) thequantity;
  Handle(Units_QuantitiesSequence) quantitiessequence;
  TCollection_AsciiString quantityname;

  Units_UnitSentence unitsentence(aunit);
  if(!unitsentence.IsDone()) {
    cout<<"Units_UnitsSystem::Specify : incorrect unit"<<endl;
    return;
  }
  Handle(Units_Token) token = unitsentence.Evaluate();

#ifdef PRO8619
  if( token->IsKind(STANDARD_TYPE(Units_ShiftedToken)) ) {
    Handle(Units_ShiftedToken) stoken =
        Handle(Units_ShiftedToken)::DownCast(token) ;
    Handle(Units_ShiftedUnit) sunit;
    unit = sunit = new Units_ShiftedUnit(aunit,aunit);
    sunit->Value(stoken->Value());
    sunit->Move(stoken->Move());
  } else
#endif
  {
    unit = new Units_Unit(aunit,aunit);
    unit->Value(token->Value());
  }

  for(index=1;index<=thequantitiessequence->Length();index++) {
    quantity = thequantitiessequence->Value(index);
    if(quantity == aquantity) {	  
      unit->Quantity(quantity);
      quantity->Sequence()->Append(unit);
      return;
    }
  }

  quantity = Units::Quantity(aquantity);
  
//  Units_NoSuchType_Raise_if(quantity.IsNull(),aquantity);
  if( quantity.IsNull() ) {
    cout<<"Warning: in Units_UnitsSystem : Units_NoSuchType '" << aquantity << "'" << endl;
    return;
  }
  
  unitssequence = new Units_UnitsSequence();
  quantityname = quantity->Name();
  thequantity = new Units_Quantity(quantityname.ToCString(),quantity->Dimensions(),unitssequence);
  unit->Quantity(thequantity);
  thequantitiessequence->Append(thequantity);
  theactiveunitssequence->Append(0);
  thequantity->Sequence()->Append(unit);
}


//=======================================================================
//function : Remove
//purpose  : 
//=======================================================================

void Units_UnitsSystem::Remove(const Standard_CString aquantity,
                               const Standard_CString aunit)
{
  Standard_Integer index1,index2;
  Handle(Units_Unit) unit;
  Handle(Units_UnitsSequence) unitssequence;
  Handle(Units_Quantity) quantity;

  for(index1=1;index1<=thequantitiessequence->Length();index1++) {

    quantity = thequantitiessequence->Value(index1);
    if(quantity == aquantity) {

      unitssequence = quantity->Sequence();
      for(index2=1;index2<=unitssequence->Length();index2++) {

	unit = unitssequence->Value(index2);
	if(unit == aunit) {
	  unitssequence->Remove(index2);
	    
	  if(unitssequence->Length() == 0) {
	    thequantitiessequence->Remove(index1);
	    theactiveunitssequence->Remove(index1);
	  }
	  else {
	    if(theactiveunitssequence->Value(index1) == index2)
	      theactiveunitssequence->SetValue(index1,0);
	    else if(theactiveunitssequence->Value(index1) > index2)
	      theactiveunitssequence->SetValue(index1,theactiveunitssequence->Value(index1)-1);
	    return;
	  }
	}
      }
      
      Units_NoSuchUnit::Raise(aunit);
      
    }
  }
  
  Units_NoSuchType::Raise(aquantity);
}


//=======================================================================
//function : Activate
//purpose  : 
//=======================================================================

void Units_UnitsSystem::Activate(const Standard_CString aquantity,
                                 const Standard_CString aunit)
{
  Standard_Integer index1,index2;
  Handle(Units_Unit) unit;
  Handle(Units_UnitsSequence) unitssequence;
  Handle(Units_Quantity) quantity;

  for(index1=1;index1<=thequantitiessequence->Length();index1++) {
    quantity = thequantitiessequence->Value(index1);
    if(quantity == aquantity)	{
      unitssequence = quantity->Sequence();
      for(index2=1;index2<=thequantitiessequence->Length();index2++) {
        unit = unitssequence->Value(index2);
        if(unit == aunit) {
          theactiveunitssequence->SetValue(index1,index2);
          return;
        }
      }
      Units_NoSuchUnit::Raise(aunit);
    }
  }

  Units_NoSuchType::Raise(aquantity);
}


//=======================================================================
//function : Activates
//purpose  : 
//=======================================================================

void Units_UnitsSystem::Activates()
{
  Standard_Integer index;
  Handle(Units_UnitsSequence) unitssequence;
  Handle(Units_Quantity) quantity;

  for(index=1;index<=thequantitiessequence->Length();index++) {
    quantity = thequantitiessequence->Value(index);
    unitssequence = quantity->Sequence();
    if( unitssequence->Length() > 0 ) {
      theactiveunitssequence->SetValue(index,1);
    }
  }
}


//=======================================================================
//function : ActiveUnit
//purpose  : 
//=======================================================================

TCollection_AsciiString Units_UnitsSystem::ActiveUnit(const Standard_CString aquantity) const
{
  Standard_Integer index1,index2;
  Handle(Units_Unit) unit;
  Handle(Units_UnitsSequence) unitssequence;
  Handle(Units_Quantity) quantity;

  for(index1=1;index1<=thequantitiessequence->Length();index1++) {
    quantity = thequantitiessequence->Value(index1);
    if(quantity == aquantity) {
      unitssequence = quantity->Sequence();
      index2 = theactiveunitssequence->Value(index1);
      if(index2)
        return unitssequence->Value(index2)->SymbolsSequence()->Value(1)->String();
      else {
#ifdef UNITS_DEB
        cout<<" Pas d'unite active pour "<<aquantity<<endl;
#endif
        return TCollection_AsciiString() ;
      }
    }
  }

  Units_NoSuchType::Raise(aquantity);
  return TCollection_AsciiString() ;
}


//=======================================================================
//function : ConvertValueToUserSystem
//purpose  : 
//=======================================================================

Standard_Real Units_UnitsSystem::ConvertValueToUserSystem
  (const Standard_CString aquantity,
   const Standard_Real avalue,
   const Standard_CString aunit) const
{
  Units_UnitSentence unitsentence(aunit);
  if(!unitsentence.IsDone()) {
    cout<<"Units_UnitsSystem::ConvertValueToUserSystem : incorrect unit => return 0"<<endl;
    return 0.;
  }
  return ConvertSIValueToUserSystem(aquantity,avalue*(unitsentence.Evaluate())->Value());
}


//=======================================================================
//function : ConvertSIValueToUserSystem
//purpose  : 
//=======================================================================

Standard_Real Units_UnitsSystem::ConvertSIValueToUserSystem
  (const Standard_CString aquantity,const Standard_Real avalue) const
{
  Standard_Integer index,activeunit;
  Handle(Units_UnitsSequence) unitssequence;
  Handle(Units_Quantity) quantity;
  Handle(Units_QuantitiesSequence) quantitiessequence;
  Handle(Units_Unit) unit;
  Handle(Units_ShiftedUnit) sunit;
  Standard_Real uvalue,umove;

  for(index=1;index<=thequantitiessequence->Length();index++) {
    quantity = thequantitiessequence->Value(index);
    if(quantity == aquantity) {
      activeunit = theactiveunitssequence->Value(index);
      if(activeunit) {
        unitssequence = quantity->Sequence();
        unit = unitssequence->Value(activeunit);
#ifdef PRO8619
        if( unit->IsKind(STANDARD_TYPE(Units_ShiftedUnit)) ) {
          sunit = Handle(Units_ShiftedUnit)::DownCast(unit) ;
          uvalue = sunit->Value();
          umove = sunit->Move();
          return avalue/uvalue - umove;
        }
        else
#endif
        {
          uvalue = unit->Value();
          return avalue/uvalue;
        }
      }
      else {
        return avalue;
      }
    }
  }

  quantity = Units::Quantity(aquantity);
  
  Units_NoSuchType_Raise_if(quantity.IsNull(),aquantity);

  return avalue;
}


//=======================================================================
//function : ConvertUserSystemValueToSI
//purpose  : 
//=======================================================================

Standard_Real Units_UnitsSystem::ConvertUserSystemValueToSI
  (const Standard_CString aquantity,const Standard_Real avalue) const
{
  Standard_Integer index,activeunit;
  Handle(Units_UnitsSequence) unitssequence;
  Handle(Units_Quantity) quantity;
  Handle(Units_QuantitiesSequence) quantitiessequence;
  Handle(Units_Unit) unit;
  Handle(Units_ShiftedUnit) sunit;
  Standard_Real uvalue,umove;

  for(index=1;index<=thequantitiessequence->Length();index++) {
    quantity = thequantitiessequence->Value(index);
    if(quantity == aquantity) {
      activeunit = theactiveunitssequence->Value(index);
      if(activeunit) {
        unitssequence = quantity->Sequence();
        unit = unitssequence->Value(activeunit);
#ifdef PRO8619
        if( unit->IsKind(STANDARD_TYPE(Units_ShiftedUnit)) ) {
          sunit = Handle(Units_ShiftedUnit)::DownCast(unit) ;
          uvalue = sunit->Value();
          umove = sunit->Move();
          return avalue*(uvalue + umove);
        } else
#endif
        {
          uvalue = unit->Value();
          return avalue*uvalue;
        }
      }
      else {
        return avalue;
      }
    }
  }

  quantity = Units::Quantity(aquantity);
  
  Units_NoSuchType_Raise_if(quantity.IsNull(),aquantity);

  return avalue;
}


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

void Units_UnitsSystem::Dump() const
{
  Handle(Standard_Transient) transient = This();
  Handle(Units_UnitsSystem) unitssystem = *(Handle(Units_UnitsSystem)*)&transient;
  Units_Explorer explorer(unitssystem);
  cout<<" UNITSSYSTEM : "<<endl;
  for(; explorer.MoreQuantity(); explorer.NextQuantity()) {
    cout<<explorer.Quantity()<<endl;
    for(; explorer.MoreUnit(); explorer.NextUnit())
      cout<<"  "<<explorer.Unit()<<endl;
  }
}


//=======================================================================
//function : IsEmpty
//purpose  : 
//=======================================================================

Standard_Boolean Units_UnitsSystem::IsEmpty() const
{
  return (thequantitiessequence->Length() > 0) ? Standard_False : Standard_True;
}
Commit	Line	Data
b311480e	1	// Created on: 1993-10-22
	2	// Created by: Gilles DEBARBOUILLE
	3	// Copyright (c) 1993-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.
7fd59977	16
	17	#define PRO8619 //GG_160697
	18	// Convertir correctement les unites translatees
	19
	20	#include <Units_UnitsSystem.ixx>
	21	#include <Units.hxx>
	22	#include <Units_UnitsDictionary.hxx>
	23	#include <Units_QuantitiesSequence.hxx>
	24	#include <Units_Explorer.hxx>
	25	#include <Units_Quantity.hxx>
	26	#include <Units_UnitsSequence.hxx>
	27	#include <Units_UnitSentence.hxx>
	28	#include <Units_Unit.hxx>
	29	#include <Units_ShiftedUnit.hxx>
	30	#include <Units_Token.hxx>
	31	#include <Units_ShiftedToken.hxx>
	32	#include <Resource_Manager.hxx>
	33	#include <TCollection_AsciiString.hxx>
	34	#include <TColStd_HSequenceOfHAsciiString.hxx>
	35	#include <Units_Operators.hxx>
	36
	37
	38	//=======================================================================
	39	//function : Units_UnitsSystem
	40	//purpose :
	41	//=======================================================================
	42
	43	Units_UnitsSystem::Units_UnitsSystem()
	44	{
	45	thequantitiessequence = new Units_QuantitiesSequence();
	46	theactiveunitssequence = new TColStd_HSequenceOfInteger;
	47	}
	48
	49
	50	//=======================================================================
	51	//function : Units_UnitsSystem
	52	//purpose :
	53	//=======================================================================
	54
	55	Units_UnitsSystem::Units_UnitsSystem(const Standard_CString aName,
	56	const Standard_Boolean Verbose)
	57	{
	58	Handle(Resource_Manager) themanager = new Resource_Manager(aName,Verbose);
	59
	60	thequantitiessequence = new Units_QuantitiesSequence();
	61	theactiveunitssequence = new TColStd_HSequenceOfInteger;
	62	}
	63
	64
	65	//=======================================================================
	66	//function : QuantitiesSequence
	67	//purpose :
	68	//=======================================================================
	69
	70	Handle(Units_QuantitiesSequence) Units_UnitsSystem::QuantitiesSequence() const
	71	{
	72	return thequantitiessequence;
	73	}
	74
	75
	76	//=======================================================================
	77	//function : ActiveUnitsSequence
	78	//purpose :
	79	//=======================================================================
80
81	Handle(TColStd_HSequenceOfInteger) Units_UnitsSystem::ActiveUnitsSequence() const
82	{
83	return theactiveunitssequence;
84	}
85
86
87	//=======================================================================
88	//function : Specify
89	//purpose :
90	//=======================================================================
91
92	void Units_UnitsSystem::Specify(const Standard_CString aquantity,const Standard_CString aunit)
93	{
94	Standard_Integer index;
95	Handle(Units_Unit) unit;
96	Handle(Units_UnitsSequence) unitssequence;
97	Handle(Units_Quantity) quantity;
98	Handle(Units_Quantity) thequantity;
99	Handle(Units_QuantitiesSequence) quantitiessequence;
100	TCollection_AsciiString quantityname;
101
102	Units_UnitSentence unitsentence(aunit);
103	if(!unitsentence.IsDone()) {
104	cout<<"Units_UnitsSystem::Specify : incorrect unit"<<endl;
105	return;
106	}
107	Handle(Units_Token) token = unitsentence.Evaluate();
108
109	#ifdef PRO8619
110	if( token->IsKind(STANDARD_TYPE(Units_ShiftedToken)) ) {
111	Handle(Units_ShiftedToken) stoken =
112	Handle(Units_ShiftedToken)::DownCast(token) ;
113	Handle(Units_ShiftedUnit) sunit;
114	unit = sunit = new Units_ShiftedUnit(aunit,aunit);
115	sunit->Value(stoken->Value());
116	sunit->Move(stoken->Move());
117	} else
118	#endif
119	{
120	unit = new Units_Unit(aunit,aunit);
121	unit->Value(token->Value());
122	}
123
124	for(index=1;index<=thequantitiessequence->Length();index++) {
125	quantity = thequantitiessequence->Value(index);
126	if(quantity == aquantity) {
127	unit->Quantity(quantity);
128	quantity->Sequence()->Append(unit);
129	return;
130	}
131	}
132
133	quantity = Units::Quantity(aquantity);
134
135	// Units_NoSuchType_Raise_if(quantity.IsNull(),aquantity);
136	if( quantity.IsNull() ) {
137	cout<<"Warning: in Units_UnitsSystem : Units_NoSuchType '" << aquantity << "'" << endl;
138	return;
139	}
140
141	unitssequence = new Units_UnitsSequence();
142	quantityname = quantity->Name();
143	thequantity = new Units_Quantity(quantityname.ToCString(),quantity->Dimensions(),unitssequence);
144	unit->Quantity(thequantity);
145	thequantitiessequence->Append(thequantity);
146	theactiveunitssequence->Append(0);
147	thequantity->Sequence()->Append(unit);
148	}
149
150
151	//=======================================================================
152	//function : Remove
153	//purpose :
154	//=======================================================================
155
156	void Units_UnitsSystem::Remove(const Standard_CString aquantity,
157	const Standard_CString aunit)
158	{
159	Standard_Integer index1,index2;
160	Handle(Units_Unit) unit;
161	Handle(Units_UnitsSequence) unitssequence;
162	Handle(Units_Quantity) quantity;
163
164	for(index1=1;index1<=thequantitiessequence->Length();index1++) {
165
166	quantity = thequantitiessequence->Value(index1);
167	if(quantity == aquantity) {
168
169	unitssequence = quantity->Sequence();
170	for(index2=1;index2<=unitssequence->Length();index2++) {
171
172	unit = unitssequence->Value(index2);
173	if(unit == aunit) {
174	unitssequence->Remove(index2);
175
176	if(unitssequence->Length() == 0) {
177	thequantitiessequence->Remove(index1);
178	theactiveunitssequence->Remove(index1);
179	}
180	else {
181	if(theactiveunitssequence->Value(index1) == index2)
182	theactiveunitssequence->SetValue(index1,0);
183	else if(theactiveunitssequence->Value(index1) > index2)
184	theactiveunitssequence->SetValue(index1,theactiveunitssequence->Value(index1)-1);
185	return;
186	}
187	}
188	}
189
190	Units_NoSuchUnit::Raise(aunit);
191
192	}
193	}
194
195	Units_NoSuchType::Raise(aquantity);
196	}
197
198
199	//=======================================================================
200	//function : Activate
201	//purpose :
202	//=======================================================================
203
204	void Units_UnitsSystem::Activate(const Standard_CString aquantity,
205	const Standard_CString aunit)
206	{
207	Standard_Integer index1,index2;
208	Handle(Units_Unit) unit;
209	Handle(Units_UnitsSequence) unitssequence;
210	Handle(Units_Quantity) quantity;
211
212	for(index1=1;index1<=thequantitiessequence->Length();index1++) {
213	quantity = thequantitiessequence->Value(index1);
214	if(quantity == aquantity) {
215	unitssequence = quantity->Sequence();
216	for(index2=1;index2<=thequantitiessequence->Length();index2++) {
217	unit = unitssequence->Value(index2);
218	if(unit == aunit) {
219	theactiveunitssequence->SetValue(index1,index2);
220	return;
221	}
222	}
223	Units_NoSuchUnit::Raise(aunit);
224	}
225	}
226
227	Units_NoSuchType::Raise(aquantity);
228	}
229
230
231	//=======================================================================
232	//function : Activates
233	//purpose :
234	//=======================================================================
235
236	void Units_UnitsSystem::Activates()
237	{
238	Standard_Integer index;
239	Handle(Units_UnitsSequence) unitssequence;
240	Handle(Units_Quantity) quantity;
241
242	for(index=1;index<=thequantitiessequence->Length();index++) {
243	quantity = thequantitiessequence->Value(index);
244	unitssequence = quantity->Sequence();
245	if( unitssequence->Length() > 0 ) {
246	theactiveunitssequence->SetValue(index,1);
247	}
248	}
249	}
250
251
252	//=======================================================================
253	//function : ActiveUnit
254	//purpose :
255	//=======================================================================
256
257	TCollection_AsciiString Units_UnitsSystem::ActiveUnit(const Standard_CString aquantity) const
258	{
259	Standard_Integer index1,index2;
260	Handle(Units_Unit) unit;
261	Handle(Units_UnitsSequence) unitssequence;
262	Handle(Units_Quantity) quantity;
263
264	for(index1=1;index1<=thequantitiessequence->Length();index1++) {
265	quantity = thequantitiessequence->Value(index1);
266	if(quantity == aquantity) {
267	unitssequence = quantity->Sequence();
268	index2 = theactiveunitssequence->Value(index1);
269	if(index2)
270	return unitssequence->Value(index2)->SymbolsSequence()->Value(1)->String();
271	else {
63c629aa	272	#ifdef UNITS_DEB
7fd59977	273	cout<<" Pas d'unite active pour "<<aquantity<<endl;
63c629aa	274	#endif
7fd59977	275	return TCollection_AsciiString() ;
	276	}
	277	}
	278	}
	279
	280	Units_NoSuchType::Raise(aquantity);
	281	return TCollection_AsciiString() ;
	282	}
	283
	284
	285	//=======================================================================
	286	//function : ConvertValueToUserSystem
	287	//purpose :
	288	//=======================================================================
	289
	290	Standard_Real Units_UnitsSystem::ConvertValueToUserSystem
	291	(const Standard_CString aquantity,
	292	const Standard_Real avalue,
	293	const Standard_CString aunit) const
	294	{
	295	Units_UnitSentence unitsentence(aunit);
	296	if(!unitsentence.IsDone()) {
	297	cout<<"Units_UnitsSystem::ConvertValueToUserSystem : incorrect unit => return 0"<<endl;
	298	return 0.;
	299	}
	300	return ConvertSIValueToUserSystem(aquantity,avalue*(unitsentence.Evaluate())->Value());
	301	}
	302
	303
	304	//=======================================================================
	305	//function : ConvertSIValueToUserSystem
	306	//purpose :
	307	//=======================================================================
	308
	309	Standard_Real Units_UnitsSystem::ConvertSIValueToUserSystem
	310	(const Standard_CString aquantity,const Standard_Real avalue) const
	311	{
	312	Standard_Integer index,activeunit;
	313	Handle(Units_UnitsSequence) unitssequence;
	314	Handle(Units_Quantity) quantity;
	315	Handle(Units_QuantitiesSequence) quantitiessequence;
	316	Handle(Units_Unit) unit;
	317	Handle(Units_ShiftedUnit) sunit;
	318	Standard_Real uvalue,umove;
	319
	320	for(index=1;index<=thequantitiessequence->Length();index++) {
	321	quantity = thequantitiessequence->Value(index);
	322	if(quantity == aquantity) {
	323	activeunit = theactiveunitssequence->Value(index);
	324	if(activeunit) {
	325	unitssequence = quantity->Sequence();
	326	unit = unitssequence->Value(activeunit);
	327	#ifdef PRO8619
	328	if( unit->IsKind(STANDARD_TYPE(Units_ShiftedUnit)) ) {
	329	sunit = Handle(Units_ShiftedUnit)::DownCast(unit) ;
	330	uvalue = sunit->Value();
	331	umove = sunit->Move();
	332	return avalue/uvalue - umove;
	333	}
	334	else
	335	#endif
	336	{
	337	uvalue = unit->Value();
	338	return avalue/uvalue;
339	}
340	}
341	else {
342	return avalue;
343	}
344	}
345	}
346
347	quantity = Units::Quantity(aquantity);
348
349	Units_NoSuchType_Raise_if(quantity.IsNull(),aquantity);
350
351	return avalue;
352	}
353
354
355	//=======================================================================
356	//function : ConvertUserSystemValueToSI
357	//purpose :
358	//=======================================================================
359
360	Standard_Real Units_UnitsSystem::ConvertUserSystemValueToSI
361	(const Standard_CString aquantity,const Standard_Real avalue) const
362	{
363	Standard_Integer index,activeunit;
364	Handle(Units_UnitsSequence) unitssequence;
365	Handle(Units_Quantity) quantity;
366	Handle(Units_QuantitiesSequence) quantitiessequence;
367	Handle(Units_Unit) unit;
368	Handle(Units_ShiftedUnit) sunit;
369	Standard_Real uvalue,umove;
370
371	for(index=1;index<=thequantitiessequence->Length();index++) {
372	quantity = thequantitiessequence->Value(index);
373	if(quantity == aquantity) {
374	activeunit = theactiveunitssequence->Value(index);
375	if(activeunit) {
376	unitssequence = quantity->Sequence();
377	unit = unitssequence->Value(activeunit);
378	#ifdef PRO8619
379	if( unit->IsKind(STANDARD_TYPE(Units_ShiftedUnit)) ) {
380	sunit = Handle(Units_ShiftedUnit)::DownCast(unit) ;
381	uvalue = sunit->Value();
382	umove = sunit->Move();
383	return avalue*(uvalue + umove);
384	} else
385	#endif
386	{
387	uvalue = unit->Value();
388	return avalue*uvalue;
389	}
390	}
391	else {
392	return avalue;
393	}
394	}
395	}
396
397	quantity = Units::Quantity(aquantity);
398
399	Units_NoSuchType_Raise_if(quantity.IsNull(),aquantity);
400
401	return avalue;
402	}
403
404
405	//=======================================================================
406	//function : Dump
407	//purpose :
408	//=======================================================================
409
410	void Units_UnitsSystem::Dump() const
411	{
412	Handle(Standard_Transient) transient = This();
857ffd5e	413	Handle(Units_UnitsSystem) unitssystem = (Handle(Units_UnitsSystem))&transient;
7fd59977	414	Units_Explorer explorer(unitssystem);
	415	cout<<" UNITSSYSTEM : "<<endl;
	416	for(; explorer.MoreQuantity(); explorer.NextQuantity()) {
	417	cout<<explorer.Quantity()<<endl;
	418	for(; explorer.MoreUnit(); explorer.NextUnit())
	419	cout<<" "<<explorer.Unit()<<endl;
	420	}
	421	}
	422
	423
	424	//=======================================================================
	425	//function : IsEmpty
	426	//purpose :
	427	//=======================================================================
	428
	429	Standard_Boolean Units_UnitsSystem::IsEmpty() const
	430	{
	431	return (thequantitiessequence->Length() > 0) ? Standard_False : Standard_True;
	432	}