Integration of OCCT 6.5.0 from SVN

src/XmlMDataStd/XmlMDataStd.cdl

@@ -0,0 +1,73 @@
+-- File:        XmlMDataStd.cdl
+
+package XmlMDataStd 
+
+        ---Purpose: Storage and Retrieval drivers for modelling attributes.
+        --          Transient attributes are defined in package TDataStd.
+
+uses XmlMDF,
+     XmlObjMgt,
+     TDF,
+     CDM
+
+is
+        ---Purpose: Storage/Retrieval drivers for TDataStd attributes
+        --          =======================================
+
+        class NameDriver;
+
+        class IntegerDriver;
+        
+        class RealDriver;
+        
+        class IntegerArrayDriver;
+        
+        class RealArrayDriver;
+        
+        class ExtStringArrayDriver;
+        
+        class UAttributeDriver;
+        
+        class DirectoryDriver;
+        
+        class CommentDriver;
+        
+        class VariableDriver;
+        
+        class ExpressionDriver;
+        
+        class RelationDriver;
+        
+        class NoteBookDriver;
+        
+        class TreeNodeDriver;  
+	
+	-- Extension	 
+        class TickDriver;
+
+        -- Lists:
+       class IntegerListDriver; 
+       class RealListDriver;
+       class ExtStringListDriver;
+       class BooleanListDriver;
+       class ReferenceListDriver;
+    
+       -- Arrays:
+       class BooleanArrayDriver;
+       class ReferenceArrayDriver;
+       class ByteArrayDriver;
+
+
+       class NamedDataDriver;  
+       class AsciiStringDriver;
+       class IntPackedMapDriver; 
+
+    AddDrivers (aDriverTable : ADriverTable  from XmlMDF;
+                anMsgDrv     : MessageDriver from CDM);
+        ---Purpose: Adds the attribute drivers to <aDriverTable>.  
+	
+    SetDocumentVersion (DocVersion  : Integer from Standard); 
+    
+    DocumentVersion returns Integer from Standard; 	
+
+end XmlMDataStd;

src/XmlMDataStd/XmlMDataStd.cxx

@@ -0,0 +1,89 @@
+// File:        XmlMDataStd.cxx
+// Created:     Mon Aug 27 17:33:16 2001
+// Author:      Alexander GRIGORIEV
+// Copyright:   Open Cascade 2001
+// History:
+// modified     20.04.2009 Sergey Zaritchny
+
+#include <XmlMDataStd.ixx>
+
+#include <XmlMDataStd_DirectoryDriver.hxx>
+#include <XmlMDataStd_UAttributeDriver.hxx>
+#include <XmlMDataStd_IntegerArrayDriver.hxx>
+#include <XmlMDataStd_RealArrayDriver.hxx>
+#include <XmlMDataStd_ExtStringArrayDriver.hxx>
+#include <XmlMDataStd_NameDriver.hxx>
+#include <XmlMDataStd_CommentDriver.hxx>
+#include <XmlMDataStd_IntegerDriver.hxx>
+#include <XmlMDataStd_RealDriver.hxx>
+#include <XmlMDataStd_VariableDriver.hxx>
+#include <XmlMDataStd_ExpressionDriver.hxx>
+#include <XmlMDataStd_RelationDriver.hxx>
+#include <XmlMDataStd_NoteBookDriver.hxx>
+#include <XmlMDataStd_TreeNodeDriver.hxx>
+#include <XmlMDataStd_TickDriver.hxx>
+#include <XmlMDataStd_IntegerListDriver.hxx>
+#include <XmlMDataStd_RealListDriver.hxx>
+#include <XmlMDataStd_ExtStringListDriver.hxx>
+#include <XmlMDataStd_BooleanListDriver.hxx>
+#include <XmlMDataStd_ReferenceListDriver.hxx>
+#include <XmlMDataStd_BooleanArrayDriver.hxx>
+#include <XmlMDataStd_ReferenceArrayDriver.hxx>
+#include <XmlMDataStd_ByteArrayDriver.hxx>
+#include <XmlMDataStd_NamedDataDriver.hxx>
+#include <XmlMDataStd_AsciiStringDriver.hxx>
+#include <XmlMDataStd_IntPackedMapDriver.hxx>
+
+static Standard_Integer myDocumentVersion = -1;
+//=======================================================================
+//function : AddDrivers
+//purpose  : 
+//=======================================================================
+void XmlMDataStd::AddDrivers (const Handle(XmlMDF_ADriverTable)& aDriverTable,
+                              const Handle(CDM_MessageDriver)&   anMsgDrv)
+{
+  aDriverTable-> AddDriver (new XmlMDataStd_DirectoryDriver     (anMsgDrv));
+  aDriverTable-> AddDriver (new XmlMDataStd_IntegerArrayDriver  (anMsgDrv));
+  aDriverTable-> AddDriver (new XmlMDataStd_RealArrayDriver     (anMsgDrv));
+  aDriverTable-> AddDriver (new XmlMDataStd_UAttributeDriver    (anMsgDrv));
+  aDriverTable-> AddDriver (new XmlMDataStd_NameDriver          (anMsgDrv));
+  aDriverTable-> AddDriver (new XmlMDataStd_CommentDriver       (anMsgDrv));
+  aDriverTable-> AddDriver (new XmlMDataStd_IntegerDriver       (anMsgDrv));
+  aDriverTable-> AddDriver (new XmlMDataStd_RealDriver          (anMsgDrv));
+  aDriverTable-> AddDriver (new XmlMDataStd_VariableDriver      (anMsgDrv));
+  aDriverTable-> AddDriver (new XmlMDataStd_ExpressionDriver    (anMsgDrv));
+  aDriverTable-> AddDriver (new XmlMDataStd_RelationDriver      (anMsgDrv));
+  aDriverTable-> AddDriver (new XmlMDataStd_NoteBookDriver      (anMsgDrv));
+  aDriverTable-> AddDriver (new XmlMDataStd_TreeNodeDriver      (anMsgDrv));
+  aDriverTable-> AddDriver (new XmlMDataStd_ExtStringArrayDriver(anMsgDrv));
+
+  aDriverTable-> AddDriver (new XmlMDataStd_TickDriver          (anMsgDrv));
+  aDriverTable-> AddDriver (new XmlMDataStd_IntegerListDriver   (anMsgDrv));
+  aDriverTable-> AddDriver (new XmlMDataStd_RealListDriver      (anMsgDrv));
+  aDriverTable-> AddDriver (new XmlMDataStd_ExtStringListDriver (anMsgDrv));
+  aDriverTable-> AddDriver (new XmlMDataStd_BooleanListDriver   (anMsgDrv));
+  aDriverTable-> AddDriver (new XmlMDataStd_ReferenceListDriver (anMsgDrv));
+  aDriverTable-> AddDriver (new XmlMDataStd_BooleanArrayDriver  (anMsgDrv));
+  aDriverTable-> AddDriver (new XmlMDataStd_ReferenceArrayDriver(anMsgDrv));
+  aDriverTable-> AddDriver (new XmlMDataStd_ByteArrayDriver     (anMsgDrv));
+  aDriverTable-> AddDriver (new XmlMDataStd_NamedDataDriver     (anMsgDrv));
+  aDriverTable-> AddDriver (new XmlMDataStd_AsciiStringDriver   (anMsgDrv));
+  aDriverTable-> AddDriver (new XmlMDataStd_IntPackedMapDriver  (anMsgDrv));
+}
+
+//=======================================================================
+//function : SetDocumentVersion
+//purpose  : Sets current document version
+//=======================================================================
+void XmlMDataStd::SetDocumentVersion(const Standard_Integer theVersion)
+{
+  myDocumentVersion = theVersion;
+}
+//=======================================================================
+//function : DocumentVersion
+//purpose  : Retrieved document version
+//=======================================================================
+Standard_Integer XmlMDataStd::DocumentVersion()
+{
+  return myDocumentVersion;
+}

src/XmlMDataStd/XmlMDataStd_AsciiStringDriver.cdl

@@ -0,0 +1,37 @@
+-- File:	XmlMDataStd_AsciiStringDriver.cdl
+-- Created:	Tue Aug 21 16:31:01 2007
+-- Author:	Sergey ZARITCHNY
+--		<sergey.zaritchny@opencascade.com>
+---Copyright:	Open CasCade SA 2007
+
+
+class AsciiStringDriver from XmlMDataStd inherits ADriver from XmlMDF
+
+	---Purpose: TDataStd_AsciiString attribute Driver.
+
+uses
+    SRelocationTable from XmlObjMgt,
+    RRelocationTable from XmlObjMgt,
+    Persistent       from XmlObjMgt,
+    MessageDriver    from CDM,
+    Attribute        from TDF
+
+is
+    Create (theMessageDriver:MessageDriver from CDM)
+        returns mutable AsciiStringDriver from XmlMDataStd;
+
+    NewEmpty (me)  returns mutable Attribute from TDF;
+
+    Paste(me; Source     : Persistent from XmlObjMgt;
+              Target     : mutable Attribute from TDF;
+              RelocTable : out RRelocationTable from XmlObjMgt)
+        returns Boolean from Standard;
+    ---Purpose: persistent -> transient (retrieve)
+
+    Paste(me; Source     : Attribute from TDF;
+              Target     : in out Persistent from XmlObjMgt;
+              RelocTable : out SRelocationTable from XmlObjMgt);
+    ---Purpose: transient -> persistent (store)
+
+
+end AsciiStringDriver;

src/XmlMDataStd/XmlMDataStd_AsciiStringDriver.cxx

@@ -0,0 +1,62 @@
+// File:	XmlMDataStd_AsciiStringDriver.cxx
+// Created:	Tue Aug 21 16:35:28 2007
+// Author:	Sergey ZARITCHNY
+//		<sergey.zaritchny@opencascade.com>
+// Copyright:   Open CASCADE SA 2007
+
+#include <XmlMDataStd_AsciiStringDriver.ixx>
+#include <XmlObjMgt.hxx>
+#include <XmlObjMgt_RRelocationTable.hxx>
+#include <XmlObjMgt_SRelocationTable.hxx>
+#include <TDataStd_AsciiString.hxx>
+
+//=======================================================================
+//function : XmlMDataStd_AsciiStringDriver
+//purpose  : Constructor
+//=======================================================================
+
+XmlMDataStd_AsciiStringDriver::XmlMDataStd_AsciiStringDriver
+                        (const Handle(CDM_MessageDriver)& theMsgDriver)
+      : XmlMDF_ADriver (theMsgDriver, NULL)
+{}
+
+//=======================================================================
+//function : NewEmpty()
+//purpose  : 
+//=======================================================================
+Handle(TDF_Attribute) XmlMDataStd_AsciiStringDriver::NewEmpty () const
+{
+  return (new TDataStd_AsciiString());
+}
+
+//=======================================================================
+//function : Paste()
+//purpose  : retrieve
+//=======================================================================
+Standard_Boolean XmlMDataStd_AsciiStringDriver::Paste
+                               (const XmlObjMgt_Persistent&  theSource,
+                                const Handle(TDF_Attribute)& theTarget,
+                                XmlObjMgt_RRelocationTable&  ) const
+{
+  if(!theTarget.IsNull()) {
+    const TCollection_AsciiString aString = XmlObjMgt::GetStringValue (theSource);
+    Handle(TDataStd_AsciiString)::DownCast(theTarget) -> Set (aString);
+    return Standard_True;
+  }
+  WriteMessage("error retrieving AsciiString for type TDataStd_AsciiString");
+  return Standard_False;
+}
+
+//=======================================================================
+//function : Paste()
+//purpose  : store
+//=======================================================================
+void XmlMDataStd_AsciiStringDriver::Paste (const Handle(TDF_Attribute)& theSource,
+                                    XmlObjMgt_Persistent&        theTarget,
+                                    XmlObjMgt_SRelocationTable&  ) const
+{
+  Handle(TDataStd_AsciiString) aS = Handle(TDataStd_AsciiString)::DownCast(theSource);
+  if (aS.IsNull()) return;
+  XmlObjMgt_DOMString aString = aS->Get().ToCString();
+  XmlObjMgt::SetStringValue (theTarget, aString);
+}

src/XmlMDataStd/XmlMDataStd_BooleanArrayDriver.cdl

@@ -0,0 +1,34 @@
+-- File:        XmlMDataStd_BooleanArrayDriver.cdl
+-- Created:     May 29 11:40:00 2007
+-- Author:      Vlad Romashko
+--  	    	<vladislav.romashko@opencascade.com>
+-- Copyright:   Open CASCADE
+
+class BooleanArrayDriver from XmlMDataStd inherits ADriver from XmlMDF
+
+uses
+
+    SRelocationTable from XmlObjMgt,
+    RRelocationTable from XmlObjMgt,
+    Persistent       from XmlObjMgt,
+    MessageDriver    from CDM,
+    Attribute        from TDF
+
+is
+
+    Create (theMessageDriver:MessageDriver from CDM)
+    returns mutable BooleanArrayDriver from XmlMDataStd;
+
+    NewEmpty (me)
+    returns mutable Attribute from TDF;
+
+    Paste(me; Source     : Persistent from XmlObjMgt;
+              Target     : mutable Attribute from TDF;
+              RelocTable : out RRelocationTable from XmlObjMgt)
+    returns Boolean from Standard;
+
+    Paste(me; Source     : Attribute from TDF;
+              Target     : in out Persistent from XmlObjMgt;
+              RelocTable : out SRelocationTable from XmlObjMgt);
+
+end BooleanArrayDriver;

src/XmlMDataStd/XmlMDataStd_BooleanArrayDriver.cxx

@@ -0,0 +1,129 @@
+// File:        XmlMDataStd_BooleanArrayDriver.cxx
+// Created:     May 29 11:40:00 2007
+// Author:      Vlad Romashko
+//  	    	<vladislav.romashko@opencascade.com>
+// Copyright:   Open CASCADE
+
+#include <XmlMDataStd_BooleanArrayDriver.ixx>
+#include <TDataStd_BooleanArray.hxx>
+#include <TColStd_HArray1OfByte.hxx>
+#include <XmlObjMgt.hxx>
+
+IMPLEMENT_DOMSTRING (FirstIndexString, "first")
+IMPLEMENT_DOMSTRING (LastIndexString,  "last")
+
+//=======================================================================
+//function : XmlMDataStd_BooleanArrayDriver
+//purpose  : Constructor
+//=======================================================================
+XmlMDataStd_BooleanArrayDriver::XmlMDataStd_BooleanArrayDriver(const Handle(CDM_MessageDriver)& theMsgDriver)
+     : XmlMDF_ADriver (theMsgDriver, NULL)
+{
+
+}
+
+//=======================================================================
+//function : NewEmpty
+//purpose  : 
+//=======================================================================
+Handle(TDF_Attribute) XmlMDataStd_BooleanArrayDriver::NewEmpty() const
+{
+  return new TDataStd_BooleanArray();
+}
+
+//=======================================================================
+//function : Paste
+//purpose  : persistent -> transient (retrieve)
+//=======================================================================
+Standard_Boolean XmlMDataStd_BooleanArrayDriver::Paste(const XmlObjMgt_Persistent&  theSource,
+						       const Handle(TDF_Attribute)& theTarget,
+						       XmlObjMgt_RRelocationTable&  ) const
+{
+  Standard_Integer aFirstInd, aLastInd, aValue, ind;
+  const XmlObjMgt_Element& anElement = theSource;
+
+  // Read the FirstIndex; if the attribute is absent initialize to 1
+  XmlObjMgt_DOMString aFirstIndex= anElement.getAttribute(::FirstIndexString());
+  if (aFirstIndex == NULL)
+    aFirstInd = 1;
+  else if (!aFirstIndex.GetInteger(aFirstInd)) 
+  {
+    TCollection_ExtendedString aMessageString =
+      TCollection_ExtendedString("Cannot retrieve the first index"
+                                 " for BooleanArray attribute as \"")
+        + aFirstIndex + "\"";
+    WriteMessage (aMessageString);
+    return Standard_False;
+  }
+
+  // Read the LastIndex; the attribute should be present
+  if (!anElement.getAttribute(::LastIndexString()).GetInteger(aLastInd)) 
+  {
+    TCollection_ExtendedString aMessageString =
+      TCollection_ExtendedString("Cannot retrieve the last index"
+                                 " for BooleanArray attribute as \"")
+        + aFirstIndex + "\"";
+    WriteMessage (aMessageString);
+    return Standard_False;
+  }
+
+  if (aFirstInd > aLastInd)
+  {
+    TCollection_ExtendedString aMessageString =
+      TCollection_ExtendedString("The last index is greater than the first index"
+                                 " for BooleanArray attribute \"");
+    WriteMessage (aMessageString);
+    return Standard_False;
+  }
+
+  Handle(TDataStd_BooleanArray) aBooleanArray = Handle(TDataStd_BooleanArray)::DownCast(theTarget);
+  aBooleanArray->Init(aFirstInd, aLastInd);
+  Standard_Integer length = aLastInd - aFirstInd + 1;
+  Handle(TColStd_HArray1OfByte) array = new TColStd_HArray1OfByte(0, length >> 3);
+
+  Standard_Integer i = 0, upper = array->Upper();
+  Standard_CString aValueStr = Standard_CString(XmlObjMgt::GetStringValue(anElement).GetString());
+  for (; i <= upper; i++)
+  {
+    if (!XmlObjMgt::GetInteger(aValueStr, aValue)) 
+    {
+      TCollection_ExtendedString aMessageString =
+	TCollection_ExtendedString("Cannot retrieve integer member"
+				   " for BooleanArray attribute as \"")
+	  + aValueStr + "\"";
+      WriteMessage (aMessageString);
+      return Standard_False;
+    }
+    array->SetValue(i, (Standard_Byte) aValue);
+  }
+  aBooleanArray->SetInternalArray(array);
+  
+  return Standard_True;
+}
+
+//=======================================================================
+//function : Paste
+//purpose  : transient -> persistent (store)
+//=======================================================================
+void XmlMDataStd_BooleanArrayDriver::Paste(const Handle(TDF_Attribute)& theSource,
+					   XmlObjMgt_Persistent&        theTarget,
+					   XmlObjMgt_SRelocationTable&  ) const
+{
+  Handle(TDataStd_BooleanArray) aBooleanArray = Handle(TDataStd_BooleanArray)::DownCast(theSource);
+
+  Standard_Integer aL = aBooleanArray->Lower();
+  Standard_Integer anU = aBooleanArray->Upper();
+  TCollection_AsciiString aValueStr;
+
+  theTarget.Element().setAttribute(::FirstIndexString(), aL);
+  theTarget.Element().setAttribute(::LastIndexString(), anU);
+
+  const Handle(TColStd_HArray1OfByte)& array = aBooleanArray->InternalArray();
+  Standard_Integer lower = array->Lower(), i = lower, upper = array->Upper();
+  for (; i <= upper; i++)
+  {
+    aValueStr += TCollection_AsciiString((Standard_Integer) array->Value(i));
+    aValueStr += ' ';
+  }
+  XmlObjMgt::SetStringValue (theTarget, aValueStr.ToCString(), Standard_True);
+}

src/XmlMDataStd/XmlMDataStd_BooleanListDriver.cdl

@@ -0,0 +1,34 @@
+-- File:        XmlMDataStd_BooleanListDriver.cdl
+-- Created:     May 29 11:40:00 2007
+-- Author:      Vlad Romashko
+--  	    	<vladislav.romashko@opencascade.com>
+-- Copyright:   Open CASCADE
+
+class BooleanListDriver from XmlMDataStd inherits ADriver from XmlMDF
+
+uses
+
+    SRelocationTable from XmlObjMgt,
+    RRelocationTable from XmlObjMgt,
+    Persistent       from XmlObjMgt,
+    MessageDriver    from CDM,
+    Attribute        from TDF
+
+is
+
+    Create (theMessageDriver:MessageDriver from CDM)
+    returns mutable BooleanListDriver from XmlMDataStd;
+
+    NewEmpty (me)
+    returns mutable Attribute from TDF;
+
+    Paste(me; Source     : Persistent from XmlObjMgt;
+              Target     : mutable Attribute from TDF;
+              RelocTable : out RRelocationTable from XmlObjMgt)
+    returns Boolean from Standard;
+
+    Paste(me; Source     : Attribute from TDF;
+              Target     : in out Persistent from XmlObjMgt;
+              RelocTable : out SRelocationTable from XmlObjMgt);
+
+end BooleanListDriver;

src/XmlMDataStd/XmlMDataStd_BooleanListDriver.cxx

@@ -0,0 +1,130 @@
+// File:        XmlMDataStd_BooleanListDriver.cxx
+// Created:     May 29 11:40:00 2007
+// Author:      Vlad Romashko
+//  	    	<vladislav.romashko@opencascade.com>
+// Copyright:   Open CASCADE
+
+#include <XmlMDataStd_BooleanListDriver.ixx>
+#include <TDataStd_BooleanList.hxx>
+#include <TDataStd_ListIteratorOfListOfByte.hxx>
+#include <XmlObjMgt.hxx>
+
+IMPLEMENT_DOMSTRING (FirstIndexString, "first")
+IMPLEMENT_DOMSTRING (LastIndexString,  "last")
+
+//=======================================================================
+//function : XmlMDataStd_BooleanListDriver
+//purpose  : Constructor
+//=======================================================================
+XmlMDataStd_BooleanListDriver::XmlMDataStd_BooleanListDriver(const Handle(CDM_MessageDriver)& theMsgDriver)
+     : XmlMDF_ADriver (theMsgDriver, NULL)
+{
+
+}
+
+//=======================================================================
+//function : NewEmpty
+//purpose  : 
+//=======================================================================
+Handle(TDF_Attribute) XmlMDataStd_BooleanListDriver::NewEmpty() const
+{
+  return new TDataStd_BooleanList();
+}
+
+//=======================================================================
+//function : Paste
+//purpose  : persistent -> transient (retrieve)
+//=======================================================================
+Standard_Boolean XmlMDataStd_BooleanListDriver::Paste(const XmlObjMgt_Persistent&  theSource,
+						      const Handle(TDF_Attribute)& theTarget,
+						      XmlObjMgt_RRelocationTable&  ) const
+{
+  Standard_Integer aFirstInd, aLastInd, aValue, ind;
+  const XmlObjMgt_Element& anElement = theSource;
+
+  // Read the FirstIndex; if the attribute is absent initialize to 1
+  XmlObjMgt_DOMString aFirstIndex= anElement.getAttribute(::FirstIndexString());
+  if (aFirstIndex == NULL)
+    aFirstInd = 1;
+  else if (!aFirstIndex.GetInteger(aFirstInd)) 
+  {
+    TCollection_ExtendedString aMessageString =
+      TCollection_ExtendedString("Cannot retrieve the first index"
+                                 " for BooleanList attribute as \"")
+        + aFirstIndex + "\"";
+    WriteMessage (aMessageString);
+    return Standard_False;
+  }
+
+  // Read the LastIndex; the attribute should be present
+  if (!anElement.getAttribute(::LastIndexString()).GetInteger(aLastInd)) 
+  {
+    TCollection_ExtendedString aMessageString =
+      TCollection_ExtendedString("Cannot retrieve the last index"
+                                 " for BooleanList attribute as \"")
+        + aFirstIndex + "\"";
+    WriteMessage (aMessageString);
+    return Standard_False;
+  }
+
+  Handle(TDataStd_BooleanList) aBooleanList = Handle(TDataStd_BooleanList)::DownCast(theTarget);
+  if (aFirstInd == aLastInd) 
+  {
+    Standard_Integer anInteger;
+    if (!XmlObjMgt::GetStringValue(anElement).GetInteger(anInteger)) 
+    {
+      TCollection_ExtendedString aMessageString =
+        TCollection_ExtendedString("Cannot retrieve integer member"
+                                   " for BooleanList attribute as \"");
+      WriteMessage (aMessageString);
+      return Standard_False;
+    }
+    aBooleanList->Append(anInteger ? Standard_True : Standard_False);
+  }
+  else 
+  {
+    Standard_CString aValueStr = Standard_CString(XmlObjMgt::GetStringValue(anElement).GetString());
+    for (ind = aFirstInd; ind <= aLastInd; ind++)
+    {
+      if (!XmlObjMgt::GetInteger(aValueStr, aValue)) 
+      {
+        TCollection_ExtendedString aMessageString =
+          TCollection_ExtendedString("Cannot retrieve integer member"
+                                     " for BooleanList attribute as \"")
+            + aValueStr + "\"";
+        WriteMessage (aMessageString);
+        return Standard_False;
+      }
+      aBooleanList->Append(aValue ? Standard_True : Standard_False);
+    }
+  }
+  
+  return Standard_True;
+}
+
+//=======================================================================
+//function : Paste
+//purpose  : transient -> persistent (store)
+//=======================================================================
+void XmlMDataStd_BooleanListDriver::Paste(const Handle(TDF_Attribute)& theSource,
+					  XmlObjMgt_Persistent&        theTarget,
+					  XmlObjMgt_SRelocationTable&  ) const
+{
+  Handle(TDataStd_BooleanList) aBooleanList = Handle(TDataStd_BooleanList)::DownCast(theSource);
+
+  Standard_Integer anU = aBooleanList->Extent();
+  TCollection_AsciiString aValueStr;
+
+  theTarget.Element().setAttribute(::LastIndexString(), anU);
+  if (anU >= 1)
+  {
+    TDataStd_ListIteratorOfListOfByte itr(aBooleanList->List());
+    for (; itr.More(); itr.Next())
+    {
+      aValueStr += TCollection_AsciiString(itr.Value());
+      aValueStr += ' ';
+    }
+  }
+  // No occurrence of '&', '<' and other irregular XML characters
+  XmlObjMgt::SetStringValue (theTarget, aValueStr.ToCString(), Standard_True);
+}

src/XmlMDataStd/XmlMDataStd_ByteArrayDriver.cdl

@@ -0,0 +1,34 @@
+-- File:        XmlMDataStd_ByteArrayDriver.cdl
+-- Created:     May 29 11:40:00 2007
+-- Author:      Vlad Romashko
+--  	    	<vladislav.romashko@opencascade.com>
+-- Copyright:   Open CASCADE
+
+class ByteArrayDriver from XmlMDataStd inherits ADriver from XmlMDF
+
+uses
+
+    SRelocationTable from XmlObjMgt,
+    RRelocationTable from XmlObjMgt,
+    Persistent       from XmlObjMgt,
+    MessageDriver    from CDM,
+    Attribute        from TDF
+
+is
+
+    Create (theMessageDriver:MessageDriver from CDM)
+    returns mutable ByteArrayDriver from XmlMDataStd;
+
+    NewEmpty (me)
+    returns mutable Attribute from TDF;
+
+    Paste(me; Source     : Persistent from XmlObjMgt;
+              Target     : mutable Attribute from TDF;
+              RelocTable : out RRelocationTable from XmlObjMgt)
+    returns Boolean from Standard;
+
+    Paste(me; Source     : Attribute from TDF;
+              Target     : in out Persistent from XmlObjMgt;
+              RelocTable : out SRelocationTable from XmlObjMgt);
+
+end ByteArrayDriver;

src/XmlMDataStd/XmlMDataStd_ByteArrayDriver.cxx

@@ -0,0 +1,156 @@
+// File:        XmlMDataStd_ByteArrayDriver.cxx
+// Created:     May 29 11:40:00 2007
+// Author:      Vlad Romashko
+//  	    	<vladislav.romashko@opencascade.com>
+// Copyright:   Open CASCADE
+
+#include <XmlMDataStd_ByteArrayDriver.ixx>
+#include <TDataStd_ByteArray.hxx>
+#include <TColStd_HArray1OfByte.hxx>
+#include <XmlObjMgt.hxx>
+#include <XmlMDataStd.hxx>
+
+IMPLEMENT_DOMSTRING (FirstIndexString, "first")
+IMPLEMENT_DOMSTRING (LastIndexString,  "last")
+IMPLEMENT_DOMSTRING (IsDeltaOn,        "delta")
+//=======================================================================
+//function : XmlMDataStd_ByteArrayDriver
+//purpose  : Constructor
+//=======================================================================
+XmlMDataStd_ByteArrayDriver::XmlMDataStd_ByteArrayDriver(const Handle(CDM_MessageDriver)& theMsgDriver)
+     : XmlMDF_ADriver (theMsgDriver, NULL)
+{
+
+}
+
+//=======================================================================
+//function : NewEmpty
+//purpose  : 
+//=======================================================================
+Handle(TDF_Attribute) XmlMDataStd_ByteArrayDriver::NewEmpty() const
+{
+  return new TDataStd_ByteArray();
+}
+
+//=======================================================================
+//function : Paste
+//purpose  : persistent -> transient (retrieve)
+//=======================================================================
+Standard_Boolean XmlMDataStd_ByteArrayDriver::Paste(const XmlObjMgt_Persistent&  theSource,
+						    const Handle(TDF_Attribute)& theTarget,
+						    XmlObjMgt_RRelocationTable&  ) const
+{
+  Standard_Integer aFirstInd, aLastInd, aValue;
+  const XmlObjMgt_Element& anElement = theSource;
+
+  // Read the FirstIndex; if the attribute is absent initialize to 1
+  XmlObjMgt_DOMString aFirstIndex= anElement.getAttribute(::FirstIndexString());
+  if (aFirstIndex == NULL)
+    aFirstInd = 1;
+  else if (!aFirstIndex.GetInteger(aFirstInd)) 
+  {
+    TCollection_ExtendedString aMessageString =
+      TCollection_ExtendedString("Cannot retrieve the first index"
+                                 " for ByteArray attribute as \"")
+        + aFirstIndex + "\"";
+    WriteMessage (aMessageString);
+    return Standard_False;
+  }
+
+  // Read the LastIndex; the attribute should be present
+  if (!anElement.getAttribute(::LastIndexString()).GetInteger(aLastInd)) 
+  {
+    TCollection_ExtendedString aMessageString =
+      TCollection_ExtendedString("Cannot retrieve the last index"
+                                 " for ByteArray attribute as \"")
+        + aFirstIndex + "\"";
+    WriteMessage (aMessageString);
+    return Standard_False;
+  }
+
+  if (aFirstInd > aLastInd)
+  {
+    TCollection_ExtendedString aMessageString =
+      TCollection_ExtendedString("The last index is greater than the first index"
+                                 " for ByteArray attribute \"");
+    WriteMessage (aMessageString);
+    return Standard_False;
+  }
+
+
+  Handle(TDataStd_ByteArray) aByteArray = Handle(TDataStd_ByteArray)::DownCast(theTarget);
+  Handle(TColStd_HArray1OfByte) array = new TColStd_HArray1OfByte(aFirstInd, aLastInd);
+
+  Standard_CString aValueStr = Standard_CString(XmlObjMgt::GetStringValue(anElement).GetString());
+  Standard_Integer i = array->Lower(), upper = array->Upper();
+  for (; i <= upper; i++)
+  {
+    if (!XmlObjMgt::GetInteger(aValueStr, aValue)) 
+    {
+      TCollection_ExtendedString aMessageString =
+	TCollection_ExtendedString("Cannot retrieve integer member"
+				   " for ByteArray attribute as \"")
+	  + aValueStr + "\"";
+      WriteMessage (aMessageString);
+      return Standard_False;
+    }
+    array->SetValue(i, (Standard_Byte) aValue);
+  }
+  aByteArray->ChangeArray(array);
+  
+#ifdef DEB
+  //cout << "CurDocVersion = " << XmlMDataStd::DocumentVersion() <<endl;
+#endif
+  Standard_Boolean aDelta(Standard_False);
+  
+  if(XmlMDataStd::DocumentVersion() > 2) {
+    Standard_Integer aDeltaValue;
+    if (!anElement.getAttribute(::IsDeltaOn()).GetInteger(aDeltaValue)) 
+      {
+	TCollection_ExtendedString aMessageString =
+	  TCollection_ExtendedString("Cannot retrieve the isDelta value"
+                                 " for ByteArray attribute as \"")
+        + aDeltaValue + "\"";
+	WriteMessage (aMessageString);
+	return Standard_False;
+      } 
+    else
+      aDelta = (Standard_Boolean)aDeltaValue;
+  }
+#ifdef DEB
+  else if(XmlMDataStd::DocumentVersion() == -1)
+    cout << "Current DocVersion field is not initialized. "  <<endl;
+#endif
+  aByteArray->SetDelta(aDelta);
+
+  return Standard_True;
+}
+
+//=======================================================================
+//function : Paste
+//purpose  : transient -> persistent (store)
+//=======================================================================
+void XmlMDataStd_ByteArrayDriver::Paste(const Handle(TDF_Attribute)& theSource,
+					XmlObjMgt_Persistent&        theTarget,
+					XmlObjMgt_SRelocationTable&  ) const
+{
+  Handle(TDataStd_ByteArray) aByteArray = Handle(TDataStd_ByteArray)::DownCast(theSource);
+
+  Standard_Integer aL = aByteArray->Lower();
+  Standard_Integer anU = aByteArray->Upper();
+  TCollection_AsciiString aValueStr;
+
+  theTarget.Element().setAttribute(::FirstIndexString(), aL);
+  theTarget.Element().setAttribute(::LastIndexString(), anU);
+  theTarget.Element().setAttribute(::IsDeltaOn(),aByteArray->GetDelta());
+
+  const Handle(TColStd_HArray1OfByte)& array = aByteArray->InternalArray();
+  Standard_Integer lower = array->Lower(), i = lower, upper = array->Upper();
+  for (; i <= upper; i++)
+  {
+    aValueStr += TCollection_AsciiString((Standard_Integer) array->Value(i));
+    aValueStr += ' ';
+  }
+  XmlObjMgt::SetStringValue (theTarget, aValueStr.ToCString(), Standard_True);
+
+}

src/XmlMDataStd/XmlMDataStd_CommentDriver.cdl

@@ -0,0 +1,32 @@
+-- File:        XmlMDataStd_CommentDriver.cdl
+-- Created:     Fri Aug 24 20:16:51 2001
+-- Author:      Alexander GRIGORIEV
+-- Copyright:   Open Cascade 2001
+
+class CommentDriver from XmlMDataStd  inherits ADriver from XmlMDF
+
+        ---Purpose: Attribute Driver.
+
+uses
+    SRelocationTable from XmlObjMgt,
+    RRelocationTable from XmlObjMgt,
+    Persistent       from XmlObjMgt,
+    MessageDriver    from CDM,
+    Attribute        from TDF
+
+is
+    Create (theMessageDriver:MessageDriver from CDM)
+        returns mutable CommentDriver from XmlMDataStd;
+
+    NewEmpty (me)  returns mutable Attribute from TDF;
+
+    Paste(me; Source     : Persistent from XmlObjMgt;
+              Target     : mutable Attribute from TDF;
+              RelocTable : out RRelocationTable from XmlObjMgt)
+        returns Boolean from Standard;
+
+    Paste(me; Source     : Attribute from TDF;
+              Target     : in out Persistent from XmlObjMgt;
+              RelocTable : out SRelocationTable from XmlObjMgt);
+
+end CommentDriver;

src/XmlMDataStd/XmlMDataStd_CommentDriver.cxx

@@ -0,0 +1,59 @@
+// File:        XmlMDataStd_CommentDriver.cxx
+// Created:     Fri Aug 24 20:46:58 2001
+// Author:      Alexnder GRIGORIEV
+// Copyright:   Open Cascade 2001
+// History:
+
+#include <XmlMDataStd_CommentDriver.ixx>
+#include <TDataStd_Comment.hxx>
+#include <XmlObjMgt.hxx>
+
+//=======================================================================
+//function : XmlMDataStd_CommentDriver
+//purpose  : Constructor
+//=======================================================================
+
+XmlMDataStd_CommentDriver::XmlMDataStd_CommentDriver
+                        (const Handle(CDM_MessageDriver)& theMsgDriver)
+      : XmlMDF_ADriver (theMsgDriver, NULL)
+{}
+
+//=======================================================================
+//function : NewEmpty
+//purpose  : 
+//=======================================================================
+Handle(TDF_Attribute) XmlMDataStd_CommentDriver::NewEmpty() const
+{
+  return (new TDataStd_Comment());
+}
+
+//=======================================================================
+//function : Paste
+//purpose  : 
+//=======================================================================
+Standard_Boolean XmlMDataStd_CommentDriver::Paste
+                                (const XmlObjMgt_Persistent&  theSource,
+                                 const Handle(TDF_Attribute)& theTarget,
+                                 XmlObjMgt_RRelocationTable&  ) const
+{
+  TCollection_ExtendedString aString;
+  if (XmlObjMgt::GetExtendedString (theSource, aString))
+  {
+    Handle(TDataStd_Comment)::DownCast(theTarget) -> Set (aString);
+    return Standard_True;
+  }
+  WriteMessage("error retrieving ExtendedString for type TDataStd_Comment");
+  return Standard_False;
+}
+
+//=======================================================================
+//function : Paste
+//purpose  : 
+//=======================================================================
+void XmlMDataStd_CommentDriver::Paste (const Handle(TDF_Attribute)& theSource,
+                                       XmlObjMgt_Persistent&        theTarget,
+                                       XmlObjMgt_SRelocationTable&  ) const
+{
+  Handle(TDataStd_Comment) aName= Handle(TDataStd_Comment)::DownCast(theSource);
+  XmlObjMgt::SetExtendedString (theTarget, aName -> Get());
+}

src/XmlMDataStd/XmlMDataStd_DirectoryDriver.cdl

@@ -0,0 +1,32 @@
+-- File:        XmlMDataStd_DirectoryDriver.cdl
+-- Created:     Fri Aug 24 20:16:51 2001
+-- Author:      Alexander GRIGORIEV
+-- Copyright:   Open Cascade 2001
+
+class DirectoryDriver from XmlMDataStd  inherits ADriver from XmlMDF
+
+        ---Purpose: Attribute Driver.
+
+uses
+    SRelocationTable from XmlObjMgt,
+    RRelocationTable from XmlObjMgt,
+    Persistent       from XmlObjMgt,
+    MessageDriver    from CDM,
+    Attribute        from TDF
+
+is
+    Create (theMessageDriver:MessageDriver from CDM)
+        returns mutable DirectoryDriver from XmlMDataStd;
+
+    NewEmpty (me)  returns mutable Attribute from TDF;
+
+    Paste(me; Source     : Persistent from XmlObjMgt;
+              Target     : mutable Attribute from TDF;
+              RelocTable : out RRelocationTable from XmlObjMgt)
+        returns Boolean from Standard;
+
+    Paste(me; Source     : Attribute from TDF;
+              Target     : in out Persistent from XmlObjMgt;
+              RelocTable : out SRelocationTable from XmlObjMgt);
+
+end DirectoryDriver;

src/XmlMDataStd/XmlMDataStd_DirectoryDriver.cxx

@@ -0,0 +1,52 @@
+// File:        XmlMDataStd_DirectoryDriver.cxx
+// Created:     Fri Aug 24 20:46:58 2001
+// Author:      Alexnder GRIGORIEV
+// Copyright:   Open Cascade 2001
+// History:
+
+#include <XmlMDataStd_DirectoryDriver.ixx>
+#include <TDataStd_Directory.hxx>
+
+//=======================================================================
+//function : XmlMDataStd_DirectoryDriver
+//purpose  : Constructor
+//=======================================================================
+
+XmlMDataStd_DirectoryDriver::XmlMDataStd_DirectoryDriver
+                        (const Handle(CDM_MessageDriver)& theMsgDriver)
+      : XmlMDF_ADriver (theMsgDriver, NULL)
+{}
+
+//=======================================================================
+//function : NewEmpty
+//purpose  : 
+//=======================================================================
+
+ Handle(TDF_Attribute) XmlMDataStd_DirectoryDriver::NewEmpty() const
+{
+  return (new TDataStd_Directory());
+}
+
+//=======================================================================
+//function : Paste
+//purpose  : 
+//=======================================================================
+
+ Standard_Boolean XmlMDataStd_DirectoryDriver::Paste
+                                        (const XmlObjMgt_Persistent&,
+                                         const Handle(TDF_Attribute)&,
+                                         XmlObjMgt_RRelocationTable& ) const
+{
+  return Standard_True;
+}
+
+//=======================================================================
+//function : Paste
+//purpose  : 
+//=======================================================================
+
+ void XmlMDataStd_DirectoryDriver::Paste (const Handle(TDF_Attribute)&,
+                                          XmlObjMgt_Persistent&,
+                                          XmlObjMgt_SRelocationTable&  ) const
+{
+}

src/XmlMDataStd/XmlMDataStd_ExpressionDriver.cdl

@@ -0,0 +1,32 @@
+-- File:        XmlMDataStd_ExpressionDriver.cdl
+-- Created:     Wed Sep 12 14:05:15 2001
+-- Author:      Julia DOROVSKIKH
+-- Copyright:   Open Cascade 2001
+
+class ExpressionDriver from XmlMDataStd  inherits ADriver from XmlMDF
+
+        ---Purpose: Attribute Driver.
+
+uses
+    SRelocationTable from XmlObjMgt,
+    RRelocationTable from XmlObjMgt,
+    Persistent       from XmlObjMgt,
+    MessageDriver    from CDM,
+    Attribute        from TDF
+
+is
+    Create (theMessageDriver:MessageDriver from CDM)
+        returns mutable ExpressionDriver from XmlMDataStd;
+
+    NewEmpty (me)  returns mutable Attribute from TDF;
+
+    Paste(me; Source     : Persistent from XmlObjMgt;
+              Target     : mutable Attribute from TDF;
+              RelocTable : out RRelocationTable from XmlObjMgt)
+        returns Boolean from Standard;
+
+    Paste(me; Source     : Attribute from TDF;
+              Target     : in out Persistent from XmlObjMgt;
+              RelocTable : out SRelocationTable from XmlObjMgt);
+
+end ExpressionDriver;

src/XmlMDataStd/XmlMDataStd_ExpressionDriver.cxx

@@ -0,0 +1,140 @@
+// File:        XmlMDataStd_ExpressionDriver.cxx
+// Created:     Wed Sep 12 14:07:32 2001
+// Author:      Julia DOROVSKIKH
+// Copyright:   Open Cascade 2001
+// History:
+
+#include <XmlMDataStd_ExpressionDriver.ixx>
+#include <TDataStd_Expression.hxx>
+#include <TDataStd_Variable.hxx>
+
+#include <TDF_ListIteratorOfAttributeList.hxx>
+
+#include <XmlObjMgt.hxx>
+
+IMPLEMENT_DOMSTRING (VariablesString, "variables")
+
+//=======================================================================
+//function : XmlMDataStd_ExpressionDriver
+//purpose  : Constructor
+//=======================================================================
+XmlMDataStd_ExpressionDriver::XmlMDataStd_ExpressionDriver
+                        (const Handle(CDM_MessageDriver)& theMsgDriver)
+      : XmlMDF_ADriver (theMsgDriver, NULL)
+{}
+
+//=======================================================================
+//function : NewEmpty
+//purpose  : 
+//=======================================================================
+Handle(TDF_Attribute) XmlMDataStd_ExpressionDriver::NewEmpty() const
+{
+  return (new TDataStd_Expression());
+}
+
+//=======================================================================
+//function : Paste
+//purpose  : persistent -> transient (retrieve)
+//=======================================================================
+Standard_Boolean XmlMDataStd_ExpressionDriver::Paste
+                        (const XmlObjMgt_Persistent&  theSource,
+                         const Handle(TDF_Attribute)& theTarget,
+                         XmlObjMgt_RRelocationTable&  theRelocTable) const
+{
+  Handle(TDataStd_Expression) aC = 
+    Handle(TDataStd_Expression)::DownCast(theTarget);
+  const XmlObjMgt_Element& anElem = theSource;
+
+  Standard_Integer aNb;
+  TCollection_ExtendedString aMsgString;
+
+  // expression
+  TCollection_ExtendedString aString;
+  if (!XmlObjMgt::GetExtendedString (theSource, aString))
+  {
+    WriteMessage("error retrieving ExtendedString for type TDataStd_Expression");
+    return Standard_False;
+  }
+  aC->SetExpression(aString);
+
+  // variables
+  XmlObjMgt_DOMString aDOMStr = anElem.getAttribute(::VariablesString());
+  if (aDOMStr != NULL)
+  {
+    Standard_CString aVs = Standard_CString(aDOMStr.GetString());
+
+    // first variable
+    if (!XmlObjMgt::GetInteger(aVs, aNb))
+    {
+      aMsgString = TCollection_ExtendedString
+        ("XmlMDataStd_ExpressionDriver: Cannot retrieve reference on first variable from \"")
+          + aDOMStr + "\"";
+      WriteMessage (aMsgString);
+      return Standard_False;
+    }
+    Standard_Integer i = 1;
+    while (aNb > 0)
+    {
+      Handle(TDF_Attribute) aV;
+      if (theRelocTable.IsBound(aNb))
+        aV = Handle(TDataStd_Variable)::DownCast(theRelocTable.Find(aNb));
+      else
+      {
+        aV = new TDataStd_Variable;
+        theRelocTable.Bind(aNb, aV);
+      }
+      aC->GetVariables().Append(aV);
+
+      // next variable
+      if (!XmlObjMgt::GetInteger(aVs, aNb)) aNb = 0;
+      i++;
+    }
+  }
+
+  return Standard_True;
+}
+
+//=======================================================================
+//function : Paste
+//purpose  : transient -> persistent (store)
+//=======================================================================
+void XmlMDataStd_ExpressionDriver::Paste
+                        (const Handle(TDF_Attribute)& theSource,
+                         XmlObjMgt_Persistent&        theTarget,
+                         XmlObjMgt_SRelocationTable&  theRelocTable) const
+{
+  Handle(TDataStd_Expression) aC =
+    Handle(TDataStd_Expression)::DownCast(theSource);
+  XmlObjMgt_Element& anElem = theTarget;
+
+  Standard_Integer aNb;
+  Handle(TDF_Attribute) TV;   
+
+  // expression
+  XmlObjMgt::SetExtendedString (theTarget, aC->Name());
+
+  // variables
+  Standard_Integer nbvar = aC->GetVariables().Extent();
+  if (nbvar >= 1)
+  {
+    TCollection_AsciiString aGsStr;
+    TDF_ListIteratorOfAttributeList it;
+    Standard_Integer index = 0;
+    for (it.Initialize(aC->GetVariables()); it.More(); it.Next())
+    {
+      index++;
+      TV = it.Value(); 
+      if (!TV.IsNull())
+      {
+        aNb = theRelocTable.FindIndex(TV);
+        if (aNb == 0)
+        {
+          aNb = theRelocTable.Add(TV);
+        }
+        aGsStr += TCollection_AsciiString(aNb) + " ";
+      }
+      else aGsStr += "0 ";
+    }
+    anElem.setAttribute(::VariablesString(), aGsStr.ToCString());
+  }
+}

src/XmlMDataStd/XmlMDataStd_ExtStringArrayDriver.cdl

@@ -0,0 +1,33 @@
+-- File:	XmlMDataStd_ExtStringArrayDriver.cdl
+-- Created:	Mon Sep 27 08:50:13 2004
+-- Author:	Pavel TELKOV
+--		<ptv@valenox>
+---Copyright:	Open CASCADE 2004
+
+class ExtStringArrayDriver from XmlMDataStd  inherits ADriver from XmlMDF
+
+        ---Purpose: Attribute Driver.
+
+uses
+    SRelocationTable from XmlObjMgt,
+    RRelocationTable from XmlObjMgt,
+    Persistent       from XmlObjMgt,
+    MessageDriver    from CDM,
+    Attribute        from TDF
+
+is
+    Create (theMessageDriver:MessageDriver from CDM)
+        returns mutable ExtStringArrayDriver from XmlMDataStd;
+
+    NewEmpty (me)  returns mutable Attribute from TDF;
+
+    Paste(me; Source     : Persistent from XmlObjMgt;
+              Target     : mutable Attribute from TDF;
+              RelocTable : out RRelocationTable from XmlObjMgt)
+        returns Boolean from Standard;
+
+    Paste(me; Source     : Attribute from TDF;
+              Target     : in out Persistent from XmlObjMgt;
+              RelocTable : out SRelocationTable from XmlObjMgt);
+
+end ExtStringArrayDriver;

src/XmlMDataStd/XmlMDataStd_ExtStringArrayDriver.cxx

@@ -0,0 +1,157 @@
+// File:      XmlMDataStd_ExtStringArrayDriver.cxx
+// Created:   27.09.04 08:50:28
+// Author:    Pavel TELKOV
+// Copyright: Open CASCADE  2004
+
+#include <XmlMDataStd_ExtStringArrayDriver.ixx>
+
+#include <TDataStd_ExtStringArray.hxx>
+
+#include <LDOM_MemManager.hxx>
+#include <XmlObjMgt.hxx>
+#include <XmlObjMgt_Document.hxx>
+#include <XmlMDataStd.hxx>
+
+IMPLEMENT_DOMSTRING (FirstIndexString, "first")
+IMPLEMENT_DOMSTRING (LastIndexString, "last")
+IMPLEMENT_DOMSTRING (ExtString,       "string")
+IMPLEMENT_DOMSTRING (IsDeltaOn,       "delta")
+//=======================================================================
+//function : XmlMDataStd_ExtStringArrayDriver
+//purpose  : Constructor
+//=======================================================================
+
+XmlMDataStd_ExtStringArrayDriver::XmlMDataStd_ExtStringArrayDriver
+                        ( const Handle(CDM_MessageDriver)& theMsgDriver )
+: XmlMDF_ADriver( theMsgDriver, NULL )
+{}
+
+//=======================================================================
+//function : NewEmpty
+//purpose  : 
+//=======================================================================
+Handle(TDF_Attribute) XmlMDataStd_ExtStringArrayDriver::NewEmpty() const
+{
+  return ( new TDataStd_ExtStringArray() );
+}
+
+//=======================================================================
+//function : Paste
+//purpose  : persistent -> transient (retrieve)
+//=======================================================================
+Standard_Boolean XmlMDataStd_ExtStringArrayDriver::Paste
+                                        ( const XmlObjMgt_Persistent&  theSource,
+                                          const Handle(TDF_Attribute)& theTarget,
+                                          XmlObjMgt_RRelocationTable& ) const
+{
+  Standard_Integer aFirstInd, aLastInd, ind;
+  TCollection_ExtendedString aValue;
+  const XmlObjMgt_Element& anElement = theSource;
+
+  // Read the FirstIndex; if the attribute is absent initialize to 1
+  XmlObjMgt_DOMString aFirstIndex= anElement.getAttribute(::FirstIndexString());
+  if (aFirstIndex == NULL)
+    aFirstInd = 1;
+  else if (!aFirstIndex.GetInteger(aFirstInd)) {
+    TCollection_ExtendedString aMessageString =
+      TCollection_ExtendedString("Cannot retrieve the first index"
+                                 " for ExtStringArray attribute as \"")
+        + aFirstIndex + "\"";
+    WriteMessage (aMessageString);
+    return Standard_False;
+  }
+
+  // Read LastIndex; the attribute should be present
+  if (!anElement.getAttribute(::LastIndexString()).GetInteger(aLastInd)) {
+    TCollection_ExtendedString aMessageString =
+      TCollection_ExtendedString("Cannot retrieve the last index"
+                                 " for ExtStringArray attribute as \"")
+        + aFirstIndex + "\"";
+    WriteMessage (aMessageString);
+    return Standard_False;
+  }
+
+  Handle(TDataStd_ExtStringArray) aExtStringArray =
+    Handle(TDataStd_ExtStringArray)::DownCast(theTarget);
+  aExtStringArray->Init(aFirstInd, aLastInd);
+  
+  if ( !anElement.hasChildNodes() )
+  {
+    TCollection_ExtendedString aMessageString =
+      TCollection_ExtendedString("Cannot retrieve array of extended string");
+    WriteMessage (aMessageString);
+    return Standard_False;
+  }
+
+  LDOM_Node aCurNode = anElement.getFirstChild();
+  LDOM_Element* aCurElement = (LDOM_Element*)&aCurNode;
+  TCollection_ExtendedString aValueStr;
+  for (ind = aFirstInd; ind <= aLastInd && *aCurElement != anElement.getLastChild(); ind++)
+  {
+    XmlObjMgt::GetExtendedString( *aCurElement, aValueStr );
+    aExtStringArray->SetValue(ind, aValueStr);
+    aCurNode = aCurElement->getNextSibling();
+    aCurElement = (LDOM_Element*)&aCurNode;
+  }
+
+  XmlObjMgt::GetExtendedString( *aCurElement, aValueStr );
+  aExtStringArray->SetValue( aLastInd, aValueStr );
+
+#ifdef DEB
+  //cout << "CurDocVersion = " << XmlMDataStd::DocumentVersion() <<endl;
+#endif
+  Standard_Boolean aDelta(Standard_False);
+  
+  if(XmlMDataStd::DocumentVersion() > 2) {
+    Standard_Integer aDeltaValue;
+    if (!anElement.getAttribute(::IsDeltaOn()).GetInteger(aDeltaValue)) 
+      {
+	TCollection_ExtendedString aMessageString =
+	  TCollection_ExtendedString("Cannot retrieve the isDelta value"
+                                 " for IntegerArray attribute as \"")
+        + aDeltaValue + "\"";
+	WriteMessage (aMessageString);
+	return Standard_False;
+      } 
+    else
+      aDelta = (Standard_Boolean)aDeltaValue;
+  }
+#ifdef DEB
+  else if(XmlMDataStd::DocumentVersion() == -1)
+    cout << "Current DocVersion field is not initialized. "  <<endl;
+#endif
+  aExtStringArray->SetDelta(aDelta);
+
+  return Standard_True;
+}
+
+//=======================================================================
+//function : Paste
+//purpose  : transient -> persistent (store)
+//=======================================================================
+void XmlMDataStd_ExtStringArrayDriver::Paste (const Handle(TDF_Attribute)& theSource,
+                                         XmlObjMgt_Persistent&        theTarget,
+                                         XmlObjMgt_SRelocationTable&  ) const
+{
+  Handle(TDataStd_ExtStringArray) aExtStringArray =
+    Handle(TDataStd_ExtStringArray)::DownCast(theSource);
+
+  Standard_Integer aL = aExtStringArray->Lower(), anU = aExtStringArray->Upper();
+
+  XmlObjMgt_Element& anElement = theTarget;
+
+  if (aL != 1) anElement.setAttribute(::FirstIndexString(), aL);
+  anElement.setAttribute(::LastIndexString(), anU);
+  anElement.setAttribute(::IsDeltaOn(), aExtStringArray->GetDelta()); 
+
+  // store a set of elements with string in each of them
+  XmlObjMgt_Document aDoc = anElement.getOwnerDocument().Doc();
+  
+  for ( Standard_Integer i = aL; i <= anU; i++ )
+  {
+    TCollection_ExtendedString aValueStr = aExtStringArray->Value( i );
+    XmlObjMgt_Element aCurTarget = aDoc.createElement( ::ExtString() );
+    XmlObjMgt::SetExtendedString( aCurTarget, aValueStr );
+    anElement.appendChild( aCurTarget );
+  }
+}

src/XmlMDataStd/XmlMDataStd_ExtStringListDriver.cdl

@@ -0,0 +1,34 @@
+-- File:        XmlMDataStd_ExtStringListDriver.cdl
+-- Created:     May 29 11:40:00 2007
+-- Author:      Vlad Romashko
+--  	    	<vladislav.romashko@opencascade.com>
+-- Copyright:   Open CASCADE
+
+class ExtStringListDriver from XmlMDataStd inherits ADriver from XmlMDF
+
+uses
+
+    SRelocationTable from XmlObjMgt,
+    RRelocationTable from XmlObjMgt,
+    Persistent       from XmlObjMgt,
+    MessageDriver    from CDM,
+    Attribute        from TDF
+
+is
+
+    Create (theMessageDriver:MessageDriver from CDM)
+    returns mutable ExtStringListDriver from XmlMDataStd;
+
+    NewEmpty (me)
+    returns mutable Attribute from TDF;
+
+    Paste(me; Source     : Persistent from XmlObjMgt;
+              Target     : mutable Attribute from TDF;
+              RelocTable : out RRelocationTable from XmlObjMgt)
+    returns Boolean from Standard;
+
+    Paste(me; Source     : Attribute from TDF;
+              Target     : in out Persistent from XmlObjMgt;
+              RelocTable : out SRelocationTable from XmlObjMgt);
+
+end ExtStringListDriver;

src/XmlMDataStd/XmlMDataStd_ExtStringListDriver.cxx

@@ -0,0 +1,124 @@
+// File:        XmlMDataStd_ExtStringListDriver.cxx
+// Created:     May 29 11:40:00 2007
+// Author:      Vlad Romashko
+//  	    	<vladislav.romashko@opencascade.com>
+// Copyright:   Open CASCADE
+
+#include <XmlMDataStd_ExtStringListDriver.ixx>
+#include <TDataStd_ExtStringList.hxx>
+#include <TDataStd_ListIteratorOfListOfExtendedString.hxx>
+#include <XmlObjMgt.hxx>
+#include <XmlObjMgt_Document.hxx>
+#include <LDOM_MemManager.hxx>
+
+IMPLEMENT_DOMSTRING (FirstIndexString, "first")
+IMPLEMENT_DOMSTRING (LastIndexString,  "last")
+IMPLEMENT_DOMSTRING (ExtString,        "string")
+
+//=======================================================================
+//function : XmlMDataStd_ExtStringListDriver
+//purpose  : Constructor
+//=======================================================================
+XmlMDataStd_ExtStringListDriver::XmlMDataStd_ExtStringListDriver(const Handle(CDM_MessageDriver)& theMsgDriver)
+     : XmlMDF_ADriver (theMsgDriver, NULL)
+{
+
+}
+
+//=======================================================================
+//function : NewEmpty
+//purpose  : 
+//=======================================================================
+Handle(TDF_Attribute) XmlMDataStd_ExtStringListDriver::NewEmpty() const
+{
+  return new TDataStd_ExtStringList();
+}
+
+//=======================================================================
+//function : Paste
+//purpose  : persistent -> transient (retrieve)
+//=======================================================================
+Standard_Boolean XmlMDataStd_ExtStringListDriver::Paste(const XmlObjMgt_Persistent&  theSource,
+							const Handle(TDF_Attribute)& theTarget,
+							XmlObjMgt_RRelocationTable&  ) const
+{
+  Standard_Integer aFirstInd, aLastInd;
+  const XmlObjMgt_Element& anElement = theSource;
+
+  // Read the FirstIndex; if the attribute is absent initialize to 1
+  XmlObjMgt_DOMString aFirstIndex= anElement.getAttribute(::FirstIndexString());
+  if (aFirstIndex == NULL)
+    aFirstInd = 1;
+  else if (!aFirstIndex.GetInteger(aFirstInd)) 
+  {
+    TCollection_ExtendedString aMessageString =
+      TCollection_ExtendedString("Cannot retrieve the first index"
+                                 " for ExtStringList attribute as \"")
+        + aFirstIndex + "\"";
+    WriteMessage (aMessageString);
+    return Standard_False;
+  }
+
+  // Read the LastIndex; the attribute should present
+  if (!anElement.getAttribute(::LastIndexString()).GetInteger(aLastInd)) 
+  {
+    TCollection_ExtendedString aMessageString =
+      TCollection_ExtendedString("Cannot retrieve the last index"
+                                 " for ExtStringList attribute as \"")
+        + aFirstIndex + "\"";
+    WriteMessage (aMessageString);
+    return Standard_False;
+  }
+
+  Handle(TDataStd_ExtStringList) anExtStringList = Handle(TDataStd_ExtStringList)::DownCast(theTarget);
+  
+  if (!anElement.hasChildNodes())
+  {
+    TCollection_ExtendedString aMessageString = 
+      TCollection_ExtendedString("Cannot retrieve a list of extended strings");
+    WriteMessage (aMessageString);
+    return Standard_False;
+  }
+
+  LDOM_Node aCurNode = anElement.getFirstChild();
+  LDOM_Element* aCurElement = (LDOM_Element*)&aCurNode;
+  TCollection_ExtendedString aValueStr;
+  while (*aCurElement != anElement.getLastChild())
+  {
+    XmlObjMgt::GetExtendedString( *aCurElement, aValueStr );
+    anExtStringList->Append(aValueStr);
+    aCurNode = aCurElement->getNextSibling();
+    aCurElement = (LDOM_Element*)&aCurNode;
+  }
+
+  XmlObjMgt::GetExtendedString( *aCurElement, aValueStr );
+  anExtStringList->Append(aValueStr);
+
+  return Standard_True;
+}
+
+//=======================================================================
+//function : Paste
+//purpose  : transient -> persistent (store)
+//=======================================================================
+void XmlMDataStd_ExtStringListDriver::Paste(const Handle(TDF_Attribute)& theSource,
+				       XmlObjMgt_Persistent&        theTarget,
+				       XmlObjMgt_SRelocationTable&  ) const
+{
+  Handle(TDataStd_ExtStringList) anExtStringList = Handle(TDataStd_ExtStringList)::DownCast(theSource);
+
+  Standard_Integer anU = anExtStringList->Extent();
+  XmlObjMgt_Element& anElement = theTarget;
+  anElement.setAttribute(::LastIndexString(), anU);
+  
+  XmlObjMgt_Document aDoc = anElement.getOwnerDocument().Doc();
+  
+  TDataStd_ListIteratorOfListOfExtendedString itr(anExtStringList->List());
+  for (; itr.More(); itr.Next())
+  {
+    const TCollection_ExtendedString& aValueStr = itr.Value();
+    XmlObjMgt_Element aCurTarget = aDoc.createElement( ::ExtString() );
+    XmlObjMgt::SetExtendedString( aCurTarget, aValueStr );
+    anElement.appendChild( aCurTarget );
+  }
+}

src/XmlMDataStd/XmlMDataStd_IntPackedMapDriver.cdl

@@ -0,0 +1,38 @@
+-- File:	XmlMDataStd_IntPackedMapDriver.cdl
+-- Created:	Wed Aug 22 09:46:29 2007
+-- Author:	Sergey ZARITCHNY
+--		<sergey.zaritchny@opencascade.com>
+---Copyright:	Open CasCade SA 2007
+
+
+class IntPackedMapDriver from XmlMDataStd inherits ADriver from XmlMDF
+
+	---Purpose: TDataStd_IntPackedMap attribute Driver.
+
+uses
+
+    SRelocationTable from XmlObjMgt,
+    RRelocationTable from XmlObjMgt,
+    Persistent       from XmlObjMgt,
+    MessageDriver    from CDM,
+    Attribute        from TDF
+
+is
+    Create (theMessageDriver:MessageDriver from CDM)
+        returns mutable IntPackedMapDriver from XmlMDataStd;
+
+    NewEmpty (me)  returns mutable Attribute from TDF;
+
+    Paste(me; Source     : Persistent from XmlObjMgt;
+              Target     : mutable Attribute from TDF;
+              RelocTable : out RRelocationTable from XmlObjMgt)
+        returns Boolean from Standard;
+    ---Purpose: persistent -> transient (retrieve)
+
+    Paste(me; Source     : Attribute from TDF;
+              Target     : in out Persistent from XmlObjMgt;
+              RelocTable : out SRelocationTable from XmlObjMgt);
+    ---Purpose: transient -> persistent (store)
+
+
+end IntPackedMapDriver;

src/XmlMDataStd/XmlMDataStd_IntPackedMapDriver.cxx

@@ -0,0 +1,153 @@
+// File:	XmlMDataStd_IntPackedMapDriver.cxx
+// Created:	Wed Aug 22 09:48:41 2007
+// Author:	Sergey ZARITCHNY
+//		<sergey.zaritchny@opencascade.com>
+//Copyright:    Open CasCade SA 2007
+
+#include <XmlMDataStd_IntPackedMapDriver.ixx>
+#include <XmlObjMgt.hxx>
+#include <XmlObjMgt_RRelocationTable.hxx>
+#include <XmlObjMgt_SRelocationTable.hxx>
+#include <CDM_MessageDriver.hxx>
+#include <TColStd_PackedMapOfInteger.hxx>
+#include <TColStd_HPackedMapOfInteger.hxx>
+#include <TColStd_MapIteratorOfPackedMapOfInteger.hxx>
+#include <XmlMDF_ADriver.hxx>
+#include <TDF_Attribute.hxx>
+#include <TDataStd_IntPackedMap.hxx>
+#include <XmlMDataStd.hxx>
+
+IMPLEMENT_DOMSTRING (IntPackedMapSize, "mapsize")
+IMPLEMENT_DOMSTRING (IsDeltaOn,        "delta")
+//=======================================================================
+//function : XmlMDataStd_IntPackedMapDriver
+//purpose  : Constructor
+//=======================================================================
+
+XmlMDataStd_IntPackedMapDriver::XmlMDataStd_IntPackedMapDriver
+                        (const Handle(CDM_MessageDriver)& theMsgDriver)
+      : XmlMDF_ADriver (theMsgDriver, STANDARD_TYPE(TDataStd_IntPackedMap)->Name())
+{}
+
+//=======================================================================
+//function : NewEmpty()
+//purpose  : 
+//=======================================================================
+Handle(TDF_Attribute) XmlMDataStd_IntPackedMapDriver::NewEmpty () const
+{
+  return (new TDataStd_IntPackedMap());
+}
+
+//=======================================================================
+//function : Paste()
+//purpose  : persistent -> transient (retrieve)
+//=======================================================================
+Standard_Boolean XmlMDataStd_IntPackedMapDriver::Paste
+                               (const XmlObjMgt_Persistent&  theSource,
+                                const Handle(TDF_Attribute)& theTarget,
+                                XmlObjMgt_RRelocationTable&  ) const
+{
+  Handle(TDataStd_IntPackedMap) aPackedMap =
+    Handle(TDataStd_IntPackedMap)::DownCast(theTarget);
+  if(!aPackedMap.IsNull()) {
+    Standard_Integer aSize;
+    const XmlObjMgt_Element& anElement = theSource;
+    XmlObjMgt_DOMString aSizeDStr = anElement.getAttribute(::IntPackedMapSize());
+    if(aSizeDStr == NULL)
+      aSize = 0;
+    else if (!aSizeDStr.GetInteger(aSize)) {
+      TCollection_ExtendedString aMessageString =
+      TCollection_ExtendedString("Cannot retrieve the Map size"
+                                 " for IntPackedMap attribute as \"")
+        + aSize + "\"";
+      WriteMessage (aMessageString);
+      return Standard_False;            
+    }
+    Handle(TColStd_HPackedMapOfInteger) aHMap = new TColStd_HPackedMapOfInteger ();
+    Standard_Boolean Ok = Standard_True;
+    if(aSize) {    
+      Standard_CString aValueString =
+	Standard_CString(XmlObjMgt::GetStringValue(anElement).GetString());
+//      Handle(TColStd_HPackedMapOfInteger) aHMap = new TColStd_HPackedMapOfInteger ();
+      for (Standard_Integer i = 1; i <= aSize; i++) {
+	Standard_Integer aValue;
+	if (!XmlObjMgt::GetInteger(aValueString, aValue)) {
+	  Ok = Standard_False; break;
+	}
+	if(!aHMap->ChangeMap().Add( aValue )) {
+	  Ok = Standard_False; break;
+	}
+      }
+      if(!Ok) {
+	TCollection_ExtendedString aMessageString =
+	  TCollection_ExtendedString("Cannot retrieve integer member"
+				     " for IntPackedMap attribute as \"")
+	    + aValueString + "\"";
+	WriteMessage (aMessageString);
+	return Standard_False;
+      }
+      if(aPackedMap->ChangeMap(aHMap))
+	Ok = Standard_True;
+    }
+    //
+#ifdef DEB
+  //cout << "CurDocVersion = " << XmlMDataStd::DocumentVersion() <<endl;
+#endif
+    if(Ok) {
+      Standard_Boolean aDelta(Standard_False);
+  
+      if(XmlMDataStd::DocumentVersion() > 2) {
+	Standard_Integer aDeltaValue;
+	if (!anElement.getAttribute(::IsDeltaOn()).GetInteger(aDeltaValue)) 
+	  {
+	    TCollection_ExtendedString aMessageString =
+	      TCollection_ExtendedString("Cannot retrieve the isDelta value"
+					 " for IntPackedMap attribute as \"")
+		+ aDeltaValue + "\"";
+	    WriteMessage (aMessageString);
+	    return Standard_False;
+	  } 
+	else
+	  aDelta = (Standard_Boolean)aDeltaValue;
+      }
+#ifdef DEB
+      else if(XmlMDataStd::DocumentVersion() == -1)
+	cout << "Current DocVersion field is not initialized. "  <<endl;
+#endif
+      aPackedMap->SetDelta(aDelta);
+      return Standard_True;
+    }  
+  }
+  WriteMessage("error retrieving Map for type TDataStd_IntPackedMap");
+  return Standard_False;
+}
+
+//=======================================================================
+//function : Paste()
+//purpose  : transient -> persistent (store)
+//=======================================================================
+void XmlMDataStd_IntPackedMapDriver::Paste (const Handle(TDF_Attribute)& theSource,
+                                    XmlObjMgt_Persistent&        theTarget,
+                                    XmlObjMgt_SRelocationTable&  ) const
+{
+  Handle(TDataStd_IntPackedMap) aS = Handle(TDataStd_IntPackedMap)::DownCast(theSource);
+  if (aS.IsNull()) {
+    WriteMessage ("IntPackedMapDriver:: The source attribute is Null.");
+    return;
+  }
+
+  Standard_Integer aSize = (aS->IsEmpty()) ? 0 : aS->Extent();
+  theTarget.Element().setAttribute(::IntPackedMapSize(), aSize);
+  theTarget.Element().setAttribute(::IsDeltaOn(),aS->GetDelta());
+
+  TCollection_AsciiString aValueString;
+  if(aSize) {
+    TColStd_MapIteratorOfPackedMapOfInteger anIt(aS->GetMap());
+    for(;anIt.More();anIt.Next()) {
+      aValueString += TCollection_AsciiString(anIt.Key());
+      aValueString += ' ';
+    }
+    // No occurrence of '&', '<' and other irregular XML characters
+    XmlObjMgt::SetStringValue (theTarget, aValueString.ToCString(), Standard_True);
+  }
+}

src/XmlMDataStd/XmlMDataStd_IntegerArrayDriver.cdl

@@ -0,0 +1,32 @@
+-- File:        XmlMDataStd_IntegerArrayDriver.cdl
+-- Created:     Fri Aug 24 20:16:51 2001
+-- Author:      Alexander GRIGORIEV
+-- Copyright:   Open Cascade 2001
+
+class IntegerArrayDriver from XmlMDataStd  inherits ADriver from XmlMDF
+
+        ---Purpose: Attribute Driver.
+
+uses
+    SRelocationTable from XmlObjMgt,
+    RRelocationTable from XmlObjMgt,
+    Persistent       from XmlObjMgt,
+    MessageDriver    from CDM,
+    Attribute        from TDF
+
+is
+    Create (theMessageDriver:MessageDriver from CDM)
+        returns mutable IntegerArrayDriver from XmlMDataStd;
+
+    NewEmpty (me)  returns mutable Attribute from TDF;
+
+    Paste(me; Source     : Persistent from XmlObjMgt;
+              Target     : mutable Attribute from TDF;
+              RelocTable : out RRelocationTable from XmlObjMgt)
+        returns Boolean from Standard;
+
+    Paste(me; Source     : Attribute from TDF;
+              Target     : in out Persistent from XmlObjMgt;
+              RelocTable : out SRelocationTable from XmlObjMgt);
+
+end IntegerArrayDriver;

src/XmlMDataStd/XmlMDataStd_IntegerArrayDriver.cxx

@@ -0,0 +1,159 @@
+// File:        XmlMDataStd_IntegerArrayDriver.cxx
+// Created:     Fri Aug 24 20:46:58 2001
+// Author:      Alexnder GRIGORIEV
+// Copyright:   Open Cascade 2001-2002
+// History:   AGV 150202: Changed prototype XmlObjMgt::SetStringValue()
+
+#include <XmlMDataStd_IntegerArrayDriver.ixx>
+#include <TDataStd_IntegerArray.hxx>
+#include <XmlObjMgt.hxx>
+#include <XmlMDataStd.hxx>
+
+IMPLEMENT_DOMSTRING (FirstIndexString, "first")
+IMPLEMENT_DOMSTRING (LastIndexString,  "last")
+IMPLEMENT_DOMSTRING (IsDeltaOn,        "delta")
+//=======================================================================
+//function : XmlMDataStd_IntegerArrayDriver
+//purpose  : Constructor
+//=======================================================================
+
+XmlMDataStd_IntegerArrayDriver::XmlMDataStd_IntegerArrayDriver
+                        (const Handle(CDM_MessageDriver)& theMsgDriver)
+      : XmlMDF_ADriver (theMsgDriver, NULL)
+{}
+
+//=======================================================================
+//function : NewEmpty
+//purpose  : 
+//=======================================================================
+Handle(TDF_Attribute) XmlMDataStd_IntegerArrayDriver::NewEmpty() const
+{
+  return (new TDataStd_IntegerArray());
+}
+
+//=======================================================================
+//function : Paste
+//purpose  : persistent -> transient (retrieve)
+//=======================================================================
+Standard_Boolean XmlMDataStd_IntegerArrayDriver::Paste
+                                (const XmlObjMgt_Persistent&  theSource,
+                                 const Handle(TDF_Attribute)& theTarget,
+                                 XmlObjMgt_RRelocationTable&  ) const
+{
+  Standard_Integer aFirstInd, aLastInd, aValue, ind;
+  const XmlObjMgt_Element& anElement = theSource;
+
+  // Read the FirstIndex; if the attribute is absent initialize to 1
+  XmlObjMgt_DOMString aFirstIndex= anElement.getAttribute(::FirstIndexString());
+  if (aFirstIndex == NULL)
+    aFirstInd = 1;
+  else if (!aFirstIndex.GetInteger(aFirstInd)) {
+    TCollection_ExtendedString aMessageString =
+      TCollection_ExtendedString("Cannot retrieve the first index"
+                                 " for IntegerArray attribute as \"")
+        + aFirstIndex + "\"";
+    WriteMessage (aMessageString);
+    return Standard_False;
+  }
+
+  // Read the LastIndex; the attribute should be present
+  if (!anElement.getAttribute(::LastIndexString()).GetInteger(aLastInd)) {
+    TCollection_ExtendedString aMessageString =
+      TCollection_ExtendedString("Cannot retrieve the last index"
+                                 " for IntegerArray attribute as \"")
+        + aFirstIndex + "\"";
+    WriteMessage (aMessageString);
+    return Standard_False;
+  }
+
+  Handle(TDataStd_IntegerArray) anIntArray =
+    Handle(TDataStd_IntegerArray)::DownCast(theTarget);
+  anIntArray->Init(aFirstInd, aLastInd);
+
+  if(aFirstInd == aLastInd) {
+    Standard_Integer anInteger;
+    if(!XmlObjMgt::GetStringValue(anElement).GetInteger( anInteger)) {
+      TCollection_ExtendedString aMessageString =
+        TCollection_ExtendedString("Cannot retrieve integer member"
+                                   " for IntegerArray attribute as \"");
+      WriteMessage (aMessageString);
+      return Standard_False;
+    }
+    anIntArray->SetValue(aFirstInd, anInteger);
+    
+  }
+  else {
+    // Warning: check implementation of XmlObjMgt_DOMString !! For LDOM this is OK
+    Standard_CString aValueStr =
+      Standard_CString(XmlObjMgt::GetStringValue(anElement).GetString());
+    
+    for (ind = aFirstInd; ind <= aLastInd; ind++)
+    {
+      if (!XmlObjMgt::GetInteger(aValueStr, aValue)) {
+        TCollection_ExtendedString aMessageString =
+          TCollection_ExtendedString("Cannot retrieve integer member"
+                                     " for IntegerArray attribute as \"")
+            + aValueStr + "\"";
+        WriteMessage (aMessageString);
+        return Standard_False;
+      }
+      anIntArray->SetValue(ind, aValue);
+    }
+  }
+#ifdef DEB
+  //cout << "CurDocVersion = " << XmlMDataStd::DocumentVersion() <<endl;
+#endif
+  Standard_Boolean aDelta(Standard_False);
+  
+  if(XmlMDataStd::DocumentVersion() > 2) {
+    Standard_Integer aDeltaValue;
+    if (!anElement.getAttribute(::IsDeltaOn()).GetInteger(aDeltaValue)) 
+      {
+	TCollection_ExtendedString aMessageString =
+	  TCollection_ExtendedString("Cannot retrieve the isDelta value"
+                                 " for IntegerArray attribute as \"")
+        + aDeltaValue + "\"";
+	WriteMessage (aMessageString);
+	return Standard_False;
+      } 
+    else
+      aDelta = (Standard_Boolean)aDeltaValue;
+  }
+#ifdef DEB
+  else if(XmlMDataStd::DocumentVersion() == -1)
+    cout << "Current DocVersion field is not initialized. "  <<endl;
+#endif
+  anIntArray->SetDelta(aDelta);
+  
+  return Standard_True;
+}
+
+//=======================================================================
+//function : Paste
+//purpose  : transient -> persistent (store)
+//=======================================================================
+void XmlMDataStd_IntegerArrayDriver::Paste
+                                (const Handle(TDF_Attribute)& theSource,
+                                 XmlObjMgt_Persistent&        theTarget,
+                                 XmlObjMgt_SRelocationTable&  ) const
+{
+  Handle(TDataStd_IntegerArray) anIntArray =
+    Handle(TDataStd_IntegerArray)::DownCast(theSource);
+
+  Standard_Integer aL = anIntArray->Lower(), anU = anIntArray->Upper();
+  TCollection_AsciiString aValueStr;
+
+  if (aL != 1) theTarget.Element().setAttribute (::FirstIndexString(), aL);
+  theTarget.Element().setAttribute(::LastIndexString(), anU);
+  theTarget.Element().setAttribute(::IsDeltaOn(), anIntArray->GetDelta());
+
+  Standard_Integer i = aL;
+  while (1) {
+    aValueStr += TCollection_AsciiString(anIntArray->Value(i));
+    if (i >= anU) break;
+    aValueStr += ' ';
+    ++i;
+  }
+  // No occurrence of '&', '<' and other irregular XML characters
+  XmlObjMgt::SetStringValue (theTarget, aValueStr.ToCString(), Standard_True);
+}

src/XmlMDataStd/XmlMDataStd_IntegerDriver.cdl

@@ -0,0 +1,32 @@
+-- File:        XmlMDataStd_IntegerDriver.cdl
+-- Created:     Fri Aug 24 20:16:51 2001
+-- Author:      Alexander GRIGORIEV
+-- Copyright:   Open Cascade 2001
+
+class IntegerDriver from XmlMDataStd  inherits ADriver from XmlMDF
+
+        ---Purpose: Attribute Driver.
+
+uses
+    SRelocationTable from XmlObjMgt,
+    RRelocationTable from XmlObjMgt,
+    Persistent       from XmlObjMgt,
+    MessageDriver    from CDM,
+    Attribute        from TDF
+
+is
+    Create (theMessageDriver:MessageDriver from CDM)
+        returns mutable IntegerDriver from XmlMDataStd;
+
+    NewEmpty (me)  returns mutable Attribute from TDF;
+
+    Paste(me; Source     : Persistent from XmlObjMgt;
+              Target     : mutable Attribute from TDF;
+              RelocTable : out RRelocationTable from XmlObjMgt)
+        returns Boolean from Standard;
+
+    Paste(me; Source     : Attribute from TDF;
+              Target     : in out Persistent from XmlObjMgt;
+              RelocTable : out SRelocationTable from XmlObjMgt);
+
+end IntegerDriver;

src/XmlMDataStd/XmlMDataStd_IntegerDriver.cxx

@@ -0,0 +1,66 @@
+// File:        XmlMDataStd_IntegerDriver.cxx
+// Created:     Fri Aug 24 20:46:58 2001
+// Author:      Alexnder GRIGORIEV
+// Copyright:   Open Cascade 2001
+// History:
+
+#include <XmlMDataStd_IntegerDriver.ixx>
+#include <XmlObjMgt.hxx>
+#include <TDataStd_Integer.hxx>
+
+//=======================================================================
+//function : XmlMDataStd_IntegerDriver
+//purpose  : Constructor
+//=======================================================================
+
+XmlMDataStd_IntegerDriver::XmlMDataStd_IntegerDriver
+                        (const Handle(CDM_MessageDriver)& theMsgDriver)
+      : XmlMDF_ADriver (theMsgDriver, NULL)
+{}
+
+//=======================================================================
+//function : NewEmpty
+//purpose  : 
+//=======================================================================
+Handle(TDF_Attribute) XmlMDataStd_IntegerDriver::NewEmpty() const
+{
+  return (new TDataStd_Integer());
+}
+
+//=======================================================================
+//function : Paste
+//purpose  : persistent -> transient (retrieve)
+//=======================================================================
+Standard_Boolean XmlMDataStd_IntegerDriver::Paste
+                                (const XmlObjMgt_Persistent&  theSource,
+                                 const Handle(TDF_Attribute)& theTarget,
+                                 XmlObjMgt_RRelocationTable&  ) const
+{
+  Standard_Integer aValue;
+  XmlObjMgt_DOMString anIntStr= XmlObjMgt::GetStringValue(theSource);
+
+  if (anIntStr.GetInteger(aValue) == Standard_False) {
+    TCollection_ExtendedString aMessageString =
+      TCollection_ExtendedString("Cannot retrieve Integer attribute from \"")
+        + anIntStr + "\"";
+    WriteMessage (aMessageString);
+    return Standard_False;
+  }
+
+  Handle(TDataStd_Integer) anInt= Handle(TDataStd_Integer)::DownCast(theTarget);
+  anInt->Set(aValue);
+
+  return Standard_True;
+}
+
+//=======================================================================
+//function : Paste
+//purpose  : transient -> persistent (store)
+//=======================================================================
+void XmlMDataStd_IntegerDriver::Paste (const Handle(TDF_Attribute)& theSource,
+                                       XmlObjMgt_Persistent&        theTarget,
+                                       XmlObjMgt_SRelocationTable&  ) const
+{
+  Handle(TDataStd_Integer) anInt= Handle(TDataStd_Integer)::DownCast(theSource);
+  XmlObjMgt::SetStringValue (theTarget, anInt->Get());
+}

src/XmlMDataStd/XmlMDataStd_IntegerListDriver.cdl

@@ -0,0 +1,34 @@
+-- File:        XmlMDataStd_IntegerListDriver.cdl
+-- Created:     May 29 11:40:00 2007
+-- Author:      Vlad Romashko
+--  	    	<vladislav.romashko@opencascade.com>
+-- Copyright:   Open CASCADE
+
+class IntegerListDriver from XmlMDataStd inherits ADriver from XmlMDF
+
+uses
+
+    SRelocationTable from XmlObjMgt,
+    RRelocationTable from XmlObjMgt,
+    Persistent       from XmlObjMgt,
+    MessageDriver    from CDM,
+    Attribute        from TDF
+
+is
+
+    Create (theMessageDriver:MessageDriver from CDM)
+    returns mutable IntegerListDriver from XmlMDataStd;
+
+    NewEmpty (me)
+    returns mutable Attribute from TDF;
+
+    Paste(me; Source     : Persistent from XmlObjMgt;
+              Target     : mutable Attribute from TDF;
+              RelocTable : out RRelocationTable from XmlObjMgt)
+    returns Boolean from Standard;
+
+    Paste(me; Source     : Attribute from TDF;
+              Target     : in out Persistent from XmlObjMgt;
+              RelocTable : out SRelocationTable from XmlObjMgt);
+
+end IntegerListDriver;

src/XmlMDataStd/XmlMDataStd_IntegerListDriver.cxx

@@ -0,0 +1,130 @@
+// File:        XmlMDataStd_IntegerListDriver.cxx
+// Created:     May 29 11:40:00 2007
+// Author:      Vlad Romashko
+//  	    	<vladislav.romashko@opencascade.com>
+// Copyright:   Open CASCADE
+
+#include <XmlMDataStd_IntegerListDriver.ixx>
+#include <TDataStd_IntegerList.hxx>
+#include <TColStd_ListIteratorOfListOfInteger.hxx>
+#include <XmlObjMgt.hxx>
+
+IMPLEMENT_DOMSTRING (FirstIndexString, "first")
+IMPLEMENT_DOMSTRING (LastIndexString,  "last")
+
+//=======================================================================
+//function : XmlMDataStd_IntegerListDriver
+//purpose  : Constructor
+//=======================================================================
+XmlMDataStd_IntegerListDriver::XmlMDataStd_IntegerListDriver(const Handle(CDM_MessageDriver)& theMsgDriver)
+     : XmlMDF_ADriver (theMsgDriver, NULL)
+{
+
+}
+
+//=======================================================================
+//function : NewEmpty
+//purpose  : 
+//=======================================================================
+Handle(TDF_Attribute) XmlMDataStd_IntegerListDriver::NewEmpty() const
+{
+  return new TDataStd_IntegerList();
+}
+
+//=======================================================================
+//function : Paste
+//purpose  : persistent -> transient (retrieve)
+//=======================================================================
+Standard_Boolean XmlMDataStd_IntegerListDriver::Paste(const XmlObjMgt_Persistent&  theSource,
+						      const Handle(TDF_Attribute)& theTarget,
+						      XmlObjMgt_RRelocationTable&  ) const
+{
+  Standard_Integer aFirstInd, aLastInd, aValue, ind;
+  const XmlObjMgt_Element& anElement = theSource;
+
+  // Read the FirstIndex; if the attribute is absent initialize to 1
+  XmlObjMgt_DOMString aFirstIndex= anElement.getAttribute(::FirstIndexString());
+  if (aFirstIndex == NULL)
+    aFirstInd = 1;
+  else if (!aFirstIndex.GetInteger(aFirstInd)) 
+  {
+    TCollection_ExtendedString aMessageString =
+      TCollection_ExtendedString("Cannot retrieve the first index"
+                                 " for IntegerList attribute as \"")
+        + aFirstIndex + "\"";
+    WriteMessage (aMessageString);
+    return Standard_False;
+  }
+
+  // Read the LastIndex; the attribute should be present
+  if (!anElement.getAttribute(::LastIndexString()).GetInteger(aLastInd)) 
+  {
+    TCollection_ExtendedString aMessageString =
+      TCollection_ExtendedString("Cannot retrieve the last index"
+                                 " for IntegerList attribute as \"")
+        + aFirstIndex + "\"";
+    WriteMessage (aMessageString);
+    return Standard_False;
+  }
+
+  Handle(TDataStd_IntegerList) anIntList = Handle(TDataStd_IntegerList)::DownCast(theTarget);
+  if (aFirstInd == aLastInd) 
+  {
+    Standard_Integer anInteger;
+    if (!XmlObjMgt::GetStringValue(anElement).GetInteger(anInteger)) 
+    {
+      TCollection_ExtendedString aMessageString =
+        TCollection_ExtendedString("Cannot retrieve integer member"
+                                   " for IntegerList attribute as \"");
+      WriteMessage (aMessageString);
+      return Standard_False;
+    }
+    anIntList->Append(anInteger);
+  }
+  else 
+  {
+    Standard_CString aValueStr = Standard_CString(XmlObjMgt::GetStringValue(anElement).GetString());
+    for (ind = aFirstInd; ind <= aLastInd; ind++)
+    {
+      if (!XmlObjMgt::GetInteger(aValueStr, aValue)) 
+      {
+        TCollection_ExtendedString aMessageString =
+          TCollection_ExtendedString("Cannot retrieve integer member"
+                                     " for IntegerList attribute as \"")
+            + aValueStr + "\"";
+        WriteMessage (aMessageString);
+        return Standard_False;
+      }
+      anIntList->Append(aValue);
+    }
+  }
+  
+  return Standard_True;
+}
+
+//=======================================================================
+//function : Paste
+//purpose  : transient -> persistent (store)
+//=======================================================================
+void XmlMDataStd_IntegerListDriver::Paste(const Handle(TDF_Attribute)& theSource,
+					  XmlObjMgt_Persistent&        theTarget,
+					  XmlObjMgt_SRelocationTable&  ) const
+{
+  Handle(TDataStd_IntegerList) anIntList = Handle(TDataStd_IntegerList)::DownCast(theSource);
+
+  Standard_Integer anU = anIntList->Extent();
+  TCollection_AsciiString aValueStr;
+
+  theTarget.Element().setAttribute(::LastIndexString(), anU);
+  if (anU >= 1)
+  {
+    TColStd_ListIteratorOfListOfInteger itr(anIntList->List());
+    for (; itr.More(); itr.Next())
+    {
+      aValueStr += TCollection_AsciiString(itr.Value());
+      aValueStr += ' ';
+    }
+  }
+  // No occurrence of '&', '<' and other irregular XML characters
+  XmlObjMgt::SetStringValue (theTarget, aValueStr.ToCString(), Standard_True);
+}

src/XmlMDataStd/XmlMDataStd_NameDriver.cdl

@@ -0,0 +1,32 @@
+-- File:      XmlMDataStd_NameDriver.cdl
+-- Created:   Mon Jul  9 12:29:49 MSK DST 2001
+-- Author:    Julia DOROVSKIKH
+-- Copyright: Matra Datavision 2001
+
+class NameDriver from XmlMDataStd  inherits ADriver from XmlMDF
+
+        ---Purpose: Attribute Driver.
+
+uses
+    SRelocationTable from XmlObjMgt,
+    RRelocationTable from XmlObjMgt,
+    Persistent       from XmlObjMgt,
+    MessageDriver    from CDM,
+    Attribute        from TDF
+
+is
+    Create (theMessageDriver:MessageDriver from CDM)
+        returns mutable NameDriver from XmlMDataStd;
+
+    NewEmpty (me)  returns mutable Attribute from TDF;
+
+    Paste(me; Source     : Persistent from XmlObjMgt;
+              Target     : mutable Attribute from TDF;
+              RelocTable : out RRelocationTable from XmlObjMgt)
+        returns Boolean from Standard;
+
+    Paste(me; Source     : Attribute from TDF;
+              Target     : in out Persistent from XmlObjMgt;
+              RelocTable : out SRelocationTable from XmlObjMgt);
+
+end NameDriver;

src/XmlMDataStd/XmlMDataStd_NameDriver.cxx

@@ -0,0 +1,61 @@
+// File:      XmlMDataStd_NameDriver.cxx
+// Created:   01.08.01 09:19:45
+// Author:    Alexander GRIGORIEV
+// Copyright: Open Cascade 2001
+// History:
+
+#include <XmlMDataStd_NameDriver.ixx>
+#include <XmlObjMgt.hxx>
+#include <XmlObjMgt_RRelocationTable.hxx>
+#include <XmlObjMgt_SRelocationTable.hxx>
+#include <TDataStd_Name.hxx>
+
+//=======================================================================
+//function : XmlMDataStd_NameDriver
+//purpose  : Constructor
+//=======================================================================
+
+XmlMDataStd_NameDriver::XmlMDataStd_NameDriver
+                        (const Handle(CDM_MessageDriver)& theMsgDriver)
+      : XmlMDF_ADriver (theMsgDriver, NULL)
+{}
+
+//=======================================================================
+//function : NewEmpty()
+//purpose  : 
+//=======================================================================
+Handle(TDF_Attribute) XmlMDataStd_NameDriver::NewEmpty () const
+{
+  return (new TDataStd_Name());
+}
+
+//=======================================================================
+//function : Paste()
+//purpose  : 
+//=======================================================================
+Standard_Boolean XmlMDataStd_NameDriver::Paste
+                               (const XmlObjMgt_Persistent&  theSource,
+                                const Handle(TDF_Attribute)& theTarget,
+                                XmlObjMgt_RRelocationTable&  ) const
+{
+  TCollection_ExtendedString aString;
+  if (XmlObjMgt::GetExtendedString (theSource, aString))
+  {
+    Handle(TDataStd_Name)::DownCast(theTarget) -> Set (aString);
+    return Standard_True;
+  }
+  WriteMessage("error retrieving ExtendedString for type TDataStd_Name");
+  return Standard_False;
+}
+
+//=======================================================================
+//function : Paste()
+//purpose  : 
+//=======================================================================
+void XmlMDataStd_NameDriver::Paste (const Handle(TDF_Attribute)& theSource,
+                                    XmlObjMgt_Persistent&        theTarget,
+                                    XmlObjMgt_SRelocationTable&  ) const
+{
+  Handle(TDataStd_Name) aName = Handle(TDataStd_Name)::DownCast(theSource);
+  XmlObjMgt::SetExtendedString (theTarget, aName -> Get());
+}

src/XmlMDataStd/XmlMDataStd_NamedDataDriver.cdl

@@ -0,0 +1,36 @@
+-- File:	XmlMDataStd_NamedDataDriver.cdl
+-- Created:	Tue Jul  3 10:05:33 2007
+-- Author:	Sergey ZARITCHNY
+--		<sergey.zaritchny@opencascade.com>
+---Copyright:	Open CasCade SA 2007
+
+
+class NamedDataDriver from XmlMDataStd inherits ADriver from XmlMDF
+
+	---Purpose: 
+
+uses
+    SRelocationTable from XmlObjMgt,
+    RRelocationTable from XmlObjMgt,
+    Persistent       from XmlObjMgt,
+    MessageDriver    from CDM,
+    Attribute        from TDF
+
+is
+
+    Create (theMessageDriver:MessageDriver from CDM)
+    returns mutable  NamedDataDriver from XmlMDataStd;
+
+    NewEmpty (me)
+    returns mutable Attribute from TDF;
+
+    Paste(me; Source     : Persistent from XmlObjMgt;
+              Target     : mutable Attribute from TDF;
+              RelocTable : out RRelocationTable from XmlObjMgt)
+    returns Boolean from Standard;
+
+    Paste(me; Source     : Attribute from TDF;
+              Target     : in out Persistent from XmlObjMgt;
+              RelocTable : out SRelocationTable from XmlObjMgt);
+
+end NamedDataDriver;

src/XmlMDataStd/XmlMDataStd_NamedDataDriver.cxx

@@ -0,0 +1,768 @@
+// File:	XmlMDataStd_NamedDataDriver.cxx
+// Created:	Tue Jul  3 11:17:43 2007
+// Author:	Sergey ZARITCHNY
+//		<sergey.zaritchny@opencascade.com>
+// Copyright:   Open CasCade SA 2007
+
+#include <XmlMDataStd_NamedDataDriver.ixx>
+#include <XmlObjMgt.hxx>
+#include <XmlObjMgt_Document.hxx>
+#include <LDOM_MemManager.hxx>
+#include <TCollection_ExtendedString.hxx>
+#include <CDM_MessageDriver.hxx>
+#include <TDataStd_NamedData.hxx>
+#include <TColStd_HArray1OfReal.hxx>
+#include <TColStd_HArray1OfInteger.hxx>
+#include <TColStd_HArray1OfReal.hxx>
+#include <TColStd_DataMapOfStringInteger.hxx>
+#include <TDataStd_DataMapOfStringReal.hxx>
+#include <TDataStd_DataMapOfStringString.hxx>
+#include <TDataStd_DataMapOfStringByte.hxx>
+#include <TDataStd_DataMapOfStringHArray1OfInteger.hxx>
+#include <TDataStd_DataMapOfStringHArray1OfReal.hxx>
+#include <TColStd_DataMapIteratorOfDataMapOfStringInteger.hxx>
+#include <TDataStd_DataMapIteratorOfDataMapOfStringReal.hxx>
+#include <TDataStd_DataMapIteratorOfDataMapOfStringString.hxx>
+#include <TDataStd_DataMapIteratorOfDataMapOfStringByte.hxx>
+#include <TDataStd_DataMapIteratorOfDataMapOfStringHArray1OfInteger.hxx>
+#include <TDataStd_DataMapIteratorOfDataMapOfStringHArray1OfReal.hxx>
+IMPLEMENT_DOMSTRING (FirstIntegerIndex, "firstI")
+IMPLEMENT_DOMSTRING (LastIntegerIndex,  "lastI")
+IMPLEMENT_DOMSTRING (FirstRealIndex,    "firstR")
+IMPLEMENT_DOMSTRING (LastRealIndex,     "lastR")
+IMPLEMENT_DOMSTRING (FirstStringIndex,  "firstS")
+IMPLEMENT_DOMSTRING (LastStringIndex,   "lastS")
+IMPLEMENT_DOMSTRING (FirstByteIndex,    "firstB")
+IMPLEMENT_DOMSTRING (LastByteIndex,     "lastB")
+IMPLEMENT_DOMSTRING (FirstIntArrIndex,  "firstIA")
+IMPLEMENT_DOMSTRING (LastIntArrIndex,   "lastIA")
+IMPLEMENT_DOMSTRING (FirstRealArrIndex, "firstRA")
+IMPLEMENT_DOMSTRING (LastRealArrIndex,   "lastRA")
+
+IMPLEMENT_DOMSTRING (ExtString, "string")
+IMPLEMENT_DOMSTRING (Value,     "value")
+
+#define OCC6010
+
+#ifdef WNT
+#define EXCEPTION ...
+#else
+#define EXCEPTION Standard_Failure
+#endif
+//=======================================================================
+//function : XmlMDataStd_NamedDataDriver
+//purpose  : Constructor
+//=======================================================================
+XmlMDataStd_NamedDataDriver::XmlMDataStd_NamedDataDriver(const Handle(CDM_MessageDriver)& theMsgDriver)
+     : XmlMDF_ADriver (theMsgDriver, NULL)
+{
+
+}
+
+//=======================================================================
+//function : NewEmpty
+//purpose  : 
+//=======================================================================
+Handle(TDF_Attribute) XmlMDataStd_NamedDataDriver::NewEmpty() const
+{
+  return new TDataStd_NamedData();
+}
+
+//=======================================================================
+static TCollection_ExtendedString SplitItemFromEnd(TCollection_ExtendedString& Key) 
+{
+  TCollection_ExtendedString aValue;
+  const Standard_Integer aPos = Key. SearchFromEnd (" ");
+  if(aPos == -1) return aValue;
+  aValue = Key.Split(aPos-1);
+  aValue.Remove(1,1);
+  return aValue;
+}
+//=======================================================================
+static TCollection_ExtendedString SplitItemFromStart(TCollection_ExtendedString& Key) 
+{
+  TCollection_ExtendedString aValue;
+  const Standard_Integer aPos = Key. Search (" ");
+  if(aPos == -1) return aValue;
+  aValue = Key.Split(aPos);
+  Key.Remove(Key.Length(),1);
+  return aValue;
+}
+//=======================================================================
+Handle(TColStd_HArray1OfInteger) BuildIntArray(const TCollection_AsciiString& ValString, 
+					       const Standard_Integer theLen) 
+{
+  Handle(TColStd_HArray1OfInteger) anArr;
+  if(ValString.Length() == 0 || !theLen) return anArr;
+  anArr = new TColStd_HArray1OfInteger (1, theLen, 0);
+  for(Standard_Integer i = 1;i <= theLen;i++) {
+    const TCollection_AsciiString& aSVal = ValString.Token(" ",i);
+    if(aSVal.Length())
+      anArr->SetValue(i, aSVal.IntegerValue());      
+  }
+  return anArr;
+}
+
+//=======================================================================
+Handle(TColStd_HArray1OfReal) BuildRealArray(const TCollection_AsciiString& ValString, 
+					     const Standard_Integer theLen) 
+{
+  Handle(TColStd_HArray1OfReal) anArr;
+  if(ValString.Length() == 0 || !theLen) return anArr;
+  anArr = new TColStd_HArray1OfReal (1, theLen, .0);
+  for(Standard_Integer i = 1;i <= theLen;i++) {
+    const TCollection_AsciiString& aSVal = ValString.Token(" ",i);
+    if(aSVal.Length())
+      anArr->SetValue(i, aSVal.RealValue());      
+  }
+  return anArr;
+}
+//=======================================================================
+//function : Paste
+//purpose  : persistent -> transient (retrieve)
+//=======================================================================
+Standard_Boolean XmlMDataStd_NamedDataDriver::Paste(const XmlObjMgt_Persistent&  theSource,
+						      const Handle(TDF_Attribute)& theTarget,
+						      XmlObjMgt_RRelocationTable&  ) const
+{
+  Standard_Integer aFirstInd, aLastInd, aValue, ind;
+  const XmlObjMgt_Element& anElement = theSource;
+
+  //DataMapOfStringInteger: Read the FirstIndex; if the attribute is absent initialize to 1
+  XmlObjMgt_DOMString aFirstIndex = anElement.getAttribute(::FirstIntegerIndex());
+  if (aFirstIndex == NULL)
+    aFirstInd = 1;
+  else if (!aFirstIndex.GetInteger(aFirstInd)) 
+  {
+    TCollection_ExtendedString aMessageString =
+      TCollection_ExtendedString("Cannot retrieve the first index for NamedData"
+                                 " attribute (DataMapOfStringInteger) as \"")
+        + aFirstIndex + "\"";
+    WriteMessage (aMessageString);
+    return Standard_False;
+  }
+
+  // Read the LastIndex;
+  XmlObjMgt_DOMString aLastIndex = anElement.getAttribute(::LastIntegerIndex());
+  if(aLastIndex == NULL) {
+    aFirstInd = 0;
+    aLastInd  = 0;
+  } else if (!aLastIndex.GetInteger(aLastInd)) {
+    TCollection_ExtendedString aMessageString =
+      TCollection_ExtendedString("Cannot retrieve the last index for NamedData"
+                                 " attribute (DataMapOfStringInteger) as \"")
+        + aLastIndex + "\"";
+    WriteMessage (aMessageString);
+    return Standard_False;
+  }
+  try {
+    Handle(TDataStd_NamedData) T = Handle(TDataStd_NamedData)::DownCast(theTarget);
+    LDOM_Node aCurNode;
+
+    if((aFirstInd | aLastInd) && aLastInd >= aFirstInd) {
+      if ( !anElement.hasChildNodes() )
+	{
+	  TCollection_ExtendedString aMessageString =
+	    TCollection_ExtendedString("Cannot retrieve DataMapOfStringInteger");
+	  WriteMessage (aMessageString);
+	  return Standard_False;
+	}
+      aCurNode = anElement.getFirstChild();
+      LDOM_Element* aCurElement = (LDOM_Element*)&aCurNode;
+      TCollection_ExtendedString aValueStr, aKey;
+      TColStd_DataMapOfStringInteger aMap;
+      for (ind = aFirstInd; ind < aLastInd; ind++) {
+	XmlObjMgt::GetExtendedString( *aCurElement, aKey );
+	aValueStr = SplitItemFromEnd(aKey);
+	if(aValueStr.Length() == 0) {
+	  TCollection_ExtendedString aMessageString =
+	    TCollection_ExtendedString("Cannot retrieve a value from item = ") + aKey;
+	  WriteMessage (aMessageString);
+	  return Standard_False;
+	}
+	TCollection_AsciiString aVal(aValueStr,'?');
+	Standard_Integer aValue = aVal.IntegerValue();
+	aMap.Bind(aKey, aValue);
+	aCurNode = aCurElement->getNextSibling();
+	aCurElement = (LDOM_Element*)&aCurNode;
+      }
+      XmlObjMgt::GetExtendedString( *aCurElement, aKey );
+      aValueStr = SplitItemFromEnd(aKey);
+      if(aValueStr.Length() == 0) {
+	TCollection_ExtendedString aMessageString =
+	  TCollection_ExtendedString("Cannot retrieve a value from item = ") + aKey;
+	WriteMessage (aMessageString);
+	return Standard_False;
+      }
+      TCollection_AsciiString aVal(aValueStr,'?');
+      Standard_Integer aValue = aVal.IntegerValue();
+      aMap.Bind(aKey, aValue);
+      T->ChangeIntegers(aMap);
+    }
+
+//DataMapOfStringReal
+    aFirstIndex = anElement.getAttribute(::FirstRealIndex());
+    if (aFirstIndex == NULL)
+      aFirstInd = 1;
+    else if (!aFirstIndex.GetInteger(aFirstInd)) 
+      {
+	TCollection_ExtendedString aMessageString =
+	  TCollection_ExtendedString("Cannot retrieve the first index for NamedData "
+				     "attribute (DataMapOfStringReal) as \"")
+	    + aFirstIndex + "\"";
+	WriteMessage (aMessageString);
+	return Standard_False;
+      }
+
+  // Read the LastIndex;
+    aLastIndex = anElement.getAttribute(::LastRealIndex());
+    if(aLastIndex == NULL) {
+      aFirstInd = 0;
+      aLastInd  = 0;
+    } else if (!aLastIndex.GetInteger(aLastInd)) {
+      TCollection_ExtendedString aMessageString =
+	TCollection_ExtendedString("Cannot retrieve the last index for NamedData"
+				   " attribute (DataMapOfStringReal) as \"")
+	  + aLastIndex + "\"";
+      WriteMessage (aMessageString);
+      return Standard_False;
+    }
+
+    if((aFirstInd | aLastInd) && aLastInd >= aFirstInd) { 
+      if ( !anElement.hasChildNodes())
+	{
+	  TCollection_ExtendedString aMessageString =
+	    TCollection_ExtendedString("Cannot retrieve DataMapOfStringReal");
+	  WriteMessage (aMessageString);
+	  return Standard_False;
+	}
+      
+      LDOM_Element* aCurElement;
+      if (aCurNode.isNull())
+	aCurNode = anElement.getFirstChild();
+      else 
+	aCurNode = aCurElement->getNextSibling();
+      
+      aCurElement = (LDOM_Element*)&aCurNode;
+      TCollection_ExtendedString aValueStr, aKey;
+      TDataStd_DataMapOfStringReal aMap;
+      for (ind = aFirstInd; ind < aLastInd; ind++) {
+	XmlObjMgt::GetExtendedString( *aCurElement, aKey );
+	aValueStr = SplitItemFromEnd(aKey);
+	if(aValueStr.Length() == 0) {
+	  TCollection_ExtendedString aMessageString =
+	    TCollection_ExtendedString("Cannot retrieve a value from item = ") + aKey;
+	  WriteMessage (aMessageString);
+	  return Standard_False;
+	}
+	TCollection_AsciiString aVal(aValueStr,'?');
+	Standard_Real aValue = aVal.RealValue();
+	aMap.Bind(aKey, aValue);
+	aCurNode = aCurElement->getNextSibling();
+	aCurElement = (LDOM_Element*)&aCurNode;
+      }
+      XmlObjMgt::GetExtendedString( *aCurElement, aKey );
+      aValueStr = SplitItemFromEnd(aKey);
+      if(aValueStr.Length() == 0) {
+	TCollection_ExtendedString aMessageString =
+	  TCollection_ExtendedString("Cannot retrieve a value from item = ") + aKey;
+	WriteMessage (aMessageString);
+	return Standard_False;
+      }
+      TCollection_AsciiString aVal(aValueStr,'?');
+      Standard_Real aValue = aVal.RealValue();
+      aMap.Bind(aKey, aValue);
+      T->ChangeReals(aMap);
+    }
+
+//DataMapOfStringString
+    aFirstIndex = anElement.getAttribute(::FirstStringIndex());
+    if (aFirstIndex == NULL)
+      aFirstInd = 1;
+    else if (!aFirstIndex.GetInteger(aFirstInd)) 
+      {
+	TCollection_ExtendedString aMessageString =
+	  TCollection_ExtendedString("Cannot retrieve the first index for NamedData"
+				     " attribute (DataMapOfStringString) as \"")
+	    + aFirstIndex + "\"";
+	WriteMessage (aMessageString);
+	return Standard_False;
+      }
+    aLastIndex = anElement.getAttribute(::LastStringIndex());
+    if(aLastIndex == NULL) {
+      aFirstInd = 0;
+      aLastInd  = 0;
+    } else if (!aLastIndex.GetInteger(aLastInd)) {
+      TCollection_ExtendedString aMessageString =
+	TCollection_ExtendedString("Cannot retrieve the last index for NamedData"
+				   " attribute (DataMapOfStringString) as \"")
+	  + aLastIndex + "\"";
+      WriteMessage (aMessageString);
+      return Standard_False;
+    }
+    
+    if((aFirstInd | aLastInd) && aLastInd >= aFirstInd) {
+      if ( !anElement.hasChildNodes())
+	{
+	  TCollection_ExtendedString aMessageString =
+	    TCollection_ExtendedString("Cannot retrieve DataMapOfStringString");
+	  WriteMessage (aMessageString);
+	  return Standard_False;
+	}
+      LDOM_Element* aCurElement;
+      if (aCurNode.isNull())
+	aCurNode = anElement.getFirstChild();
+      else 
+	aCurNode = aCurElement->getNextSibling();
+      
+      aCurElement = (LDOM_Element*)&aCurNode;
+      TCollection_ExtendedString aValue, aKey;
+      TDataStd_DataMapOfStringString aMap;
+      for (ind = aFirstInd; ind < aLastInd; ind++) {
+	XmlObjMgt::GetExtendedString( *aCurElement, aKey );
+	aValue = SplitItemFromStart(aKey); // ==>from start
+	if(aValue.Length() == 0) {
+	  TCollection_ExtendedString aMessageString =
+	    TCollection_ExtendedString("Cannot retrieve a value from item = ") + aKey;
+	  WriteMessage (aMessageString);
+	  return Standard_False;
+	}
+	aMap.Bind(aKey, aValue);
+	aCurNode = aCurElement->getNextSibling();
+	aCurElement = (LDOM_Element*)&aCurNode;
+      }
+      XmlObjMgt::GetExtendedString( *aCurElement, aKey );
+      aValue = SplitItemFromStart(aKey);
+      if(aValue.Length() == 0) {
+	TCollection_ExtendedString aMessageString =
+	  TCollection_ExtendedString("Cannot retrieve a value from item = ") + aKey;
+	WriteMessage (aMessageString);
+	return Standard_False;
+      }
+      
+      aMap.Bind(aKey, aValue);
+      T->ChangeStrings(aMap);
+    }
+
+//DataMapOfStringByte
+    aFirstIndex = anElement.getAttribute(::FirstByteIndex());
+    if (aFirstIndex == NULL)
+      aFirstInd = 1;
+    else if (!aFirstIndex.GetInteger(aFirstInd)) 
+      {
+	TCollection_ExtendedString aMessageString =
+	  TCollection_ExtendedString("Cannot retrieve the first index for NamedData "
+				     "attribute (DataMapOfStringByte) as \"")
+	    + aFirstIndex + "\"";
+	WriteMessage (aMessageString);
+	return Standard_False;
+      }
+
+  // Read the LastIndex;
+    aLastIndex = anElement.getAttribute(::LastByteIndex());
+    if(aLastIndex == NULL) {
+      aFirstInd = 0;
+      aLastInd  = 0;
+    } else if (!aLastIndex.GetInteger(aLastInd)) {
+      TCollection_ExtendedString aMessageString =
+	TCollection_ExtendedString("Cannot retrieve the last index for NamedData"
+				   " attribute (DataMapOfStringByte) as \"")
+	  + aLastIndex + "\"";
+      WriteMessage (aMessageString);
+      return Standard_False;
+    }
+    
+    if((aFirstInd | aLastInd) && aLastInd >= aFirstInd) { 
+      if ( !anElement.hasChildNodes())
+	{
+	  TCollection_ExtendedString aMessageString =
+	    TCollection_ExtendedString("Cannot retrieve DataMapOfStringByte");
+	  WriteMessage (aMessageString);
+	  return Standard_False;
+	}
+      
+      LDOM_Element* aCurElement;
+      if (aCurNode.isNull())
+	aCurNode = anElement.getFirstChild();
+      else 
+	aCurNode = aCurElement->getNextSibling();
+      
+      aCurElement = (LDOM_Element*)&aCurNode;
+      TCollection_ExtendedString aValueStr, aKey;
+      TDataStd_DataMapOfStringByte aMap;
+      for (ind = aFirstInd; ind < aLastInd; ind++) {
+	XmlObjMgt::GetExtendedString( *aCurElement, aKey );
+	aValueStr = SplitItemFromEnd(aKey);
+	if(aValueStr.Length() == 0) {
+	  TCollection_ExtendedString aMessageString =
+	    TCollection_ExtendedString("Cannot retrieve a value from item = ") + aKey;
+	  WriteMessage (aMessageString);
+	  return Standard_False;
+	}
+	
+	TCollection_AsciiString aVal(aValueStr,'?');
+	Standard_Byte aValue = (Standard_Byte)aVal.IntegerValue();
+	
+	aMap.Bind(aKey, aValue);
+	aCurNode = aCurElement->getNextSibling();
+	aCurElement = (LDOM_Element*)&aCurNode;
+      }
+      XmlObjMgt::GetExtendedString( *aCurElement, aKey );
+      aValueStr = SplitItemFromEnd(aKey);
+      if(aValueStr.Length() == 0) {
+	TCollection_ExtendedString aMessageString =
+	  TCollection_ExtendedString("Cannot retrieve a value from item = ") + aKey;
+	WriteMessage (aMessageString);
+	return Standard_False;
+      }
+      
+      TCollection_AsciiString aVal(aValueStr,'?');
+      Standard_Byte aValue = (Standard_Byte)aVal.IntegerValue();
+      aMap.Bind(aKey, aValue);
+      T->ChangeBytes(aMap);
+    }
+    
+//DataMapOfStringHArray1OfInteger
+    aFirstIndex = anElement.getAttribute(::FirstIntArrIndex());
+    if (aFirstIndex == NULL)
+      aFirstInd = 1;
+    else if (!aFirstIndex.GetInteger(aFirstInd)) 
+      {
+	TCollection_ExtendedString aMessageString =
+	  TCollection_ExtendedString("Cannot retrieve the first index for NamedData "
+				     "attribute (DataMapOfStringHArray1OfInteger) as \"")
+	    + aFirstIndex + "\"";
+	WriteMessage (aMessageString);
+	return Standard_False;
+      }
+    
+  // Read the LastIndex;
+    aLastIndex = anElement.getAttribute(::LastIntArrIndex());
+    if(aLastIndex == NULL) {
+      aFirstInd = 0;
+      aLastInd  = 0;
+    } else if (!aLastIndex.GetInteger(aLastInd)) {
+      TCollection_ExtendedString aMessageString =
+	TCollection_ExtendedString("Cannot retrieve the last index for NamedData"
+				   " attribute (DataMapOfStringHArray1OfInteger) as \"")
+	  + aLastIndex + "\"";
+      WriteMessage (aMessageString);
+      return Standard_False;
+    }
+    
+    if((aFirstInd | aLastInd) && aLastInd >= aFirstInd) { 
+      if ( !anElement.hasChildNodes())
+	{
+	  TCollection_ExtendedString aMessageString =
+	    TCollection_ExtendedString("Cannot retrieve DataMapOfStringHArray1OfInteger");
+	  WriteMessage (aMessageString);
+	  return Standard_False;
+	}
+      LDOM_Element* aCurElement;
+      if (aCurNode.isNull())
+	aCurNode = anElement.getFirstChild();
+      else 
+	aCurNode = aCurElement->getNextSibling();
+      
+      aCurElement = (LDOM_Element*)&aCurNode;
+      TCollection_ExtendedString aKey, aValueStr;
+      TDataStd_DataMapOfStringHArray1OfInteger aMap;
+      
+      for (ind = aFirstInd; ind < aLastInd; ind++) {
+	XmlObjMgt::GetExtendedString( *aCurElement, aKey );// Len - at the end
+	aValueStr = SplitItemFromEnd(aKey);
+	if(aValueStr.Length() == 0) {
+	  TCollection_ExtendedString aMessageString =
+	    TCollection_ExtendedString("Cannot retrieve a value from item = ") + aKey;
+	  WriteMessage (aMessageString);
+	  return Standard_False;
+	}
+	TCollection_AsciiString aVal(aValueStr,'?');
+	Standard_Integer aLen = aVal.IntegerValue();
+	
+#ifdef DEB
+//      XmlObjMgt_DOMString aValStr = aCurElement->getAttribute(::Value()); 
+//      const char* aS = aValStr.GetString();
+//      cout << " Key = " << TCollection_AsciiString(aKey, '?') << " aValue = " << aS <<  endl;
+#endif      
+	
+	TCollection_AsciiString aValueString = aCurElement->getAttribute(::Value()); 
+	Handle(TColStd_HArray1OfInteger) aValue = BuildIntArray(aValueString, aLen);
+	if(aValue.IsNull()) {
+	  TCollection_ExtendedString aMessageString =
+	    TCollection_ExtendedString("Cannot retrieve a value from item = ") + aKey;
+	  WriteMessage (aMessageString);
+	  return Standard_False;
+	}
+	
+	aMap.Bind(aKey, aValue);
+	aCurNode = aCurElement->getNextSibling();
+	aCurElement = (LDOM_Element*)&aCurNode;
+      }
+      
+      XmlObjMgt::GetExtendedString( *aCurElement, aKey );
+      aValueStr = SplitItemFromEnd(aKey);
+      if(aValueStr.Length() == 0) {
+	TCollection_ExtendedString aMessageString =
+	  TCollection_ExtendedString("Cannot retrieve a value from item = ") + aKey;
+	WriteMessage (aMessageString);
+	return Standard_False;
+      }
+      TCollection_AsciiString aVal(aValueStr,'?');
+      Standard_Integer aLen = aVal.IntegerValue();
+#ifdef DEB
+//    XmlObjMgt_DOMString aValStr = aCurElement->getAttribute(::Value());  
+//    const char* aS = aValStr.GetString();
+//    cout << " Key = " << TCollection_AsciiString(aKey, '?') << " aValue = " <<aS<<endl;
+#endif
+      TCollection_AsciiString aValueString = aCurElement->getAttribute(::Value());
+      Handle(TColStd_HArray1OfInteger) aValue = BuildIntArray(aValueString, aLen);
+      if(aValue.IsNull()) {
+	TCollection_ExtendedString aMessageString =
+	  TCollection_ExtendedString("Cannot retrieve a value from item = ") + aKey;
+	WriteMessage (aMessageString);
+	return Standard_False;
+      }
+      aMap.Bind(aKey, aValue);
+      T->ChangeArraysOfIntegers(aMap);
+    }
+
+//DataMapOfStringHArray1OfReal
+    aFirstIndex = anElement.getAttribute(::FirstRealArrIndex());
+    if (aFirstIndex == NULL)
+      aFirstInd = 1;
+    else if (!aFirstIndex.GetInteger(aFirstInd)) 
+      {
+	TCollection_ExtendedString aMessageString =
+	  TCollection_ExtendedString("Cannot retrieve the first index for NamedData "
+				     "attribute (DataMapOfStringHArray1OfReal) as \"")
+	    + aFirstIndex + "\"";
+	WriteMessage (aMessageString);
+	return Standard_False;
+      }
+    
+  // Read the LastIndex;
+    aLastIndex = anElement.getAttribute(::LastRealArrIndex());
+    if(aLastIndex == NULL) {
+      aFirstInd = 0;
+      aLastInd  = 0;
+    } else if (!aLastIndex.GetInteger(aLastInd)) {
+      TCollection_ExtendedString aMessageString =
+	TCollection_ExtendedString("Cannot retrieve the last index for NamedData"
+                                 " attribute (DataMapOfStringHArray1OfReal) as \"")
+	  + aLastIndex + "\"";
+      WriteMessage (aMessageString);
+      return Standard_False;
+    }
+    
+    if((aFirstInd | aLastInd) && aLastInd >= aFirstInd) { 
+      if ( !anElement.hasChildNodes())
+	{
+	  TCollection_ExtendedString aMessageString =
+	    TCollection_ExtendedString("Cannot retrieve DataMapOfStringHArray1OfReal");
+	  WriteMessage (aMessageString);
+	  return Standard_False;
+	}
+      
+      LDOM_Element* aCurElement;
+      if (aCurNode.isNull())
+	aCurNode = anElement.getFirstChild();
+      else 
+	aCurNode = aCurElement->getNextSibling();
+      
+      aCurElement = (LDOM_Element*)&aCurNode;
+      TCollection_ExtendedString aKey, aValueStr;
+      TDataStd_DataMapOfStringHArray1OfReal aMap;
+      
+      for (ind = aFirstInd; ind < aLastInd; ind++) {
+	XmlObjMgt::GetExtendedString( *aCurElement, aKey );// Len - at the end
+	aValueStr = SplitItemFromEnd(aKey);
+	if(aValueStr.Length() == 0) {
+	  TCollection_ExtendedString aMessageString =
+ 	  TCollection_ExtendedString("Cannot retrieve a value from item = ") + aKey;
+	  WriteMessage (aMessageString);
+	  return Standard_False;
+	}
+	TCollection_AsciiString aVal(aValueStr,'?');
+	Standard_Integer aLen = aVal.IntegerValue();      
+	
+	TCollection_AsciiString aValueString = aCurElement->getAttribute(::Value());
+	Handle(TColStd_HArray1OfReal) aValue = BuildRealArray(aValueString, aLen);
+	if(aValue.IsNull()) {
+	  TCollection_ExtendedString aMessageString =
+	    TCollection_ExtendedString("Cannot retrieve a value from item = ") + aKey;
+	  WriteMessage (aMessageString);
+	  return Standard_False;
+	}
+	
+	aMap.Bind(aKey, aValue);
+	aCurNode = aCurElement->getNextSibling();
+	aCurElement = (LDOM_Element*)&aCurNode;
+      }
+      
+      XmlObjMgt::GetExtendedString( *aCurElement, aKey );
+      aValueStr = SplitItemFromEnd(aKey);
+      if(aValueStr.Length() == 0) {
+	TCollection_ExtendedString aMessageString =
+	  TCollection_ExtendedString("Cannot retrieve a value from item = ") + aKey;
+	WriteMessage (aMessageString);
+	return Standard_False;
+      }
+      TCollection_AsciiString aVal(aValueStr,'?');
+      Standard_Integer aLen = aVal.IntegerValue();
+      
+      TCollection_AsciiString aValueString = aCurElement->getAttribute(::Value());
+      Handle(TColStd_HArray1OfReal) aValue = BuildRealArray(aValueString, aLen);
+      if(aValue.IsNull()) {
+	TCollection_ExtendedString aMessageString =
+	  TCollection_ExtendedString("Cannot retrieve a value from item = ") + aKey;
+	WriteMessage (aMessageString);
+	return Standard_False;
+      }
+      
+      aMap.Bind(aKey, aValue);
+    T->ChangeArraysOfReals(aMap);
+    } 
+  } catch (EXCEPTION) {
+    TCollection_ExtendedString aMessageString =
+      TCollection_ExtendedString("Unknown exception during data retrieve in NamedDatDriver ");
+    WriteMessage (aMessageString);
+      return Standard_False;} 
+  
+  return Standard_True;
+}
+
+//=======================================================================
+//function : Paste
+//purpose  : transient -> persistent (store)
+//=======================================================================
+void XmlMDataStd_NamedDataDriver::Paste(const Handle(TDF_Attribute)& theSource,
+					XmlObjMgt_Persistent&        theTarget,
+					XmlObjMgt_SRelocationTable&  ) const
+{
+  Handle(TDataStd_NamedData) S = Handle(TDataStd_NamedData)::DownCast(theSource);
+  if(S.IsNull()) {
+    WriteMessage ("NamedDataDriver:: The source attribute is Null.");
+    return;}
+
+  Standard_Integer i=0, up;
+  XmlObjMgt_Element& anElement = theTarget;
+  XmlObjMgt_Document aDoc = anElement.getOwnerDocument().Doc();
+  if(S->HasIntegers() && !S->GetIntegersContainer().IsEmpty()) {
+    // store a set of elements with string in each of them
+    up = S->GetIntegersContainer().Extent();
+    theTarget.Element().setAttribute(::LastIntegerIndex(), up);
+
+    TColStd_DataMapIteratorOfDataMapOfStringInteger itr(S->GetIntegersContainer());
+    for (i=1; itr.More(); itr.Next(),i++) {
+      const TCollection_ExtendedString aValueStr = 
+	itr.Key() + ' ' + TCollection_ExtendedString(itr.Value());// key - value;
+      XmlObjMgt_Element aCurTarget = aDoc.createElement( ::ExtString() );
+      XmlObjMgt::SetExtendedString( aCurTarget, aValueStr );
+      anElement.appendChild( aCurTarget );
+    }
+  }
+
+  if(S->HasReals() && !S->GetRealsContainer().IsEmpty()) {
+    up = S->GetRealsContainer().Extent();
+    theTarget.Element().setAttribute(::LastRealIndex(), up);
+    TDataStd_DataMapIteratorOfDataMapOfStringReal itr(S->GetRealsContainer());
+    for (i=1; itr.More(); itr.Next(),i++) {
+     const TCollection_ExtendedString aValueStr = 
+	itr.Key() + ' ' + TCollection_ExtendedString(itr.Value());// key - value;
+     XmlObjMgt_Element aCurTarget = aDoc.createElement( ::ExtString() );
+     XmlObjMgt::SetExtendedString( aCurTarget, aValueStr );
+     anElement.appendChild( aCurTarget );
+    }
+  } 
+
+  if(S->HasStrings() && !S->GetStringsContainer().IsEmpty()) {
+    up = S->GetStringsContainer().Extent();
+    theTarget.Element().setAttribute(::LastStringIndex(), up);
+    TDataStd_DataMapIteratorOfDataMapOfStringString itr(S->GetStringsContainer());
+    for (i=1; itr.More(); itr.Next(),i++) {
+      const TCollection_ExtendedString aValueStr = 
+	itr.Key() + ' ' + TCollection_ExtendedString(itr.Value());// key(without blanks) - value;
+      XmlObjMgt_Element aCurTarget = aDoc.createElement( ::ExtString() );
+      XmlObjMgt::SetExtendedString( aCurTarget, aValueStr );
+      anElement.appendChild( aCurTarget );
+    }
+  } 
+
+  if(S->HasBytes() && !S->GetBytesContainer().IsEmpty()) {
+    up = S->GetBytesContainer().Extent();
+    theTarget.Element().setAttribute(::LastByteIndex(), up);
+    TDataStd_DataMapIteratorOfDataMapOfStringByte itr(S->GetBytesContainer());
+    for (i=1; itr.More(); itr.Next(),i++) {
+      const TCollection_ExtendedString aValueStr = 
+	itr.Key() + ' ' + TCollection_ExtendedString(itr.Value());// key - value;
+      XmlObjMgt_Element aCurTarget = aDoc.createElement( ::ExtString() );
+      XmlObjMgt::SetExtendedString( aCurTarget, aValueStr );
+      anElement.appendChild( aCurTarget );
+    }
+  } 
+
+  if(S->HasArraysOfIntegers() && !S->GetArraysOfIntegersContainer().IsEmpty()) {
+    up = S->GetArraysOfIntegersContainer().Extent();
+    theTarget.Element().setAttribute(::LastIntArrIndex(), up);
+    TDataStd_DataMapIteratorOfDataMapOfStringHArray1OfInteger itr(S->GetArraysOfIntegersContainer());
+    for (i=1; itr.More(); itr.Next(),i++) {
+      const TColStd_Array1OfInteger& anArr1 = itr.Value()->Array1();
+      const Standard_Integer aLen = anArr1.Upper() - anArr1.Lower() +1;
+
+      const TCollection_ExtendedString aValueStr = 
+	itr.Key() + ' ' + TCollection_ExtendedString(aLen);// key - Num_of_Arr_elements;
+      XmlObjMgt_Element aCurTarget = aDoc.createElement( ::ExtString() );
+      XmlObjMgt::SetExtendedString( aCurTarget,  aValueStr); //key
+      anElement.appendChild( aCurTarget );
+
+      //Value = Array
+      TCollection_AsciiString aValueStr2;
+      Standard_Integer j = anArr1.Lower();
+       while (1) {
+	 aValueStr2 += TCollection_AsciiString(anArr1.Value(j));
+	 if (j >= anArr1.Upper()) break;
+	 aValueStr2 += ' ';
+	 j++;
+       }
+
+      aCurTarget.setAttribute(::Value(), aValueStr2.ToCString());
+    }
+  }
+
+  if(S->HasArraysOfReals() && !S->GetArraysOfRealsContainer().IsEmpty()) {
+    up = S->GetArraysOfRealsContainer().Extent();
+    theTarget.Element().setAttribute(::LastRealArrIndex(), up);
+    TDataStd_DataMapIteratorOfDataMapOfStringHArray1OfReal itr(S->GetArraysOfRealsContainer());
+    for (i=1; itr.More(); itr.Next(),i++) {
+      const TColStd_Array1OfReal& anArr1 = itr.Value()->Array1();
+      const Standard_Integer aLen = anArr1.Upper() - anArr1.Lower() +1;
+
+      //key
+      const TCollection_ExtendedString aValueStr = 
+	itr.Key() + ' ' + TCollection_ExtendedString(aLen);// key - Num_of_Arr_elements;
+      XmlObjMgt_Element aCurTarget = aDoc.createElement( ::ExtString() );
+      XmlObjMgt::SetExtendedString( aCurTarget,  aValueStr); //key
+      anElement.appendChild( aCurTarget );
+
+      //Value = Array
+      TCollection_AsciiString aValueStr2;
+      Standard_Integer j = anArr1.Lower();
+      while (1) {
+#ifndef OCC6010
+	aValueStr2 += TCollection_AsciiString(anArr1.Value(j));
+#else
+	char aValueChar[32];
+	sprintf(aValueChar, "%.15g", anArr1.Value(j));
+	TCollection_AsciiString aValueStr(aValueChar);
+	aValueStr2 += aValueStr;
+#endif
+	if (j >= anArr1.Upper()) break;
+	aValueStr2 += ' ';
+	j++;
+      }
+      aCurTarget.setAttribute(::Value(), aValueStr2.ToCString());
+
+    }
+  }
+}

src/XmlMDataStd/XmlMDataStd_NoteBookDriver.cdl

@@ -0,0 +1,32 @@
+-- File:        XmlMDataStd_NoteBookDriver.cdl
+-- Created:     Fri Aug 24 20:16:51 2001
+-- Author:      Alexander GRIGORIEV
+-- Copyright:   Open Cascade 2001
+
+class NoteBookDriver from XmlMDataStd  inherits ADriver from XmlMDF
+
+        ---Purpose: Attribute Driver.
+
+uses
+    SRelocationTable from XmlObjMgt,
+    RRelocationTable from XmlObjMgt,
+    Persistent       from XmlObjMgt,
+    MessageDriver    from CDM,
+    Attribute        from TDF
+
+is
+    Create (theMessageDriver:MessageDriver from CDM)
+        returns mutable NoteBookDriver from XmlMDataStd;
+
+    NewEmpty (me)  returns mutable Attribute from TDF;
+
+    Paste(me; Source     : Persistent from XmlObjMgt;
+              Target     : mutable Attribute from TDF;
+              RelocTable : out RRelocationTable from XmlObjMgt)
+        returns Boolean from Standard;
+
+    Paste(me; Source     : Attribute from TDF;
+              Target     : in out Persistent from XmlObjMgt;
+              RelocTable : out SRelocationTable from XmlObjMgt);
+
+end NoteBookDriver;

src/XmlMDataStd/XmlMDataStd_NoteBookDriver.cxx

@@ -0,0 +1,52 @@
+// File:        XmlMDataStd_NoteBookDriver.cxx
+// Created:     Fri Aug 24 20:46:58 2001
+// Author:      Alexnder GRIGORIEV
+// Copyright:   Open Cascade 2001
+// History:
+
+#include <XmlMDataStd_NoteBookDriver.ixx>
+#include <TDataStd_NoteBook.hxx>
+
+//=======================================================================
+//function : XmlMDataStd_NoteBookDriver
+//purpose  : Constructor
+//=======================================================================
+
+XmlMDataStd_NoteBookDriver::XmlMDataStd_NoteBookDriver
+                        (const Handle(CDM_MessageDriver)& theMsgDriver)
+      : XmlMDF_ADriver (theMsgDriver, NULL)
+{}
+
+//=======================================================================
+//function : NewEmpty
+//purpose  : 
+//=======================================================================
+
+ Handle(TDF_Attribute) XmlMDataStd_NoteBookDriver::NewEmpty() const
+{
+  return (new TDataStd_NoteBook());
+}
+
+//=======================================================================
+//function : Paste
+//purpose  : 
+//=======================================================================
+
+ Standard_Boolean XmlMDataStd_NoteBookDriver::Paste
+                                        (const XmlObjMgt_Persistent&,
+                                         const Handle(TDF_Attribute)&,
+                                         XmlObjMgt_RRelocationTable& ) const
+{
+  return Standard_True;
+}
+
+//=======================================================================
+//function : Paste
+//purpose  : 
+//=======================================================================
+
+ void XmlMDataStd_NoteBookDriver::Paste (const Handle(TDF_Attribute)&,
+                                         XmlObjMgt_Persistent&,
+                                         XmlObjMgt_SRelocationTable&  ) const
+{
+}

src/XmlMDataStd/XmlMDataStd_RealArrayDriver.cdl

@@ -0,0 +1,32 @@
+-- File:        XmlMDataStd_RealArrayDriver.cdl
+-- Created:     Fri Aug 24 20:16:51 2001
+-- Author:      Alexander GRIGORIEV
+-- Copyright:   Open Cascade 2001
+
+class RealArrayDriver from XmlMDataStd  inherits ADriver from XmlMDF
+
+        ---Purpose: Attribute Driver.
+
+uses
+    SRelocationTable from XmlObjMgt,
+    RRelocationTable from XmlObjMgt,
+    Persistent       from XmlObjMgt,
+    MessageDriver    from CDM,
+    Attribute        from TDF
+
+is
+    Create (theMessageDriver:MessageDriver from CDM)
+        returns mutable RealArrayDriver from XmlMDataStd;
+
+    NewEmpty (me)  returns mutable Attribute from TDF;
+
+    Paste(me; Source     : Persistent from XmlObjMgt;
+              Target     : mutable Attribute from TDF;
+              RelocTable : out RRelocationTable from XmlObjMgt)
+        returns Boolean from Standard;
+
+    Paste(me; Source     : Attribute from TDF;
+              Target     : in out Persistent from XmlObjMgt;
+              RelocTable : out SRelocationTable from XmlObjMgt);
+
+end RealArrayDriver;

src/XmlMDataStd/XmlMDataStd_RealArrayDriver.cxx

@@ -0,0 +1,169 @@
+// File:        XmlMDataStd_RealArrayDriver.cxx
+// Created:     Fri Aug 24 20:46:58 2001
+// Author:      Alexnder GRIGORIEV
+// Copyright:   Open Cascade 2001-2002
+// History:     AGV 150202: Changed prototype XmlObjMgt::SetStringValue()
+
+#define OCC6010 // vro 01.06.2004
+
+# include <stdio.h>
+#include <XmlMDataStd_RealArrayDriver.ixx>
+#include <TDataStd_RealArray.hxx>
+#include <XmlObjMgt.hxx>
+#include <XmlMDataStd.hxx>
+
+IMPLEMENT_DOMSTRING (FirstIndexString, "first")
+IMPLEMENT_DOMSTRING (LastIndexString, "last")
+IMPLEMENT_DOMSTRING (IsDeltaOn,       "delta")
+
+//=======================================================================
+//function : XmlMDataStd_RealArrayDriver
+//purpose  : Constructor
+//=======================================================================
+
+XmlMDataStd_RealArrayDriver::XmlMDataStd_RealArrayDriver
+                        (const Handle(CDM_MessageDriver)& theMsgDriver)
+      : XmlMDF_ADriver (theMsgDriver, NULL)
+{}
+
+//=======================================================================
+//function : NewEmpty
+//purpose  : 
+//=======================================================================
+Handle(TDF_Attribute) XmlMDataStd_RealArrayDriver::NewEmpty() const
+{
+  return (new TDataStd_RealArray());
+}
+
+//=======================================================================
+//function : Paste
+//purpose  : persistent -> transient (retrieve)
+//=======================================================================
+Standard_Boolean XmlMDataStd_RealArrayDriver::Paste
+                                        (const XmlObjMgt_Persistent&  theSource,
+                                         const Handle(TDF_Attribute)& theTarget,
+                                         XmlObjMgt_RRelocationTable&  ) const
+{
+  Standard_Integer aFirstInd, aLastInd, ind;
+  Standard_Real aValue;
+  const XmlObjMgt_Element& anElement = theSource;
+
+  // Read the FirstIndex; if the attribute is absent initialize to 1
+  XmlObjMgt_DOMString aFirstIndex= anElement.getAttribute(::FirstIndexString());
+  if (aFirstIndex == NULL)
+    aFirstInd = 1;
+  else if (!aFirstIndex.GetInteger(aFirstInd)) {
+    TCollection_ExtendedString aMessageString =
+      TCollection_ExtendedString("Cannot retrieve the first index"
+                                 " for RealArray attribute as \"")
+        + aFirstIndex + "\"";
+    WriteMessage (aMessageString);
+    return Standard_False;
+  }
+
+  // Read LastIndex; the attribute should be present
+  if (!anElement.getAttribute(::LastIndexString()).GetInteger(aLastInd)) {
+    TCollection_ExtendedString aMessageString =
+      TCollection_ExtendedString("Cannot retrieve the last index"
+                                 " for RealArray attribute as \"")
+        + aFirstIndex + "\"";
+    WriteMessage (aMessageString);
+    return Standard_False;
+  }
+
+  Handle(TDataStd_RealArray) aRealArray =
+    Handle(TDataStd_RealArray)::DownCast(theTarget);
+  aRealArray->Init(aFirstInd, aLastInd);
+
+  // Check the type of LDOMString
+  const XmlObjMgt_DOMString& aString = XmlObjMgt::GetStringValue(anElement);
+  if (aString.Type() == LDOMBasicString::LDOM_Integer) {
+    if (aFirstInd == aLastInd) {
+      Standard_Integer anIntValue;
+      if (aString.GetInteger(anIntValue))
+        aRealArray -> SetValue (aFirstInd, Standard_Real(anIntValue));
+    } else {
+      TCollection_ExtendedString aMessageString =
+        TCollection_ExtendedString("Cannot retrieve array of real members"
+                                   " for RealArray attribute from Integer \"")
+        + aString + "\"";
+      WriteMessage (aMessageString);
+      return Standard_False;
+    }
+  } else {
+    Standard_CString aValueStr = Standard_CString(aString.GetString());
+    for (ind = aFirstInd; ind <= aLastInd; ind++)
+    {
+      if (!XmlObjMgt::GetReal(aValueStr, aValue)) {
+        TCollection_ExtendedString aMessageString =
+          TCollection_ExtendedString("Cannot retrieve real member"
+                                     " for RealArray attribute as \"")
+            + aValueStr + "\"";
+        WriteMessage (aMessageString);
+        return Standard_False;
+      }
+      aRealArray->SetValue(ind, aValue);
+    }
+  }
+#ifdef DEB
+  //cout << "CurDocVersion = " << XmlMDataStd::DocumentVersion() <<endl;
+#endif
+  Standard_Boolean aDelta(Standard_False);
+  
+  if(XmlMDataStd::DocumentVersion() > 2) {
+    Standard_Integer aDeltaValue;
+    if (!anElement.getAttribute(::IsDeltaOn()).GetInteger(aDeltaValue)) 
+      {
+	TCollection_ExtendedString aMessageString =
+	  TCollection_ExtendedString("Cannot retrieve the isDelta value"
+                                 " for RealArray attribute as \"")
+        + aDeltaValue + "\"";
+	WriteMessage (aMessageString);
+	return Standard_False;
+      } 
+    else
+      aDelta = (Standard_Boolean)aDeltaValue;
+  }
+#ifdef DEB
+  else if(XmlMDataStd::DocumentVersion() == -1)
+    cout << "Current DocVersion field is not initialized. "  <<endl;
+#endif
+  aRealArray->SetDelta(aDelta);
+
+  return Standard_True;
+}
+
+//=======================================================================
+//function : Paste
+//purpose  : transient -> persistent (store)
+//=======================================================================
+void XmlMDataStd_RealArrayDriver::Paste (const Handle(TDF_Attribute)& theSource,
+                                         XmlObjMgt_Persistent&        theTarget,
+                                         XmlObjMgt_SRelocationTable&  ) const
+{
+  Handle(TDataStd_RealArray) aRealArray =
+    Handle(TDataStd_RealArray)::DownCast(theSource);
+
+  Standard_Integer aL = aRealArray->Lower(), anU = aRealArray->Upper();
+  TCollection_AsciiString aValueStr;
+
+  if (aL != 1) theTarget.Element().setAttribute(::FirstIndexString(), aL);
+  theTarget.Element().setAttribute(::LastIndexString(), anU);
+  theTarget.Element().setAttribute(::IsDeltaOn(), aRealArray->GetDelta());
+
+  Standard_Integer i = aL;
+  while (1) {
+#ifndef OCC6010
+    aValueStr += TCollection_AsciiString(aRealArray->Value(i));
+#else
+    char aValueChar[32];
+    sprintf(aValueChar, "%.15g", aRealArray->Value(i));
+    aValueStr += aValueChar;
+#endif
+    if (i >= anU) break;
+    aValueStr += ' ';
+    ++i;
+  }
+  // No occurrence of '&', '<' and other irregular XML characters
+  XmlObjMgt::SetStringValue (theTarget, aValueStr.ToCString(), Standard_True);
+}

src/XmlMDataStd/XmlMDataStd_RealDriver.cdl

@@ -0,0 +1,32 @@
+-- File:        XmlMDataStd_RealDriver.cdl
+-- Created:     Fri Aug 24 20:16:51 2001
+-- Author:      Alexander GRIGORIEV
+-- Copyright:   Open Cascade 2001
+
+class RealDriver from XmlMDataStd  inherits ADriver from XmlMDF
+
+        ---Purpose: Attribute Driver.
+
+uses
+    SRelocationTable from XmlObjMgt,
+    RRelocationTable from XmlObjMgt,
+    Persistent       from XmlObjMgt,
+    MessageDriver    from CDM,
+    Attribute        from TDF
+
+is
+    Create (theMessageDriver:MessageDriver from CDM)
+        returns mutable RealDriver from XmlMDataStd;
+
+    NewEmpty (me)  returns mutable Attribute from TDF;
+
+    Paste(me; Source     : Persistent from XmlObjMgt;
+              Target     : mutable Attribute from TDF;
+              RelocTable : out RRelocationTable from XmlObjMgt)
+        returns Boolean from Standard;
+
+    Paste(me; Source     : Attribute from TDF;
+              Target     : in out Persistent from XmlObjMgt;
+              RelocTable : out SRelocationTable from XmlObjMgt);
+
+end RealDriver;

src/XmlMDataStd/XmlMDataStd_RealDriver.cxx

@@ -0,0 +1,77 @@
+// File:        XmlMDataStd_RealDriver.cxx
+// Created:     Fri Aug 24 20:46:58 2001
+// Author:      Alexnder GRIGORIEV
+// Copyright:   Open Cascade 2001-2002
+// History:     AGV 150202: Changed prototype XmlObjMgt::SetStringValue()
+
+#define OCC6010 // vro 09.06.2004
+
+#include <stdio.h>
+#include <XmlMDataStd_RealDriver.ixx>
+#include <TDataStd_Real.hxx>
+#include <XmlObjMgt.hxx>
+
+//=======================================================================
+//function : XmlMDataStd_RealDriver
+//purpose  : Constructor
+//=======================================================================
+
+XmlMDataStd_RealDriver::XmlMDataStd_RealDriver
+                        (const Handle(CDM_MessageDriver)& theMsgDriver)
+      : XmlMDF_ADriver (theMsgDriver, NULL)
+{}
+
+//=======================================================================
+//function : NewEmpty
+//purpose  : 
+//=======================================================================
+Handle(TDF_Attribute) XmlMDataStd_RealDriver::NewEmpty() const
+{
+  return (new TDataStd_Real());
+}
+
+//=======================================================================
+//function : Paste
+//purpose  : persistent -> transient (retrieve)
+//=======================================================================
+Standard_Boolean XmlMDataStd_RealDriver::Paste
+                                        (const XmlObjMgt_Persistent&  theSource,
+                                         const Handle(TDF_Attribute)& theTarget,
+                                         XmlObjMgt_RRelocationTable&  ) const
+{
+  Standard_Real aValue;
+  XmlObjMgt_DOMString aRealStr= XmlObjMgt::GetStringValue (theSource);
+
+  if (XmlObjMgt::GetReal(aRealStr, aValue) == Standard_False) {
+    TCollection_ExtendedString aMessageString =
+      TCollection_ExtendedString("Cannot retrieve Real attribute from \"")
+        + aRealStr + "\"";
+    WriteMessage (aMessageString);
+    return Standard_False;
+  }
+
+  Handle(TDataStd_Real) anInt = Handle(TDataStd_Real)::DownCast(theTarget);
+  anInt->Set(aValue);
+
+  return Standard_True;
+}
+
+//=======================================================================
+//function : Paste
+//purpose  : transient -> persistent (store)
+//=======================================================================
+void XmlMDataStd_RealDriver::Paste (const Handle(TDF_Attribute)& theSource,
+                                    XmlObjMgt_Persistent&        theTarget,
+                                    XmlObjMgt_SRelocationTable&  ) const
+{
+  Handle(TDataStd_Real) anInt = Handle(TDataStd_Real)::DownCast(theSource);
+#ifndef OCC6010
+  TCollection_AsciiString aValueStr (anInt->Get());
+#else
+  char aValueChar[32];
+  sprintf(aValueChar, "%.15g", anInt->Get());
+  TCollection_AsciiString aValueStr(aValueChar);
+#endif
+  // No occurrence of '&', '<' and other irregular XML characters
+  XmlObjMgt::SetStringValue (theTarget, aValueStr.ToCString(), Standard_True);
+}

src/XmlMDataStd/XmlMDataStd_RealListDriver.cdl

@@ -0,0 +1,34 @@
+-- File:        XmlMDataStd_RealListDriver.cdl
+-- Created:     May 29 11:40:00 2007
+-- Author:      Vlad Romashko
+--  	    	<vladislav.romashko@opencascade.com>
+-- Copyright:   Open CASCADE
+
+class RealListDriver from XmlMDataStd inherits ADriver from XmlMDF
+
+uses
+
+    SRelocationTable from XmlObjMgt,
+    RRelocationTable from XmlObjMgt,
+    Persistent       from XmlObjMgt,
+    MessageDriver    from CDM,
+    Attribute        from TDF
+
+is
+
+    Create (theMessageDriver:MessageDriver from CDM)
+    returns mutable RealListDriver from XmlMDataStd;
+
+    NewEmpty (me)
+    returns mutable Attribute from TDF;
+
+    Paste(me; Source     : Persistent from XmlObjMgt;
+              Target     : mutable Attribute from TDF;
+              RelocTable : out RRelocationTable from XmlObjMgt)
+    returns Boolean from Standard;
+
+    Paste(me; Source     : Attribute from TDF;
+              Target     : in out Persistent from XmlObjMgt;
+              RelocTable : out SRelocationTable from XmlObjMgt);
+
+end RealListDriver;

src/XmlMDataStd/XmlMDataStd_RealListDriver.cxx

@@ -0,0 +1,138 @@
+// File:        XmlMDataStd_RealListDriver.cxx
+// Created:     May 29 11:40:00 2007
+// Author:      Vlad Romashko
+//  	    	<vladislav.romashko@opencascade.com>
+// Copyright:   Open CASCADE
+
+#include <XmlMDataStd_RealListDriver.ixx>
+#include <TDataStd_RealList.hxx>
+#include <TColStd_ListIteratorOfListOfReal.hxx>
+#include <XmlObjMgt.hxx>
+
+IMPLEMENT_DOMSTRING (FirstIndexString, "first")
+IMPLEMENT_DOMSTRING (LastIndexString,  "last")
+
+//=======================================================================
+//function : XmlMDataStd_RealListDriver
+//purpose  : Constructor
+//=======================================================================
+XmlMDataStd_RealListDriver::XmlMDataStd_RealListDriver(const Handle(CDM_MessageDriver)& theMsgDriver)
+     : XmlMDF_ADriver (theMsgDriver, NULL)
+{
+
+}
+
+//=======================================================================
+//function : NewEmpty
+//purpose  : 
+//=======================================================================
+Handle(TDF_Attribute) XmlMDataStd_RealListDriver::NewEmpty() const
+{
+  return new TDataStd_RealList();
+}
+
+//=======================================================================
+//function : Paste
+//purpose  : persistent -> transient (retrieve)
+//=======================================================================
+Standard_Boolean XmlMDataStd_RealListDriver::Paste(const XmlObjMgt_Persistent&  theSource,
+						   const Handle(TDF_Attribute)& theTarget,
+						   XmlObjMgt_RRelocationTable&  ) const
+{
+  Standard_Real aValue;
+  Standard_Integer aFirstInd, aLastInd, ind;
+  const XmlObjMgt_Element& anElement = theSource;
+
+  // Read the FirstIndex; if the attribute is absent initialize to 1
+  XmlObjMgt_DOMString aFirstIndex= anElement.getAttribute(::FirstIndexString());
+  if (aFirstIndex == NULL)
+    aFirstInd = 1;
+  else if (!aFirstIndex.GetInteger(aFirstInd)) 
+  {
+    TCollection_ExtendedString aMessageString =
+      TCollection_ExtendedString("Cannot retrieve the first index"
+                                 " for RealList attribute as \"")
+        + aFirstIndex + "\"";
+    WriteMessage (aMessageString);
+    return Standard_False;
+  }
+
+  // Read the LastIndex; the attribute should be present
+  if (!anElement.getAttribute(::LastIndexString()).GetInteger(aLastInd)) 
+  {
+    TCollection_ExtendedString aMessageString =
+      TCollection_ExtendedString("Cannot retrieve the last index"
+                                 " for RealList attribute as \"")
+        + aFirstIndex + "\"";
+    WriteMessage (aMessageString);
+    return Standard_False;
+  }
+
+  Handle(TDataStd_RealList) aRealList = Handle(TDataStd_RealList)::DownCast(theTarget);
+
+  // Check the type of LDOMString
+  const XmlObjMgt_DOMString& aString = XmlObjMgt::GetStringValue(anElement);
+  if (aString.Type() == LDOMBasicString::LDOM_Integer) 
+  {
+    if (aFirstInd == aLastInd) 
+    {
+      Standard_Integer anIntValue;
+      if (aString.GetInteger(anIntValue))
+        aRealList->Append(Standard_Real(anIntValue));
+    } 
+    else 
+    {
+      TCollection_ExtendedString aMessageString =
+        TCollection_ExtendedString("Cannot retrieve array of real members"
+                                   " for RealList attribute from Integer \"")
+        + aString + "\"";
+      WriteMessage (aMessageString);
+      return Standard_False;
+    }
+  } 
+  else 
+  {
+    Standard_CString aValueStr = Standard_CString(aString.GetString());
+    for (ind = aFirstInd; ind <= aLastInd; ind++)
+    {
+      if (!XmlObjMgt::GetReal(aValueStr, aValue)) {
+        TCollection_ExtendedString aMessageString =
+          TCollection_ExtendedString("Cannot retrieve real member"
+                                     " for RealList attribute as \"")
+            + aValueStr + "\"";
+        WriteMessage (aMessageString);
+        return Standard_False;
+      }
+      aRealList->Append(aValue);
+    }
+  }
+
+  return Standard_True;
+}
+
+//=======================================================================
+//function : Paste
+//purpose  : transient -> persistent (store)
+//=======================================================================
+void XmlMDataStd_RealListDriver::Paste(const Handle(TDF_Attribute)& theSource,
+				       XmlObjMgt_Persistent&        theTarget,
+				       XmlObjMgt_SRelocationTable&  ) const
+{
+  Handle(TDataStd_RealList) aRealList = Handle(TDataStd_RealList)::DownCast(theSource);
+
+  Standard_Integer anU = aRealList->Extent();
+  TCollection_AsciiString aValueStr;
+
+  theTarget.Element().setAttribute(::LastIndexString(), anU);
+  if (anU >= 1)
+  {
+    TColStd_ListIteratorOfListOfReal itr(aRealList->List());
+    for (; itr.More(); itr.Next())
+    {
+      aValueStr += TCollection_AsciiString(itr.Value());
+      aValueStr += ' ';
+    }
+  }
+  // No occurrence of '&', '<' and other irregular XML characters
+  XmlObjMgt::SetStringValue (theTarget, aValueStr.ToCString(), Standard_True);
+}

src/XmlMDataStd/XmlMDataStd_ReferenceArrayDriver.cdl

@@ -0,0 +1,34 @@
+-- File:        XmlMDataStd_ReferenceArrayDriver.cdl
+-- Created:     May 29 11:40:00 2007
+-- Author:      Vlad Romashko
+--  	    	<vladislav.romashko@opencascade.com>
+-- Copyright:   Open CASCADE
+
+class ReferenceArrayDriver from XmlMDataStd inherits ADriver from XmlMDF
+
+uses
+
+    SRelocationTable from XmlObjMgt,
+    RRelocationTable from XmlObjMgt,
+    Persistent       from XmlObjMgt,
+    MessageDriver    from CDM,
+    Attribute        from TDF
+
+is
+
+    Create (theMessageDriver:MessageDriver from CDM)
+    returns mutable ReferenceArrayDriver from XmlMDataStd;
+
+    NewEmpty (me)
+    returns mutable Attribute from TDF;
+
+    Paste(me; Source     : Persistent from XmlObjMgt;
+              Target     : mutable Attribute from TDF;
+              RelocTable : out RRelocationTable from XmlObjMgt)
+    returns Boolean from Standard;
+
+    Paste(me; Source     : Attribute from TDF;
+              Target     : in out Persistent from XmlObjMgt;
+              RelocTable : out SRelocationTable from XmlObjMgt);
+
+end ReferenceArrayDriver;

src/XmlMDataStd/XmlMDataStd_ReferenceArrayDriver.cxx

@@ -0,0 +1,184 @@
+// File:        XmlMDataStd_ReferenceArrayDriver.cxx
+// Created:     May 29 11:40:00 2007
+// Author:      Vlad Romashko
+//  	    	<vladislav.romashko@opencascade.com>
+// Copyright:   Open CASCADE
+
+#include <XmlMDataStd_ReferenceArrayDriver.ixx>
+#include <XmlObjMgt.hxx>
+#include <XmlObjMgt_Document.hxx>
+#include <LDOM_MemManager.hxx>
+
+#include <TDF_Tool.hxx>
+#include <TDF_Label.hxx>
+#include <TDataStd_ReferenceArray.hxx>
+
+IMPLEMENT_DOMSTRING (FirstIndexString, "first")
+IMPLEMENT_DOMSTRING (LastIndexString,  "last")
+IMPLEMENT_DOMSTRING (ExtString,        "string")
+
+//=======================================================================
+//function : XmlMDataStd_ReferenceArrayDriver
+//purpose  : Constructor
+//=======================================================================
+XmlMDataStd_ReferenceArrayDriver::XmlMDataStd_ReferenceArrayDriver(const Handle(CDM_MessageDriver)& theMsgDriver)
+     : XmlMDF_ADriver (theMsgDriver, NULL)
+{
+
+}
+
+//=======================================================================
+//function : NewEmpty
+//purpose  : 
+//=======================================================================
+Handle(TDF_Attribute) XmlMDataStd_ReferenceArrayDriver::NewEmpty() const
+{
+  return new TDataStd_ReferenceArray();
+}
+
+//=======================================================================
+//function : Paste
+//purpose  : persistent -> transient (retrieve)
+//=======================================================================
+Standard_Boolean XmlMDataStd_ReferenceArrayDriver::Paste(const XmlObjMgt_Persistent&  theSource,
+							 const Handle(TDF_Attribute)& theTarget,
+							 XmlObjMgt_RRelocationTable&  ) const
+{
+  Standard_Integer aFirstInd, aLastInd;
+  const XmlObjMgt_Element& anElement = theSource;
+
+  // Read the FirstIndex; if the attribute is absent initialize to 1
+  XmlObjMgt_DOMString aFirstIndex= anElement.getAttribute(::FirstIndexString());
+  if (aFirstIndex == NULL)
+    aFirstInd = 1;
+  else if (!aFirstIndex.GetInteger(aFirstInd)) 
+  {
+    TCollection_ExtendedString aMessageString =
+      TCollection_ExtendedString("Cannot retrieve the first index"
+                                 " for ReferenceArray attribute as \"")
+        + aFirstIndex + "\"";
+    WriteMessage (aMessageString);
+    return Standard_False;
+  }
+
+  // Read the LastIndex; the attribute should present
+  if (!anElement.getAttribute(::LastIndexString()).GetInteger(aLastInd)) 
+  {
+    TCollection_ExtendedString aMessageString =
+      TCollection_ExtendedString("Cannot retrieve the last index"
+                                 " for ReferenceArray attribute as \"")
+        + aFirstIndex + "\"";
+    WriteMessage (aMessageString);
+    return Standard_False;
+  }
+
+  Handle(TDataStd_ReferenceArray) aReferenceArray = Handle(TDataStd_ReferenceArray)::DownCast(theTarget);
+  aReferenceArray->Init(aFirstInd, aLastInd);
+  
+  if (!anElement.hasChildNodes())
+  {
+    TCollection_ExtendedString aMessageString = 
+      TCollection_ExtendedString("Cannot retrieve a Array of reference");
+    WriteMessage (aMessageString);
+    return Standard_False;
+  }
+
+  LDOM_Node aCurNode = anElement.getFirstChild();
+  LDOM_Element* aCurElement = (LDOM_Element*)&aCurNode;
+  XmlObjMgt_DOMString aValueStr;
+  Standard_Integer i = aFirstInd;
+  while (*aCurElement != anElement.getLastChild())
+  {
+    aValueStr = XmlObjMgt::GetStringValue( *aCurElement );
+    if (aValueStr == NULL)
+    {
+      WriteMessage ("Cannot retrieve reference string from element");
+      return Standard_False;
+    }
+    TCollection_AsciiString anEntry;
+    if (XmlObjMgt::GetTagEntryString (aValueStr, anEntry) == Standard_False)
+    {
+      TCollection_ExtendedString aMessage =
+	TCollection_ExtendedString ("Cannot retrieve reference from \"")
+	  + aValueStr + '\"';
+      WriteMessage (aMessage);
+      return Standard_False;
+    }
+    // Find label by entry
+    TDF_Label tLab; // Null label.
+    if (anEntry.Length() > 0)
+    {
+      TDF_Tool::Label(aReferenceArray->Label().Data(), anEntry, tLab, Standard_True);
+    }
+    aReferenceArray->SetValue(i++, tLab);
+    aCurNode = aCurElement->getNextSibling();
+    aCurElement = (LDOM_Element*)&aCurNode;
+  }
+
+  // Last reference
+  aValueStr = XmlObjMgt::GetStringValue( *aCurElement );
+  if (aValueStr == NULL)
+  {
+    WriteMessage ("Cannot retrieve reference string from element");
+    return Standard_False;
+  }
+  TCollection_AsciiString anEntry;
+  if (XmlObjMgt::GetTagEntryString (aValueStr, anEntry) == Standard_False)
+  {
+    TCollection_ExtendedString aMessage =
+      TCollection_ExtendedString ("Cannot retrieve reference from \"")
+	+ aValueStr + '\"';
+    WriteMessage (aMessage);
+    return Standard_False;
+  }
+  // Find label by entry
+  TDF_Label tLab; // Null label.
+  if (anEntry.Length() > 0)
+  {
+    TDF_Tool::Label(aReferenceArray->Label().Data(), anEntry, tLab, Standard_True);
+  }
+  aReferenceArray->SetValue(i, tLab);
+
+  return Standard_True;
+}
+
+//=======================================================================
+//function : Paste
+//purpose  : transient -> persistent (store)
+//=======================================================================
+void XmlMDataStd_ReferenceArrayDriver::Paste(const Handle(TDF_Attribute)& theSource,
+					     XmlObjMgt_Persistent&        theTarget,
+					     XmlObjMgt_SRelocationTable&  ) const
+{
+  Handle(TDataStd_ReferenceArray) aReferenceArray = Handle(TDataStd_ReferenceArray)::DownCast(theSource);
+  TDF_Label L = aReferenceArray->Label();
+  if (L.IsNull())
+  {
+    WriteMessage ("Label of a ReferenceArray is Null.");
+    return;
+  }
+
+  Standard_Integer aL = aReferenceArray->Lower();
+  Standard_Integer anU = aReferenceArray->Upper();
+  XmlObjMgt_Element& anElement = theTarget;
+  anElement.setAttribute(::FirstIndexString(), aL);
+  anElement.setAttribute(::LastIndexString(), anU);
+  
+  XmlObjMgt_Document aDoc = anElement.getOwnerDocument().Doc();
+  
+  for (Standard_Integer i = aL; i <= anU; i++)
+  {
+    if (L.IsDescendant(aReferenceArray->Value(i).Root()))
+    {
+      // Internal reference
+      TCollection_AsciiString anEntry;
+      TDF_Tool::Entry(aReferenceArray->Value(i), anEntry);
+
+      XmlObjMgt_DOMString aDOMString;
+      XmlObjMgt::SetTagEntryString (aDOMString, anEntry);
+      XmlObjMgt_Element aCurTarget = aDoc.createElement( ::ExtString() );
+      XmlObjMgt::SetStringValue (aCurTarget, aDOMString, Standard_True);
+      anElement.appendChild( aCurTarget );
+    }
+  }
+}

src/XmlMDataStd/XmlMDataStd_ReferenceListDriver.cdl

@@ -0,0 +1,34 @@
+-- File:        XmlMDataStd_ReferenceListDriver.cdl
+-- Created:     May 29 11:40:00 2007
+-- Author:      Vlad Romashko
+--  	    	<vladislav.romashko@opencascade.com>
+-- Copyright:   Open CASCADE
+
+class ReferenceListDriver from XmlMDataStd inherits ADriver from XmlMDF
+
+uses
+
+    SRelocationTable from XmlObjMgt,
+    RRelocationTable from XmlObjMgt,
+    Persistent       from XmlObjMgt,
+    MessageDriver    from CDM,
+    Attribute        from TDF
+
+is
+
+    Create (theMessageDriver:MessageDriver from CDM)
+    returns mutable ReferenceListDriver from XmlMDataStd;
+
+    NewEmpty (me)
+    returns mutable Attribute from TDF;
+
+    Paste(me; Source     : Persistent from XmlObjMgt;
+              Target     : mutable Attribute from TDF;
+              RelocTable : out RRelocationTable from XmlObjMgt)
+    returns Boolean from Standard;
+
+    Paste(me; Source     : Attribute from TDF;
+              Target     : in out Persistent from XmlObjMgt;
+              RelocTable : out SRelocationTable from XmlObjMgt);
+
+end ReferenceListDriver;

src/XmlMDataStd/XmlMDataStd_ReferenceListDriver.cxx

@@ -0,0 +1,182 @@
+// File:        XmlMDataStd_ReferenceListDriver.cxx
+// Created:     May 29 11:40:00 2007
+// Author:      Vlad Romashko
+//  	    	<vladislav.romashko@opencascade.com>
+// Copyright:   Open CASCADE
+
+#include <XmlMDataStd_ReferenceListDriver.ixx>
+#include <XmlObjMgt.hxx>
+#include <XmlObjMgt_Document.hxx>
+#include <LDOM_MemManager.hxx>
+
+#include <TDF_Tool.hxx>
+#include <TDF_Label.hxx>
+#include <TDataStd_ReferenceList.hxx>
+#include <TDF_ListIteratorOfLabelList.hxx>
+
+IMPLEMENT_DOMSTRING (FirstIndexString, "first")
+IMPLEMENT_DOMSTRING (LastIndexString,  "last")
+IMPLEMENT_DOMSTRING (ExtString,        "string")
+
+//=======================================================================
+//function : XmlMDataStd_ReferenceListDriver
+//purpose  : Constructor
+//=======================================================================
+XmlMDataStd_ReferenceListDriver::XmlMDataStd_ReferenceListDriver(const Handle(CDM_MessageDriver)& theMsgDriver)
+     : XmlMDF_ADriver (theMsgDriver, NULL)
+{
+
+}
+
+//=======================================================================
+//function : NewEmpty
+//purpose  : 
+//=======================================================================
+Handle(TDF_Attribute) XmlMDataStd_ReferenceListDriver::NewEmpty() const
+{
+  return new TDataStd_ReferenceList();
+}
+
+//=======================================================================
+//function : Paste
+//purpose  : persistent -> transient (retrieve)
+//=======================================================================
+Standard_Boolean XmlMDataStd_ReferenceListDriver::Paste(const XmlObjMgt_Persistent&  theSource,
+							const Handle(TDF_Attribute)& theTarget,
+							XmlObjMgt_RRelocationTable&  ) const
+{
+  Standard_Integer aFirstInd, aLastInd;
+  const XmlObjMgt_Element& anElement = theSource;
+
+  // Read the FirstIndex; if the attribute is absent initialize to 1
+  XmlObjMgt_DOMString aFirstIndex= anElement.getAttribute(::FirstIndexString());
+  if (aFirstIndex == NULL)
+    aFirstInd = 1;
+  else if (!aFirstIndex.GetInteger(aFirstInd)) 
+  {
+    TCollection_ExtendedString aMessageString =
+      TCollection_ExtendedString("Cannot retrieve the first index"
+                                 " for ReferenceList attribute as \"")
+        + aFirstIndex + "\"";
+    WriteMessage (aMessageString);
+    return Standard_False;
+  }
+
+  // Read the LastIndex; the attribute should present
+  if (!anElement.getAttribute(::LastIndexString()).GetInteger(aLastInd)) 
+  {
+    TCollection_ExtendedString aMessageString =
+      TCollection_ExtendedString("Cannot retrieve the last index"
+                                 " for ReferenceList attribute as \"")
+        + aFirstIndex + "\"";
+    WriteMessage (aMessageString);
+    return Standard_False;
+  }
+
+  Handle(TDataStd_ReferenceList) aReferenceList = Handle(TDataStd_ReferenceList)::DownCast(theTarget);
+  
+  if (!anElement.hasChildNodes())
+  {
+    TCollection_ExtendedString aMessageString = 
+      TCollection_ExtendedString("Cannot retrieve a list of reference");
+    WriteMessage (aMessageString);
+    return Standard_False;
+  }
+
+  LDOM_Node aCurNode = anElement.getFirstChild();
+  LDOM_Element* aCurElement = (LDOM_Element*)&aCurNode;
+  XmlObjMgt_DOMString aValueStr;
+  while (*aCurElement != anElement.getLastChild())
+  {
+    aValueStr = XmlObjMgt::GetStringValue( *aCurElement );
+    if (aValueStr == NULL)
+    {
+      WriteMessage ("Cannot retrieve reference string from element");
+      return Standard_False;
+    }
+    TCollection_AsciiString anEntry;
+    if (XmlObjMgt::GetTagEntryString (aValueStr, anEntry) == Standard_False)
+    {
+      TCollection_ExtendedString aMessage =
+	TCollection_ExtendedString ("Cannot retrieve reference from \"")
+	  + aValueStr + '\"';
+      WriteMessage (aMessage);
+      return Standard_False;
+    }
+    // Find label by entry
+    TDF_Label tLab; // Null label.
+    if (anEntry.Length() > 0)
+    {
+      TDF_Tool::Label(aReferenceList->Label().Data(), anEntry, tLab, Standard_True);
+    }
+    aReferenceList->Append(tLab);
+    aCurNode = aCurElement->getNextSibling();
+    aCurElement = (LDOM_Element*)&aCurNode;
+  }
+
+  // Last reference
+  aValueStr = XmlObjMgt::GetStringValue( *aCurElement );
+  if (aValueStr == NULL)
+  {
+    WriteMessage ("Cannot retrieve reference string from element");
+    return Standard_False;
+  }
+  TCollection_AsciiString anEntry;
+  if (XmlObjMgt::GetTagEntryString (aValueStr, anEntry) == Standard_False)
+  {
+    TCollection_ExtendedString aMessage =
+      TCollection_ExtendedString ("Cannot retrieve reference from \"")
+	+ aValueStr + '\"';
+    WriteMessage (aMessage);
+    return Standard_False;
+  }
+  // Find label by entry
+  TDF_Label tLab; // Null label.
+  if (anEntry.Length() > 0)
+  {
+    TDF_Tool::Label(aReferenceList->Label().Data(), anEntry, tLab, Standard_True);
+  }
+  aReferenceList->Append(tLab);
+
+  return Standard_True;
+}
+
+//=======================================================================
+//function : Paste
+//purpose  : transient -> persistent (store)
+//=======================================================================
+void XmlMDataStd_ReferenceListDriver::Paste(const Handle(TDF_Attribute)& theSource,
+					    XmlObjMgt_Persistent&        theTarget,
+					    XmlObjMgt_SRelocationTable&  ) const
+{
+  Handle(TDataStd_ReferenceList) aReferenceList = Handle(TDataStd_ReferenceList)::DownCast(theSource);
+  TDF_Label L = aReferenceList->Label();
+  if (L.IsNull())
+  {
+    WriteMessage ("Label of a ReferenceList is Null.");
+    return;
+  }
+
+  Standard_Integer anU = aReferenceList->Extent();
+  XmlObjMgt_Element& anElement = theTarget;
+  anElement.setAttribute(::LastIndexString(), anU);
+  
+  XmlObjMgt_Document aDoc = anElement.getOwnerDocument().Doc();
+  
+  TDF_ListIteratorOfLabelList itr(aReferenceList->List());
+  for (; itr.More(); itr.Next())
+  {
+    if (L.IsDescendant(itr.Value().Root()))
+    {
+      // Internal reference
+      TCollection_AsciiString anEntry;
+      TDF_Tool::Entry(itr.Value(), anEntry);
+
+      XmlObjMgt_DOMString aDOMString;
+      XmlObjMgt::SetTagEntryString (aDOMString, anEntry);
+      XmlObjMgt_Element aCurTarget = aDoc.createElement( ::ExtString() );
+      XmlObjMgt::SetStringValue (aCurTarget, aDOMString, Standard_True);
+      anElement.appendChild( aCurTarget );
+    }
+  }
+}

src/XmlMDataStd/XmlMDataStd_RelationDriver.cdl

@@ -0,0 +1,32 @@
+-- File:        XmlMDataStd_RelationDriver.cdl
+-- Created:     Wed Sep 12 14:05:15 2001
+-- Author:      Julia DOROVSKIKH
+-- Copyright:   Open Cascade 2001
+
+class RelationDriver from XmlMDataStd  inherits ADriver from XmlMDF
+
+        ---Purpose: Attribute Driver.
+
+uses
+    SRelocationTable from XmlObjMgt,
+    RRelocationTable from XmlObjMgt,
+    Persistent       from XmlObjMgt,
+    MessageDriver    from CDM,
+    Attribute        from TDF
+
+is
+    Create (theMessageDriver:MessageDriver from CDM)
+        returns mutable RelationDriver from XmlMDataStd;
+
+    NewEmpty (me)  returns mutable Attribute from TDF;
+
+    Paste(me; Source     : Persistent from XmlObjMgt;
+              Target     : mutable Attribute from TDF;
+              RelocTable : out RRelocationTable from XmlObjMgt)
+        returns Boolean from Standard;
+
+    Paste(me; Source     : Attribute from TDF;
+              Target     : in out Persistent from XmlObjMgt;
+              RelocTable : out SRelocationTable from XmlObjMgt);
+
+end RelationDriver;

src/XmlMDataStd/XmlMDataStd_RelationDriver.cxx

@@ -0,0 +1,140 @@
+// File:        XmlMDataStd_RelationDriver.cxx
+// Created:     Wed Sep 12 14:07:32 2001
+// Author:      Julia DOROVSKIKH
+// Copyright:   Open Cascade 2001
+// History:
+
+#include <XmlMDataStd_RelationDriver.ixx>
+#include <TDataStd_Relation.hxx>
+#include <TDataStd_Variable.hxx>
+
+#include <TDF_ListIteratorOfAttributeList.hxx>
+
+#include <XmlObjMgt.hxx>
+
+IMPLEMENT_DOMSTRING (VariablesString, "variables")
+
+//=======================================================================
+//function : XmlMDataStd_RelationDriver
+//purpose  : Constructor
+//=======================================================================
+XmlMDataStd_RelationDriver::XmlMDataStd_RelationDriver
+                        (const Handle(CDM_MessageDriver)& theMsgDriver)
+      : XmlMDF_ADriver (theMsgDriver, NULL)
+{}
+
+//=======================================================================
+//function : NewEmpty
+//purpose  : 
+//=======================================================================
+Handle(TDF_Attribute) XmlMDataStd_RelationDriver::NewEmpty() const
+{
+  return (new TDataStd_Relation());
+}
+
+//=======================================================================
+//function : Paste
+//purpose  : persistent -> transient (retrieve)
+//=======================================================================
+Standard_Boolean XmlMDataStd_RelationDriver::Paste
+                        (const XmlObjMgt_Persistent&  theSource,
+                         const Handle(TDF_Attribute)& theTarget,
+                         XmlObjMgt_RRelocationTable&  theRelocTable) const
+{
+  Handle(TDataStd_Relation) aC = 
+    Handle(TDataStd_Relation)::DownCast(theTarget);
+  const XmlObjMgt_Element& anElem = theSource;
+
+  Standard_Integer aNb;
+  TCollection_ExtendedString aMsgString;
+
+  // expression
+  TCollection_ExtendedString aString;
+  if (!XmlObjMgt::GetExtendedString (theSource, aString))
+  {
+    WriteMessage("error retrieving ExtendedString for type TDataStd_Relation");
+    return Standard_False;
+  }
+  aC->SetRelation(aString);
+
+  // variables
+  XmlObjMgt_DOMString aDOMStr = anElem.getAttribute(::VariablesString());
+  if (aDOMStr != NULL)
+  {
+    Standard_CString aVs = Standard_CString(aDOMStr.GetString());
+
+    // first variable
+    if (!XmlObjMgt::GetInteger(aVs, aNb))
+    {
+      aMsgString = TCollection_ExtendedString
+        ("XmlMDataStd_RelationDriver: Cannot retrieve reference on first variable from \"")
+          + aDOMStr + "\"";
+      WriteMessage (aMsgString);
+      return Standard_False;
+    }
+    Standard_Integer i = 1;
+    while (aNb > 0)
+    {
+      Handle(TDF_Attribute) aV;
+      if (theRelocTable.IsBound(aNb))
+        aV = Handle(TDataStd_Variable)::DownCast(theRelocTable.Find(aNb));
+      else
+      {
+        aV = new TDataStd_Variable;
+        theRelocTable.Bind(aNb, aV);
+      }
+      aC->GetVariables().Append(aV);
+
+      // next variable
+      if (!XmlObjMgt::GetInteger(aVs, aNb)) aNb = 0;
+      i++;
+    }
+  }
+
+  return Standard_True;
+}
+
+//=======================================================================
+//function : Paste
+//purpose  : transient -> persistent (store)
+//=======================================================================
+void XmlMDataStd_RelationDriver::Paste
+                        (const Handle(TDF_Attribute)& theSource,
+                         XmlObjMgt_Persistent&        theTarget,
+                         XmlObjMgt_SRelocationTable&  theRelocTable) const
+{
+  Handle(TDataStd_Relation) aC =
+    Handle(TDataStd_Relation)::DownCast(theSource);
+  XmlObjMgt_Element& anElem = theTarget;
+
+  Standard_Integer aNb;
+  Handle(TDF_Attribute) TV;   
+
+  // expression
+  XmlObjMgt::SetExtendedString (theTarget, aC->Name());
+
+  // variables
+  Standard_Integer nbvar = aC->GetVariables().Extent();
+  if (nbvar >= 1)
+  {
+    TCollection_AsciiString aGsStr;
+    TDF_ListIteratorOfAttributeList it;
+    Standard_Integer index = 0;
+    for (it.Initialize(aC->GetVariables()); it.More(); it.Next())
+    {
+      index++;
+      TV = it.Value(); 
+      if (!TV.IsNull())
+      {
+        aNb = theRelocTable.FindIndex(TV);
+        if (aNb == 0)
+        {
+          aNb = theRelocTable.Add(TV);
+        }
+        aGsStr += TCollection_AsciiString(aNb) + " ";
+      }
+      else aGsStr += "0 ";
+    }
+    anElem.setAttribute(::VariablesString(), aGsStr.ToCString());
+  }
+}

src/XmlMDataStd/XmlMDataStd_TickDriver.cdl

@@ -0,0 +1,34 @@
+-- File:        XmlMDataStd_TickDriver.cdl
+-- Created:     May 29 11:40:00 2007
+-- Author:      Vlad Romashko
+--  	    	<vladislav.romashko@opencascade.com>
+-- Copyright:   Open CASCADE
+
+class TickDriver from XmlMDataStd inherits ADriver from XmlMDF
+
+uses
+
+    SRelocationTable from XmlObjMgt,
+    RRelocationTable from XmlObjMgt,
+    Persistent       from XmlObjMgt,
+    MessageDriver    from CDM,
+    Attribute        from TDF
+
+is
+
+    Create(theMessageDriver:MessageDriver from CDM)
+    returns mutable TickDriver from XmlMDataStd;
+
+    NewEmpty(me)
+    returns mutable Attribute from TDF;
+
+    Paste(me; Source     : Persistent from XmlObjMgt;
+              Target     : mutable Attribute from TDF;
+              RelocTable : out RRelocationTable from XmlObjMgt)
+    returns Boolean from Standard;
+
+    Paste(me; Source     : Attribute from TDF;
+              Target     : in out Persistent from XmlObjMgt;
+              RelocTable : out SRelocationTable from XmlObjMgt);
+
+end TickDriver;

src/XmlMDataStd/XmlMDataStd_TickDriver.cxx

@@ -0,0 +1,49 @@
+// File:        XmlMDataStd_TickDriver.cxx
+// Created:     May 29 11:40:00 2007
+// Author:      Vlad Romashko
+//  	    	<vladislav.romashko@opencascade.com>
+// Copyright:   Open CASCADE
+
+#include <XmlMDataStd_TickDriver.ixx>
+#include <TDataStd_Tick.hxx>
+
+//=======================================================================
+//function : XmlMDataStd_TickDriver
+//purpose  : Constructor
+//=======================================================================
+XmlMDataStd_TickDriver::XmlMDataStd_TickDriver(const Handle(CDM_MessageDriver)& theMsgDriver)
+: XmlMDF_ADriver (theMsgDriver, NULL)
+{
+
+}
+
+//=======================================================================
+//function : NewEmpty
+//purpose  : 
+//=======================================================================
+ Handle(TDF_Attribute) XmlMDataStd_TickDriver::NewEmpty() const
+{
+  return (new TDataStd_Tick());
+}
+
+//=======================================================================
+//function : Paste
+//purpose  : 
+//=======================================================================
+Standard_Boolean XmlMDataStd_TickDriver::Paste(const XmlObjMgt_Persistent&,
+					       const Handle(TDF_Attribute)&,
+					       XmlObjMgt_RRelocationTable& ) const
+{
+  return Standard_True;
+}
+
+//=======================================================================
+//function : Paste
+//purpose  : 
+//=======================================================================
+void XmlMDataStd_TickDriver::Paste(const Handle(TDF_Attribute)&,
+				   XmlObjMgt_Persistent&,
+				   XmlObjMgt_SRelocationTable&  ) const
+{
+
+}

src/XmlMDataStd/XmlMDataStd_TreeNodeDriver.cdl

@@ -0,0 +1,32 @@
+-- File:        XmlMDataStd_TreeNodeDriver.cdl
+-- Created:     Fri Aug 24 20:16:51 2001
+-- Author:      Alexander GRIGORIEV
+-- Copyright:   Open Cascade 2001
+
+class TreeNodeDriver from XmlMDataStd  inherits ADriver from XmlMDF
+
+        ---Purpose: Attribute Driver.
+
+uses
+    SRelocationTable from XmlObjMgt,
+    RRelocationTable from XmlObjMgt,
+    Persistent       from XmlObjMgt,
+    MessageDriver    from CDM,
+    Attribute        from TDF
+
+is
+    Create (theMessageDriver:MessageDriver from CDM)
+        returns mutable TreeNodeDriver from XmlMDataStd;
+
+    NewEmpty (me)  returns mutable Attribute from TDF;
+
+    Paste(me; Source     : Persistent from XmlObjMgt;
+              Target     : mutable Attribute from TDF;
+              RelocTable : out RRelocationTable from XmlObjMgt)
+        returns Boolean from Standard;
+
+    Paste(me; Source     : Attribute from TDF;
+              Target     : in out Persistent from XmlObjMgt;
+              RelocTable : out SRelocationTable from XmlObjMgt);
+
+end TreeNodeDriver;

src/XmlMDataStd/XmlMDataStd_TreeNodeDriver.cxx

@@ -0,0 +1,128 @@
+// File:        XmlMDataStd_TreeNodeDriver.cxx
+// Created:     Fri Aug 24 20:46:58 2001
+// Author:      Alexnder GRIGORIEV
+// Copyright:   Open Cascade 2001
+// History:
+
+#include <XmlMDataStd_TreeNodeDriver.ixx>
+#include <TDataStd_TreeNode.hxx>
+#include <XmlObjMgt.hxx>
+
+IMPLEMENT_DOMSTRING (TreeIdString,   "treeid")
+IMPLEMENT_DOMSTRING (ChildrenString, "children")
+
+//=======================================================================
+//function : XmlMDataStd_TreeNodeDriver
+//purpose  : Constructor
+//=======================================================================
+
+XmlMDataStd_TreeNodeDriver::XmlMDataStd_TreeNodeDriver
+                        (const Handle(CDM_MessageDriver)& theMsgDriver)
+      : XmlMDF_ADriver (theMsgDriver, NULL)
+{}
+
+//=======================================================================
+//function : NewEmpty
+//purpose  : 
+//=======================================================================
+Handle(TDF_Attribute) XmlMDataStd_TreeNodeDriver::NewEmpty() const
+{
+  return (new TDataStd_TreeNode());
+}
+
+//=======================================================================
+//function : Paste
+//purpose  : 
+//=======================================================================
+Standard_Boolean XmlMDataStd_TreeNodeDriver::Paste
+                               (const XmlObjMgt_Persistent&  theSource,
+                                const Handle(TDF_Attribute)& theTarget,
+                                XmlObjMgt_RRelocationTable& theRelocTable) const
+{
+  Handle(TDataStd_TreeNode) aT = Handle(TDataStd_TreeNode)::DownCast(theTarget);
+  const XmlObjMgt_Element& anElement = theSource;
+
+  // tree id
+  XmlObjMgt_DOMString aGUIDStr = anElement.getAttribute(::TreeIdString());
+  Standard_GUID aGUID (Standard_CString(aGUIDStr.GetString()));
+  aT->SetTreeID(aGUID);
+
+  // children
+  Handle(TDataStd_TreeNode) aTChild;
+
+  XmlObjMgt_DOMString aChildrenStr = anElement.getAttribute(::ChildrenString());
+  if (aChildrenStr != NULL)                     // void list is allowed
+  {
+    Standard_CString aChildren = Standard_CString(aChildrenStr.GetString());
+    Standard_Integer aNb = 0;
+    if (!XmlObjMgt::GetInteger(aChildren, aNb)) return Standard_False;
+
+    while (aNb > 0)
+    {
+      // Find or create TreeNode attribute with the given ID
+      if (theRelocTable.IsBound(aNb))
+      {
+        aTChild = Handle(TDataStd_TreeNode)::DownCast(theRelocTable.Find(aNb));
+        if (aTChild.IsNull())
+          return Standard_False;
+      }
+      else
+      {
+        aTChild = new TDataStd_TreeNode;
+        theRelocTable.Bind(aNb, aTChild);
+      }
+
+      // Add the child to the current tree
+      aTChild->SetTreeID(aGUID);
+      aT->Append(aTChild);
+
+      // Get next child ID
+      if (!XmlObjMgt::GetInteger(aChildren, aNb)) aNb = 0;
+    }
+  }
+  return Standard_True;
+}
+
+//=======================================================================
+//function : Paste
+//purpose  : 
+//=======================================================================
+void XmlMDataStd_TreeNodeDriver::Paste
+                               (const Handle(TDF_Attribute)& theSource,
+                                XmlObjMgt_Persistent&       theTarget,
+                                XmlObjMgt_SRelocationTable& theRelocTable) const
+{
+  Handle(TDataStd_TreeNode) aS = Handle(TDataStd_TreeNode)::DownCast(theSource);
+
+  Standard_Integer aNb;
+
+  TCollection_AsciiString aChildrenStr;
+
+  // tree id
+  Standard_Character aGuidStr [40];
+  Standard_PCharacter pGuidStr=aGuidStr;
+  aS->ID().ToCString (pGuidStr);
+  theTarget.Element().setAttribute(::TreeIdString(), aGuidStr);
+
+  // first child
+  Handle(TDataStd_TreeNode) aF = aS->First();
+
+  // form the string of numbers for the list of children
+  while (!aF.IsNull())
+  {
+    aNb = theRelocTable.FindIndex(aF);
+    if (aNb == 0)
+    {
+      aNb = theRelocTable.Add(aF);
+    }
+    TCollection_AsciiString aNbStr (aNb);
+    aChildrenStr += aNbStr + " ";
+
+    // next child
+    aF = aF->Next();
+  }
+
+  if (aChildrenStr.Length() > 0)
+    theTarget.Element().setAttribute(::ChildrenString(),
+                                      aChildrenStr.ToCString());
+}

src/XmlMDataStd/XmlMDataStd_UAttributeDriver.cdl

@@ -0,0 +1,32 @@
+-- File:        XmlMDataStd_UAttributeDriver.cdl
+-- Created:     Fri Aug 24 20:16:51 2001
+-- Author:      Alexander GRIGORIEV
+-- Copyright:   Open Cascade 2001
+
+class UAttributeDriver from XmlMDataStd  inherits ADriver from XmlMDF
+
+        ---Purpose: Attribute Driver.
+
+uses
+    SRelocationTable from XmlObjMgt,
+    RRelocationTable from XmlObjMgt,
+    Persistent       from XmlObjMgt,
+    MessageDriver    from CDM,
+    Attribute        from TDF
+
+is
+    Create (theMessageDriver:MessageDriver from CDM)
+        returns mutable UAttributeDriver from XmlMDataStd;
+
+    NewEmpty (me)  returns mutable Attribute from TDF;
+
+    Paste(me; Source     : Persistent from XmlObjMgt;
+              Target     : mutable Attribute from TDF;
+              RelocTable : out RRelocationTable from XmlObjMgt)
+        returns Boolean from Standard;
+
+    Paste(me; Source     : Attribute from TDF;
+              Target     : in out Persistent from XmlObjMgt;
+              RelocTable : out SRelocationTable from XmlObjMgt);
+
+end UAttributeDriver;

src/XmlMDataStd/XmlMDataStd_UAttributeDriver.cxx

@@ -0,0 +1,71 @@
+// File:        XmlMDataStd_UAttributeDriver.cxx
+// Created:     Fri Aug 24 20:46:58 2001
+// Author:      Alexnder GRIGORIEV
+// Copyright:   Open Cascade 2001
+// History:
+
+#include <XmlMDataStd_UAttributeDriver.ixx>
+#include <TDataStd_UAttribute.hxx>
+
+IMPLEMENT_DOMSTRING (GuidString, "guid")
+
+//=======================================================================
+//function : XmlMDataStd_UAttributeDriver
+//purpose  : Constructor
+//=======================================================================
+
+XmlMDataStd_UAttributeDriver::XmlMDataStd_UAttributeDriver
+                        (const Handle(CDM_MessageDriver)& theMsgDriver)
+      : XmlMDF_ADriver (theMsgDriver, NULL)
+{}
+
+//=======================================================================
+//function : NewEmpty
+//purpose  : 
+//=======================================================================
+Handle(TDF_Attribute) XmlMDataStd_UAttributeDriver::NewEmpty() const
+{
+  return (new TDataStd_UAttribute());
+}
+
+//=======================================================================
+//function : Paste
+//purpose  : 
+//=======================================================================
+Standard_Boolean XmlMDataStd_UAttributeDriver::Paste
+                                (const XmlObjMgt_Persistent&  theSource,
+                                 const Handle(TDF_Attribute)& theTarget,
+                                 XmlObjMgt_RRelocationTable&  ) const
+{
+  XmlObjMgt_DOMString aGuidDomStr =
+    theSource.Element().getAttribute (::GuidString());
+  Standard_CString aGuidStr = (Standard_CString)aGuidDomStr.GetString();
+  if (aGuidStr[0] == '\0') {
+    WriteMessage ("error retrieving GUID for type TDataStd_UAttribute");
+    return Standard_False;
+  }
+
+  Handle(TDataStd_UAttribute)::DownCast (theTarget) -> SetID (aGuidStr);
+  return Standard_True;
+}
+
+
+//=======================================================================
+//function : Paste
+//purpose  : 
+//=======================================================================
+void XmlMDataStd_UAttributeDriver::Paste(const Handle(TDF_Attribute)& theSource,
+                                         XmlObjMgt_Persistent&        theTarget,
+                                         XmlObjMgt_SRelocationTable&  ) const
+{
+  Handle(TDataStd_UAttribute) aName =
+    Handle(TDataStd_UAttribute)::DownCast(theSource);
+
+  //convert GUID into attribute value
+  Standard_Character aGuidStr [40];
+  Standard_PCharacter pGuidStr;
+  pGuidStr=aGuidStr;
+  aName->ID().ToCString (pGuidStr);
+
+  theTarget.Element().setAttribute (::GuidString(), aGuidStr);
+}

src/XmlMDataStd/XmlMDataStd_VariableDriver.cdl

@@ -0,0 +1,32 @@
+-- File:        XmlMDataStd_VariableDriver.cdl
+-- Created:     Fri Aug 24 20:16:51 2001
+-- Author:      Alexander GRIGORIEV
+-- Copyright:   Open Cascade 2001
+
+class VariableDriver from XmlMDataStd  inherits ADriver from XmlMDF
+
+        ---Purpose: Attribute Driver.
+
+uses
+    SRelocationTable from XmlObjMgt,
+    RRelocationTable from XmlObjMgt,
+    Persistent       from XmlObjMgt,
+    MessageDriver    from CDM,
+    Attribute        from TDF
+
+is
+    Create (theMessageDriver:MessageDriver from CDM)
+        returns mutable VariableDriver from XmlMDataStd;
+
+    NewEmpty (me)  returns mutable Attribute from TDF;
+
+    Paste(me; Source     : Persistent from XmlObjMgt;
+              Target     : mutable Attribute from TDF;
+              RelocTable : out RRelocationTable from XmlObjMgt)
+        returns Boolean from Standard;
+
+    Paste(me; Source     : Attribute from TDF;
+              Target     : in out Persistent from XmlObjMgt;
+              RelocTable : out SRelocationTable from XmlObjMgt);
+
+end VariableDriver;

src/XmlMDataStd/XmlMDataStd_VariableDriver.cxx

@@ -0,0 +1,64 @@
+// File:        XmlMDataStd_VariableDriver.cxx
+// Created:     Fri Aug 24 20:46:58 2001
+// Author:      Alexnder GRIGORIEV
+// Copyright:   Open Cascade 2001
+// History:
+
+#include <XmlMDataStd_VariableDriver.ixx>
+#include <TDataStd_Variable.hxx>
+
+IMPLEMENT_DOMSTRING (IsConstString, "isconst")
+IMPLEMENT_DOMSTRING (UnitString,    "unit")
+IMPLEMENT_DOMSTRING (ConstString,   "true")
+
+//=======================================================================
+//function : XmlMDataStd_VariableDriver
+//purpose  : Constructor
+//=======================================================================
+XmlMDataStd_VariableDriver::XmlMDataStd_VariableDriver
+                        (const Handle(CDM_MessageDriver)& theMsgDriver)
+      : XmlMDF_ADriver (theMsgDriver, NULL)
+{}
+
+//=======================================================================
+//function : NewEmpty
+//purpose  : 
+//=======================================================================
+Handle(TDF_Attribute) XmlMDataStd_VariableDriver::NewEmpty() const
+{
+  return (new TDataStd_Variable());
+}
+
+//=======================================================================
+//function : Paste
+//purpose  : 
+//=======================================================================
+Standard_Boolean XmlMDataStd_VariableDriver::Paste
+                                (const XmlObjMgt_Persistent&  theSource,
+                                 const Handle(TDF_Attribute)& theTarget,
+                                 XmlObjMgt_RRelocationTable&  ) const
+{
+  Handle(TDataStd_Variable) aV = Handle(TDataStd_Variable)::DownCast(theTarget);
+  
+  XmlObjMgt_DOMString aStr =
+    theSource.Element().getAttribute(::IsConstString());
+  aV->Constant (aStr != NULL);
+
+  aStr = theSource.Element().getAttribute(::UnitString());
+  aV->Unit(aStr);
+  return Standard_True;
+}
+
+//=======================================================================
+//function : Paste
+//purpose  : 
+//=======================================================================
+void XmlMDataStd_VariableDriver::Paste (const Handle(TDF_Attribute)& theSource,
+                                        XmlObjMgt_Persistent&        theTarget,
+                                        XmlObjMgt_SRelocationTable&  ) const
+{
+  Handle(TDataStd_Variable) aV = Handle(TDataStd_Variable)::DownCast(theSource);
+  if (aV->IsConstant())
+    theTarget.Element().setAttribute (::IsConstString(), ::ConstString());
+  theTarget.Element().setAttribute(::UnitString(), aV->Unit().ToCString());
+}