[occt.git] / src / XmlMDataXtd / XmlMDataXtd_ConstraintDriver.cxx

// Created on: 2001-08-24
// Created by: Alexnder GRIGORIEV
// Copyright (c) 2001-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.


#include <CDM_MessageDriver.hxx>
#include <Standard_Type.hxx>
#include <TDataStd_Real.hxx>
#include <TDataXtd_Constraint.hxx>
#include <TDF_Attribute.hxx>
#include <TNaming_NamedShape.hxx>
#include <XmlMDataXtd_ConstraintDriver.hxx>
#include <XmlObjMgt.hxx>
#include <XmlObjMgt_Persistent.hxx>

static TDataXtd_ConstraintEnum    ConstraintTypeEnum
                                                (const XmlObjMgt_DOMString&);
static const XmlObjMgt_DOMString& ConstraintTypeString
                                                (const TDataXtd_ConstraintEnum);

IMPLEMENT_DOMSTRING (TypeString,             "contype")
IMPLEMENT_DOMSTRING (ValueString,            "valueref")
IMPLEMENT_DOMSTRING (GeometriesString,       "geometries")
IMPLEMENT_DOMSTRING (PlaneString,            "plane")
IMPLEMENT_DOMSTRING (StatusString,           "flags")
     // planar constraints
IMPLEMENT_DOMSTRING (ConRadiusString,        "radius")
IMPLEMENT_DOMSTRING (ConDiameterString,      "diameter")
IMPLEMENT_DOMSTRING (ConMinRadiusString,     "minorradius")
IMPLEMENT_DOMSTRING (ConMajRadiusString,     "majorradius")
IMPLEMENT_DOMSTRING (ConTangentString,       "tangent")
IMPLEMENT_DOMSTRING (ConParallelString,      "parallel")
IMPLEMENT_DOMSTRING (ConPerpendicularString, "perpendicular")
IMPLEMENT_DOMSTRING (ConConcentricString,    "concentric")
IMPLEMENT_DOMSTRING (ConCoincidentString,    "coincident")
IMPLEMENT_DOMSTRING (ConDistanceString,      "distance")
IMPLEMENT_DOMSTRING (ConAngleString,         "angle")
IMPLEMENT_DOMSTRING (ConEqualRadiusString,   "equalradius")
IMPLEMENT_DOMSTRING (ConSymmetryString,      "symmetry")
IMPLEMENT_DOMSTRING (ConMidPointString,      "midpoint")
IMPLEMENT_DOMSTRING (ConEqualDistanceString, "equaldist")
IMPLEMENT_DOMSTRING (ConFixString,           "fix")
IMPLEMENT_DOMSTRING (ConRigidString,         "rigid")
     // placement constraints
IMPLEMENT_DOMSTRING (ConFromString,          "from")
IMPLEMENT_DOMSTRING (ConAxisString,          "axis")
IMPLEMENT_DOMSTRING (ConMateString,          "mate")
IMPLEMENT_DOMSTRING (ConAlignFacesString,    "alignfaces")
IMPLEMENT_DOMSTRING (ConAlignAxesString,     "alignaxes")
IMPLEMENT_DOMSTRING (ConAxesAngleString,     "axesangle")
IMPLEMENT_DOMSTRING (ConFacesAngleString,    "facesangle")
IMPLEMENT_DOMSTRING (ConRoundString,         "round")
IMPLEMENT_DOMSTRING (ConOffsetString,        "offset")

//=======================================================================
//function : XmlMDataXtd_ConstraintDriver
//purpose  : Constructor
//=======================================================================
XmlMDataXtd_ConstraintDriver::XmlMDataXtd_ConstraintDriver
                        (const Handle(CDM_MessageDriver)& theMsgDriver)
      : XmlMDF_ADriver (theMsgDriver, NULL)
{}

//=======================================================================
//function : NewEmpty
//purpose  : 
//=======================================================================
Handle(TDF_Attribute) XmlMDataXtd_ConstraintDriver::NewEmpty() const
{
  return (new TDataXtd_Constraint());
}

//=======================================================================
//function : Paste
//purpose  : persistent -> transient (retrieve)
//=======================================================================
Standard_Boolean XmlMDataXtd_ConstraintDriver::Paste
                        (const XmlObjMgt_Persistent&  theSource,
                         const Handle(TDF_Attribute)& theTarget,
                         XmlObjMgt_RRelocationTable&  theRelocTable) const
{
  Handle(TDataXtd_Constraint) aC = 
    Handle(TDataXtd_Constraint)::DownCast(theTarget);
  const XmlObjMgt_Element& anElem = theSource;

  Standard_Integer aNb;
  TCollection_ExtendedString aMsgString;

  // value
  Handle(TDataStd_Real) aTValue;
  XmlObjMgt_DOMString aDOMStr = anElem.getAttribute(::ValueString());
  if (aDOMStr != NULL)
  {
    if (!aDOMStr.GetInteger(aNb))
    {
      aMsgString = TCollection_ExtendedString
        ("XmlMDataXtd_ConstraintDriver: "
         "Cannot retrieve reference on Integer attribute from \"")
          + aDOMStr + "\"";
      WriteMessage (aMsgString);
      return Standard_False;
    }
    if (aNb > 0)
    {
      if (theRelocTable.IsBound(aNb))
        aTValue = Handle(TDataStd_Real)::DownCast(theRelocTable.Find(aNb));
      else
      {
        aTValue = new TDataStd_Real;
        theRelocTable.Bind(aNb, aTValue);
      }
      aC->SetValue(aTValue);
    }
  }

  // geometries
  aDOMStr = anElem.getAttribute(::GeometriesString());
  if (aDOMStr != NULL)
  {
    Standard_CString aGs = Standard_CString(aDOMStr.GetString());

    // first geometry
    if (!XmlObjMgt::GetInteger(aGs, aNb))
    {
      aMsgString = TCollection_ExtendedString
        ("XmlMDataXtd_ConstraintDriver: Cannot retrieve reference on first Geometry from \"")
          + aDOMStr + "\"";
      WriteMessage (aMsgString);
      return Standard_False;
    }
    Standard_Integer i = 1;
    while (aNb > 0)
    {
      Handle(TNaming_NamedShape) aG;
      if (theRelocTable.IsBound(aNb))
        aG = Handle(TNaming_NamedShape)::DownCast(theRelocTable.Find(aNb));
      else
      {
        aG = new TNaming_NamedShape;
        theRelocTable.Bind(aNb, aG);
      }
      aC->SetGeometry (i, aG);

      // next geometry
      if (!XmlObjMgt::GetInteger(aGs, aNb)) aNb = 0;
      i++;
    }
  }

  // plane
  aDOMStr = anElem.getAttribute(::PlaneString());
  if (aDOMStr != NULL)
  {
    if (!aDOMStr.GetInteger(aNb))
    {
      aMsgString = TCollection_ExtendedString
        ("XmlMDataXtd_ConstraintDriver: Cannot retrieve reference on Plane from \"")
          + aDOMStr + "\"";
      WriteMessage (aMsgString);
      return Standard_False;
    }
    Handle(TNaming_NamedShape) aTPlane;
    if (aNb > 0)
    {
      if (theRelocTable.IsBound(aNb))
        aTPlane = Handle(TNaming_NamedShape)::DownCast(theRelocTable.Find(aNb));
      else
      {
        aTPlane = new TNaming_NamedShape;
        theRelocTable.Bind(aNb, aTPlane);
      }
      aC->SetPlane(aTPlane);
    }
  }

  // constraint type
  XmlObjMgt_DOMString aType = anElem.getAttribute(::TypeString());
  aC->SetType(ConstraintTypeEnum(aType));

  // flags
  XmlObjMgt_DOMString aString = anElem.getAttribute(::StatusString());
  const char * aPtr = aString.GetString();
  aC->Verified((*aPtr) == '+');
  aPtr ++;
  aC->Inverted((*aPtr) == '+');
  aPtr ++;
  aC->Reversed((*aPtr) == '+');

  return Standard_True;
}

//=======================================================================
//function : Paste
//purpose  : transient -> persistent (store)
//=======================================================================
void XmlMDataXtd_ConstraintDriver::Paste
                        (const Handle(TDF_Attribute)& theSource,
                         XmlObjMgt_Persistent&        theTarget,
                         XmlObjMgt_SRelocationTable&  theRelocTable) const
{
  Handle(TDataXtd_Constraint) aC =
    Handle(TDataXtd_Constraint)::DownCast(theSource);
  XmlObjMgt_Element& anElem = theTarget;

  Standard_Integer aNb;

  // value
  Handle(TDataStd_Real) aValue = aC->GetValue();
  if (!aValue.IsNull())
  {
    aNb = theRelocTable.FindIndex(aValue);
    if (aNb == 0)
    {
      aNb = theRelocTable.Add(aValue);
    }
    anElem.setAttribute(::ValueString(), aNb);
  }

  // geometries
  Standard_Integer NbGeom = aC->NbGeometries();
  if (NbGeom >= 1)
  {
    TCollection_AsciiString aGsStr;
    for (Standard_Integer i = 1; i <= NbGeom; i++)
    {
      Handle(TNaming_NamedShape) aG = aC->GetGeometry(i);
      aNb = 0;
      if (!aG.IsNull())
      {
        aNb = theRelocTable.FindIndex(aG);
        if (aNb == 0)
        {
          aNb = theRelocTable.Add(aG);
        }
        aGsStr += TCollection_AsciiString(aNb) + " ";
      }
      else aGsStr += "0 ";
    }
    anElem.setAttribute(::GeometriesString(), aGsStr.ToCString());
  }

  // plane
  Handle(TNaming_NamedShape) aTPlane = aC->GetPlane();
  if (!aTPlane.IsNull())
  {
    aNb = theRelocTable.FindIndex(aTPlane);
    if (aNb == 0)
    {
      aNb = theRelocTable.Add(aTPlane);
    }
    anElem.setAttribute(::PlaneString(), aNb);
  }
  
  // constraint type
  anElem.setAttribute(::TypeString(), ConstraintTypeString(aC->GetType()));

  // flags
  TCollection_AsciiString aStatusStr;

  if (aC->Verified()) aStatusStr += "+";
  else aStatusStr += "-";

  if (aC->Inverted()) aStatusStr += "+";
  else aStatusStr += "-";

  if (aC->Reversed()) aStatusStr += "+";
  else aStatusStr += "-";

  anElem.setAttribute(::StatusString(), aStatusStr.ToCString());
}

//=======================================================================
//function : ConstraintTypeEnum
//purpose  : 
//=======================================================================
static TDataXtd_ConstraintEnum ConstraintTypeEnum (const XmlObjMgt_DOMString& theString) 
{
  TDataXtd_ConstraintEnum aResult = TDataXtd_RADIUS;
  // planar constraints
  if (!theString.equals (::ConRadiusString()))
  {
    if (theString.equals (::ConDiameterString()))
      aResult = TDataXtd_DIAMETER;
    else if (theString.equals (::ConMinRadiusString()))
      aResult = TDataXtd_MINOR_RADIUS;
    else if (theString.equals (::ConMajRadiusString()))
      aResult = TDataXtd_MAJOR_RADIUS;
    else if (theString.equals (::ConTangentString()))
      aResult = TDataXtd_TANGENT;
    else if (theString.equals (::ConParallelString()))
      aResult = TDataXtd_PARALLEL;
    else if (theString.equals (::ConPerpendicularString()))
      aResult = TDataXtd_PERPENDICULAR;
    else if (theString.equals (::ConConcentricString()))
      aResult = TDataXtd_CONCENTRIC;
    else if (theString.equals (::ConCoincidentString()))
      aResult = TDataXtd_COINCIDENT;
    else if (theString.equals (::ConDistanceString()))
      aResult = TDataXtd_DISTANCE;
    else if (theString.equals (::ConAngleString()))
      aResult = TDataXtd_ANGLE;
    else if (theString.equals (::ConEqualRadiusString()))
      aResult = TDataXtd_EQUAL_RADIUS;
    else if (theString.equals (::ConSymmetryString()))
      aResult = TDataXtd_SYMMETRY;
    else if (theString.equals (::ConMidPointString()))
      aResult = TDataXtd_MIDPOINT;
    else if (theString.equals (::ConEqualDistanceString()))
      aResult = TDataXtd_EQUAL_DISTANCE;
    else if (theString.equals (::ConFixString()))
      aResult = TDataXtd_FIX;
    else if (theString.equals (::ConRigidString()))
      aResult = TDataXtd_RIGID;
    // placement constraints
    else if (theString.equals (::ConFromString()))
      aResult = TDataXtd_FROM;
    else if (theString.equals (::ConAxisString()))
      aResult = TDataXtd_AXIS;
    else if (theString.equals (::ConMateString()))
      aResult = TDataXtd_MATE;
    else if (theString.equals (::ConAlignFacesString()))
      aResult = TDataXtd_ALIGN_FACES;
    else if (theString.equals (::ConAlignAxesString()))
      aResult = TDataXtd_ALIGN_AXES;
    else if (theString.equals (::ConAxesAngleString()))
      aResult = TDataXtd_AXES_ANGLE;
    else if (theString.equals (::ConFacesAngleString()))
      aResult = TDataXtd_FACES_ANGLE;
    else if (theString.equals (::ConRoundString()))
      aResult = TDataXtd_ROUND;
    else if (theString.equals (::ConOffsetString()))
      aResult = TDataXtd_OFFSET;
    else
      Standard_DomainError::Raise
        ("TDataXtd_ConstraintEnum; string value without enum term equivalence");
  }
  return aResult;
}

//=======================================================================
//function : ConstraintTypeString
//purpose  : 
//=======================================================================
static const XmlObjMgt_DOMString& ConstraintTypeString (const TDataXtd_ConstraintEnum theE) 
{
  switch (theE)
  {
    // planar constraints
  case TDataXtd_RADIUS         : return ::ConRadiusString();
  case TDataXtd_DIAMETER       : return ::ConDiameterString();
  case TDataXtd_MINOR_RADIUS   : return ::ConMinRadiusString();
  case TDataXtd_MAJOR_RADIUS   : return ::ConMajRadiusString();
  case TDataXtd_TANGENT        : return ::ConTangentString();
  case TDataXtd_PARALLEL       : return ::ConParallelString();
  case TDataXtd_PERPENDICULAR  : return ::ConPerpendicularString();
  case TDataXtd_CONCENTRIC     : return ::ConConcentricString();
  case TDataXtd_COINCIDENT     : return ::ConCoincidentString();
  case TDataXtd_DISTANCE       : return ::ConDistanceString();
  case TDataXtd_ANGLE          : return ::ConAngleString();
  case TDataXtd_EQUAL_RADIUS   : return ::ConEqualRadiusString();
  case TDataXtd_SYMMETRY       : return ::ConSymmetryString();
  case TDataXtd_MIDPOINT       : return ::ConMidPointString();   
  case TDataXtd_EQUAL_DISTANCE : return ::ConEqualDistanceString();
  case TDataXtd_FIX            : return ::ConFixString();
  case TDataXtd_RIGID          : return ::ConRigidString();
    // placement constraints
  case TDataXtd_FROM           : return ::ConFromString(); 
  case TDataXtd_AXIS           : return ::ConAxisString(); 
  case TDataXtd_MATE           : return ::ConMateString();
  case TDataXtd_ALIGN_FACES    : return ::ConAlignFacesString();
  case TDataXtd_ALIGN_AXES     : return ::ConAlignAxesString();
  case TDataXtd_AXES_ANGLE     : return ::ConAxesAngleString();
  case TDataXtd_FACES_ANGLE    : return ::ConFacesAngleString();
  case TDataXtd_ROUND          : return ::ConRoundString();
  case TDataXtd_OFFSET         : return ::ConOffsetString();
    
  default:
    Standard_DomainError::Raise("TDataXtd_ConstraintEnum; enum term unknown");
  }
  static XmlObjMgt_DOMString aNullString;
  return aNullString; // To avoid compilation error message.
}
Commit	Line	Data
b311480e	1	// Created on: 2001-08-24
b311480e	2	// Created by: Alexnder GRIGORIEV
973c2be1	3	// Copyright (c) 2001-2014 OPEN CASCADE SAS
b311480e	4	//
973c2be1	5	// This file is part of Open CASCADE Technology software library.
b311480e	6	//
d5f74e42	7	// This library is free software; you can redistribute it and/or modify it under
d5f74e42	8	// the terms of the GNU Lesser General Public License version 2.1 as published
973c2be1	9	// by the Free Software Foundation, with special exception defined in the file
	10	// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
	11	// distribution for complete text of the license and disclaimer of any warranty.
b311480e	12	//
973c2be1	13	// Alternatively, this file may be used under the terms of Open CASCADE
973c2be1	14	// commercial license or contractual agreement.
7fd59977	15
7fd59977	16
42cf5bc1	17	#include <CDM_MessageDriver.hxx>
42cf5bc1	18	#include <Standard_Type.hxx>
7fd59977	19	#include <TDataStd_Real.hxx>
42cf5bc1	20	#include <TDataXtd_Constraint.hxx>
42cf5bc1	21	#include <TDF_Attribute.hxx>
7fd59977	22	#include <TNaming_NamedShape.hxx>
42cf5bc1	23	#include <XmlMDataXtd_ConstraintDriver.hxx>
7fd59977	24	#include <XmlObjMgt.hxx>
42cf5bc1	25	#include <XmlObjMgt_Persistent.hxx>
7fd59977	26
	27	static TDataXtd_ConstraintEnum ConstraintTypeEnum
	28	(const XmlObjMgt_DOMString&);
	29	static const XmlObjMgt_DOMString& ConstraintTypeString
	30	(const TDataXtd_ConstraintEnum);
	31
	32	IMPLEMENT_DOMSTRING (TypeString, "contype")
	33	IMPLEMENT_DOMSTRING (ValueString, "valueref")
	34	IMPLEMENT_DOMSTRING (GeometriesString, "geometries")
	35	IMPLEMENT_DOMSTRING (PlaneString, "plane")
	36	IMPLEMENT_DOMSTRING (StatusString, "flags")
	37	// planar constraints
	38	IMPLEMENT_DOMSTRING (ConRadiusString, "radius")
	39	IMPLEMENT_DOMSTRING (ConDiameterString, "diameter")
	40	IMPLEMENT_DOMSTRING (ConMinRadiusString, "minorradius")
	41	IMPLEMENT_DOMSTRING (ConMajRadiusString, "majorradius")
	42	IMPLEMENT_DOMSTRING (ConTangentString, "tangent")
	43	IMPLEMENT_DOMSTRING (ConParallelString, "parallel")
	44	IMPLEMENT_DOMSTRING (ConPerpendicularString, "perpendicular")
	45	IMPLEMENT_DOMSTRING (ConConcentricString, "concentric")
	46	IMPLEMENT_DOMSTRING (ConCoincidentString, "coincident")
	47	IMPLEMENT_DOMSTRING (ConDistanceString, "distance")
	48	IMPLEMENT_DOMSTRING (ConAngleString, "angle")
	49	IMPLEMENT_DOMSTRING (ConEqualRadiusString, "equalradius")
	50	IMPLEMENT_DOMSTRING (ConSymmetryString, "symmetry")
	51	IMPLEMENT_DOMSTRING (ConMidPointString, "midpoint")
	52	IMPLEMENT_DOMSTRING (ConEqualDistanceString, "equaldist")
	53	IMPLEMENT_DOMSTRING (ConFixString, "fix")
	54	IMPLEMENT_DOMSTRING (ConRigidString, "rigid")
	55	// placement constraints
	56	IMPLEMENT_DOMSTRING (ConFromString, "from")
	57	IMPLEMENT_DOMSTRING (ConAxisString, "axis")
	58	IMPLEMENT_DOMSTRING (ConMateString, "mate")
	59	IMPLEMENT_DOMSTRING (ConAlignFacesString, "alignfaces")
	60	IMPLEMENT_DOMSTRING (ConAlignAxesString, "alignaxes")
	61	IMPLEMENT_DOMSTRING (ConAxesAngleString, "axesangle")
	62	IMPLEMENT_DOMSTRING (ConFacesAngleString, "facesangle")
	63	IMPLEMENT_DOMSTRING (ConRoundString, "round")
	64	IMPLEMENT_DOMSTRING (ConOffsetString, "offset")
	65
	66	//=======================================================================
	67	//function : XmlMDataXtd_ConstraintDriver
	68	//purpose : Constructor
	69	//=======================================================================
	70	XmlMDataXtd_ConstraintDriver::XmlMDataXtd_ConstraintDriver
	71	(const Handle(CDM_MessageDriver)& theMsgDriver)
	72	: XmlMDF_ADriver (theMsgDriver, NULL)
	73	{}
	74
	75	//=======================================================================
	76	//function : NewEmpty
	77	//purpose :
	78	//=======================================================================
	79	Handle(TDF_Attribute) XmlMDataXtd_ConstraintDriver::NewEmpty() const
	80	{
	81	return (new TDataXtd_Constraint());
	82	}
	83
	84	//=======================================================================
	85	//function : Paste
	86	//purpose : persistent -> transient (retrieve)
	87	//=======================================================================
	88	Standard_Boolean XmlMDataXtd_ConstraintDriver::Paste
	89	(const XmlObjMgt_Persistent& theSource,
90	const Handle(TDF_Attribute)& theTarget,
91	XmlObjMgt_RRelocationTable& theRelocTable) const
92	{
93	Handle(TDataXtd_Constraint) aC =
94	Handle(TDataXtd_Constraint)::DownCast(theTarget);
95	const XmlObjMgt_Element& anElem = theSource;
96
97	Standard_Integer aNb;
98	TCollection_ExtendedString aMsgString;
99
100	// value
101	Handle(TDataStd_Real) aTValue;
102	XmlObjMgt_DOMString aDOMStr = anElem.getAttribute(::ValueString());
103	if (aDOMStr != NULL)
104	{
105	if (!aDOMStr.GetInteger(aNb))
106	{
107	aMsgString = TCollection_ExtendedString
108	("XmlMDataXtd_ConstraintDriver: "
109	"Cannot retrieve reference on Integer attribute from \"")
110	+ aDOMStr + "\"";
111	WriteMessage (aMsgString);
112	return Standard_False;
113	}
114	if (aNb > 0)
115	{
116	if (theRelocTable.IsBound(aNb))
117	aTValue = Handle(TDataStd_Real)::DownCast(theRelocTable.Find(aNb));
118	else
119	{
120	aTValue = new TDataStd_Real;
121	theRelocTable.Bind(aNb, aTValue);
122	}
123	aC->SetValue(aTValue);
124	}
125	}
126
127	// geometries
128	aDOMStr = anElem.getAttribute(::GeometriesString());
129	if (aDOMStr != NULL)
130	{
131	Standard_CString aGs = Standard_CString(aDOMStr.GetString());
132
133	// first geometry
134	if (!XmlObjMgt::GetInteger(aGs, aNb))
135	{
136	aMsgString = TCollection_ExtendedString
137	("XmlMDataXtd_ConstraintDriver: Cannot retrieve reference on first Geometry from \"")
138	+ aDOMStr + "\"";
139	WriteMessage (aMsgString);
140	return Standard_False;
141	}
142	Standard_Integer i = 1;
143	while (aNb > 0)
144	{
145	Handle(TNaming_NamedShape) aG;
146	if (theRelocTable.IsBound(aNb))
147	aG = Handle(TNaming_NamedShape)::DownCast(theRelocTable.Find(aNb));
148	else
149	{
150	aG = new TNaming_NamedShape;
151	theRelocTable.Bind(aNb, aG);
152	}
153	aC->SetGeometry (i, aG);
154
155	// next geometry
156	if (!XmlObjMgt::GetInteger(aGs, aNb)) aNb = 0;
157	i++;
158	}
159	}
160
161	// plane
162	aDOMStr = anElem.getAttribute(::PlaneString());
163	if (aDOMStr != NULL)
164	{
165	if (!aDOMStr.GetInteger(aNb))
166	{
167	aMsgString = TCollection_ExtendedString
168	("XmlMDataXtd_ConstraintDriver: Cannot retrieve reference on Plane from \"")
169	+ aDOMStr + "\"";
170	WriteMessage (aMsgString);
171	return Standard_False;
172	}
173	Handle(TNaming_NamedShape) aTPlane;
174	if (aNb > 0)
175	{
176	if (theRelocTable.IsBound(aNb))
177	aTPlane = Handle(TNaming_NamedShape)::DownCast(theRelocTable.Find(aNb));
178	else
179	{
180	aTPlane = new TNaming_NamedShape;
181	theRelocTable.Bind(aNb, aTPlane);
182	}
183	aC->SetPlane(aTPlane);
184	}
185	}
186
187	// constraint type
188	XmlObjMgt_DOMString aType = anElem.getAttribute(::TypeString());
189	aC->SetType(ConstraintTypeEnum(aType));
190
191	// flags
192	XmlObjMgt_DOMString aString = anElem.getAttribute(::StatusString());
193	const char * aPtr = aString.GetString();
194	aC->Verified((*aPtr) == '+');
195	aPtr ++;
196	aC->Inverted((*aPtr) == '+');
197	aPtr ++;
198	aC->Reversed((*aPtr) == '+');
199
200	return Standard_True;
201	}
202
203	//=======================================================================
204	//function : Paste
205	//purpose : transient -> persistent (store)
206	//=======================================================================
207	void XmlMDataXtd_ConstraintDriver::Paste
208	(const Handle(TDF_Attribute)& theSource,
209	XmlObjMgt_Persistent& theTarget,
210	XmlObjMgt_SRelocationTable& theRelocTable) const
211	{
212	Handle(TDataXtd_Constraint) aC =
213	Handle(TDataXtd_Constraint)::DownCast(theSource);
214	XmlObjMgt_Element& anElem = theTarget;
215
216	Standard_Integer aNb;
217
218	// value
219	Handle(TDataStd_Real) aValue = aC->GetValue();
220	if (!aValue.IsNull())
221	{
222	aNb = theRelocTable.FindIndex(aValue);
223	if (aNb == 0)
224	{
225	aNb = theRelocTable.Add(aValue);
226	}
227	anElem.setAttribute(::ValueString(), aNb);
228	}
229
230	// geometries
231	Standard_Integer NbGeom = aC->NbGeometries();
232	if (NbGeom >= 1)
233	{
234	TCollection_AsciiString aGsStr;
235	for (Standard_Integer i = 1; i <= NbGeom; i++)
236	{
237	Handle(TNaming_NamedShape) aG = aC->GetGeometry(i);
238	aNb = 0;
239	if (!aG.IsNull())
240	{
241	aNb = theRelocTable.FindIndex(aG);
242	if (aNb == 0)
243	{
244	aNb = theRelocTable.Add(aG);
245	}
246	aGsStr += TCollection_AsciiString(aNb) + " ";
247	}
248	else aGsStr += "0 ";
249	}
250	anElem.setAttribute(::GeometriesString(), aGsStr.ToCString());
251	}
252
253	// plane
254	Handle(TNaming_NamedShape) aTPlane = aC->GetPlane();
255	if (!aTPlane.IsNull())
256	{
257	aNb = theRelocTable.FindIndex(aTPlane);
258	if (aNb == 0)
259	{
260	aNb = theRelocTable.Add(aTPlane);
261	}
262	anElem.setAttribute(::PlaneString(), aNb);
263	}
264
265	// constraint type
266	anElem.setAttribute(::TypeString(), ConstraintTypeString(aC->GetType()));
267
268	// flags
269	TCollection_AsciiString aStatusStr;
270
271	if (aC->Verified()) aStatusStr += "+";
272	else aStatusStr += "-";
273
274	if (aC->Inverted()) aStatusStr += "+";
275	else aStatusStr += "-";
276
277	if (aC->Reversed()) aStatusStr += "+";
278	else aStatusStr += "-";
279
280	anElem.setAttribute(::StatusString(), aStatusStr.ToCString());
281	}
282
283	//=======================================================================
284	//function : ConstraintTypeEnum
285	//purpose :
286	//=======================================================================
287	static TDataXtd_ConstraintEnum ConstraintTypeEnum (const XmlObjMgt_DOMString& theString)
288	{
289	TDataXtd_ConstraintEnum aResult = TDataXtd_RADIUS;
290	// planar constraints
291	if (!theString.equals (::ConRadiusString()))
292	{
293	if (theString.equals (::ConDiameterString()))
294	aResult = TDataXtd_DIAMETER;
295	else if (theString.equals (::ConMinRadiusString()))
296	aResult = TDataXtd_MINOR_RADIUS;
297	else if (theString.equals (::ConMajRadiusString()))
298	aResult = TDataXtd_MAJOR_RADIUS;
299	else if (theString.equals (::ConTangentString()))
300	aResult = TDataXtd_TANGENT;
301	else if (theString.equals (::ConParallelString()))
302	aResult = TDataXtd_PARALLEL;
303	else if (theString.equals (::ConPerpendicularString()))
304	aResult = TDataXtd_PERPENDICULAR;
305	else if (theString.equals (::ConConcentricString()))
306	aResult = TDataXtd_CONCENTRIC;
307	else if (theString.equals (::ConCoincidentString()))
308	aResult = TDataXtd_COINCIDENT;
309	else if (theString.equals (::ConDistanceString()))
310	aResult = TDataXtd_DISTANCE;
311	else if (theString.equals (::ConAngleString()))
312	aResult = TDataXtd_ANGLE;
313	else if (theString.equals (::ConEqualRadiusString()))
314	aResult = TDataXtd_EQUAL_RADIUS;
315	else if (theString.equals (::ConSymmetryString()))
316	aResult = TDataXtd_SYMMETRY;
317	else if (theString.equals (::ConMidPointString()))
318	aResult = TDataXtd_MIDPOINT;
319	else if (theString.equals (::ConEqualDistanceString()))
320	aResult = TDataXtd_EQUAL_DISTANCE;
321	else if (theString.equals (::ConFixString()))
322	aResult = TDataXtd_FIX;
323	else if (theString.equals (::ConRigidString()))
324	aResult = TDataXtd_RIGID;
325	// placement constraints
326	else if (theString.equals (::ConFromString()))
327	aResult = TDataXtd_FROM;
328	else if (theString.equals (::ConAxisString()))
329	aResult = TDataXtd_AXIS;
330	else if (theString.equals (::ConMateString()))
331	aResult = TDataXtd_MATE;
332	else if (theString.equals (::ConAlignFacesString()))
333	aResult = TDataXtd_ALIGN_FACES;
334	else if (theString.equals (::ConAlignAxesString()))
335	aResult = TDataXtd_ALIGN_AXES;
336	else if (theString.equals (::ConAxesAngleString()))
337	aResult = TDataXtd_AXES_ANGLE;
338	else if (theString.equals (::ConFacesAngleString()))
339	aResult = TDataXtd_FACES_ANGLE;
340	else if (theString.equals (::ConRoundString()))
341	aResult = TDataXtd_ROUND;
342	else if (theString.equals (::ConOffsetString()))
343	aResult = TDataXtd_OFFSET;
344	else
345	Standard_DomainError::Raise
346	("TDataXtd_ConstraintEnum; string value without enum term equivalence");
347	}
348	return aResult;
349	}
350
351	//=======================================================================
352	//function : ConstraintTypeString
353	//purpose :
354	//=======================================================================
355	static const XmlObjMgt_DOMString& ConstraintTypeString (const TDataXtd_ConstraintEnum theE)
356	{
357	switch (theE)
358	{
359	// planar constraints
360	case TDataXtd_RADIUS : return ::ConRadiusString();
361	case TDataXtd_DIAMETER : return ::ConDiameterString();
362	case TDataXtd_MINOR_RADIUS : return ::ConMinRadiusString();
363	case TDataXtd_MAJOR_RADIUS : return ::ConMajRadiusString();
364	case TDataXtd_TANGENT : return ::ConTangentString();
365	case TDataXtd_PARALLEL : return ::ConParallelString();
366	case TDataXtd_PERPENDICULAR : return ::ConPerpendicularString();
367	case TDataXtd_CONCENTRIC : return ::ConConcentricString();
368	case TDataXtd_COINCIDENT : return ::ConCoincidentString();
369	case TDataXtd_DISTANCE : return ::ConDistanceString();
370	case TDataXtd_ANGLE : return ::ConAngleString();
371	case TDataXtd_EQUAL_RADIUS : return ::ConEqualRadiusString();
372	case TDataXtd_SYMMETRY : return ::ConSymmetryString();
373	case TDataXtd_MIDPOINT : return ::ConMidPointString();
374	case TDataXtd_EQUAL_DISTANCE : return ::ConEqualDistanceString();
375	case TDataXtd_FIX : return ::ConFixString();
376	case TDataXtd_RIGID : return ::ConRigidString();
377	// placement constraints
378	case TDataXtd_FROM : return ::ConFromString();
379	case TDataXtd_AXIS : return ::ConAxisString();
380	case TDataXtd_MATE : return ::ConMateString();
381	case TDataXtd_ALIGN_FACES : return ::ConAlignFacesString();
382	case TDataXtd_ALIGN_AXES : return ::ConAlignAxesString();
383	case TDataXtd_AXES_ANGLE : return ::ConAxesAngleString();
384	case TDataXtd_FACES_ANGLE : return ::ConFacesAngleString();
385	case TDataXtd_ROUND : return ::ConRoundString();
386	case TDataXtd_OFFSET : return ::ConOffsetString();
387
388	default:
389	Standard_DomainError::Raise("TDataXtd_ConstraintEnum; enum term unknown");
390	}
391	static XmlObjMgt_DOMString aNullString;
392	return aNullString; // To avoid compilation error message.
393	}