0027970: Improvement of standard attributes usability - containers.
authorszy <szy@opencascade.com>
Thu, 11 May 2017 14:37:44 +0000 (17:37 +0300)
committerbugmaster <bugmaster@opencascade.com>
Fri, 26 May 2017 11:48:53 +0000 (14:48 +0300)
111 files changed:
src/BinMDataStd/BinMDataStd.hxx
src/BinMDataStd/BinMDataStd_BooleanArrayDriver.cxx
src/BinMDataStd/BinMDataStd_BooleanListDriver.cxx
src/BinMDataStd/BinMDataStd_ByteArrayDriver.cxx
src/BinMDataStd/BinMDataStd_ExtStringArrayDriver.cxx
src/BinMDataStd/BinMDataStd_ExtStringListDriver.cxx
src/BinMDataStd/BinMDataStd_IntegerArrayDriver.cxx
src/BinMDataStd/BinMDataStd_IntegerListDriver.cxx
src/BinMDataStd/BinMDataStd_RealArrayDriver.cxx
src/BinMDataStd/BinMDataStd_RealListDriver.cxx
src/BinMDataStd/BinMDataStd_ReferenceArrayDriver.cxx
src/BinMDataStd/BinMDataStd_ReferenceListDriver.cxx
src/DDataStd/DDataStd_BasicCommands.cxx
src/Standard/Standard.hxx
src/Standard/Standard_GUID.hxx
src/StdLPersistent/StdLPersistent_Data.cxx
src/TDF/TDF_Attribute.hxx
src/TDF/TDF_Attribute.lxx
src/TDF/TDF_CopyTool.cxx
src/TDataStd/TDataStd_AsciiString.cxx
src/TDataStd/TDataStd_AsciiString.hxx
src/TDataStd/TDataStd_BooleanArray.cxx
src/TDataStd/TDataStd_BooleanArray.hxx
src/TDataStd/TDataStd_BooleanList.cxx
src/TDataStd/TDataStd_BooleanList.hxx
src/TDataStd/TDataStd_ByteArray.cxx
src/TDataStd/TDataStd_ByteArray.hxx
src/TDataStd/TDataStd_ExtStringArray.cxx
src/TDataStd/TDataStd_ExtStringArray.hxx
src/TDataStd/TDataStd_ExtStringList.cxx
src/TDataStd/TDataStd_ExtStringList.hxx
src/TDataStd/TDataStd_Integer.cxx
src/TDataStd/TDataStd_Integer.hxx
src/TDataStd/TDataStd_IntegerArray.cxx
src/TDataStd/TDataStd_IntegerArray.hxx
src/TDataStd/TDataStd_IntegerList.cxx
src/TDataStd/TDataStd_IntegerList.hxx
src/TDataStd/TDataStd_Name.cxx
src/TDataStd/TDataStd_Name.hxx
src/TDataStd/TDataStd_Real.cxx
src/TDataStd/TDataStd_Real.hxx
src/TDataStd/TDataStd_RealArray.cxx
src/TDataStd/TDataStd_RealArray.hxx
src/TDataStd/TDataStd_RealList.cxx
src/TDataStd/TDataStd_RealList.hxx
src/TDataStd/TDataStd_ReferenceArray.cxx
src/TDataStd/TDataStd_ReferenceArray.hxx
src/TDataStd/TDataStd_ReferenceList.cxx
src/TDataStd/TDataStd_ReferenceList.hxx
src/TDataStd/TDataStd_UAttribute.hxx
src/XCAFDoc/XCAFDoc_Datum.cxx
src/XCAFDoc/XCAFDoc_Dimension.cxx
src/XCAFDoc/XCAFDoc_GeomTolerance.cxx
src/XmlMDataStd/XmlMDataStd_BooleanArrayDriver.cxx
src/XmlMDataStd/XmlMDataStd_BooleanListDriver.cxx
src/XmlMDataStd/XmlMDataStd_ByteArrayDriver.cxx
src/XmlMDataStd/XmlMDataStd_ExtStringArrayDriver.cxx
src/XmlMDataStd/XmlMDataStd_ExtStringListDriver.cxx
src/XmlMDataStd/XmlMDataStd_IntegerArrayDriver.cxx
src/XmlMDataStd/XmlMDataStd_IntegerListDriver.cxx
src/XmlMDataStd/XmlMDataStd_RealArrayDriver.cxx
src/XmlMDataStd/XmlMDataStd_RealListDriver.cxx
src/XmlMDataStd/XmlMDataStd_ReferenceArrayDriver.cxx
src/XmlMDataStd/XmlMDataStd_ReferenceListDriver.cxx
tests/bugs/caf/bug2932_2
tests/caf/basic/C4 [new file with mode: 0644]
tests/caf/basic/C5 [new file with mode: 0644]
tests/caf/basic/C6 [new file with mode: 0644]
tests/caf/basic/D4 [new file with mode: 0644]
tests/caf/basic/D5 [new file with mode: 0644]
tests/caf/basic/D6 [new file with mode: 0644]
tests/caf/basic/D7 [new file with mode: 0644]
tests/caf/basic/M5 [new file with mode: 0644]
tests/caf/basic/M6 [new file with mode: 0644]
tests/caf/basic/M7 [new file with mode: 0644]
tests/caf/basic/O5 [new file with mode: 0644]
tests/caf/basic/O6 [new file with mode: 0644]
tests/caf/basic/O7 [new file with mode: 0644]
tests/caf/basic/P5 [new file with mode: 0644]
tests/caf/basic/P6 [new file with mode: 0644]
tests/caf/basic/P7 [new file with mode: 0644]
tests/caf/basic/Q5 [new file with mode: 0644]
tests/caf/basic/Q6 [new file with mode: 0644]
tests/caf/basic/Q7 [new file with mode: 0644]
tests/caf/basic/R5 [new file with mode: 0644]
tests/caf/basic/R6 [new file with mode: 0644]
tests/caf/basic/R7 [new file with mode: 0644]
tests/caf/basic/S5 [new file with mode: 0644]
tests/caf/basic/S6 [new file with mode: 0644]
tests/caf/basic/S7 [new file with mode: 0644]
tests/caf/basic/T5 [new file with mode: 0644]
tests/caf/basic/T6 [new file with mode: 0644]
tests/caf/basic/T7 [new file with mode: 0644]
tests/caf/basic/U5 [new file with mode: 0644]
tests/caf/basic/U6 [new file with mode: 0644]
tests/caf/basic/U7 [new file with mode: 0644]
tests/caf/basic/V5 [new file with mode: 0644]
tests/caf/basic/V6 [new file with mode: 0644]
tests/caf/basic/V7 [new file with mode: 0644]
tests/caf/basic/W1 [new file with mode: 0644]
tests/caf/basic/W10 [new file with mode: 0644]
tests/caf/basic/W11 [new file with mode: 0644]
tests/caf/basic/W2 [new file with mode: 0644]
tests/caf/basic/W3 [new file with mode: 0644]
tests/caf/basic/W4 [new file with mode: 0644]
tests/caf/basic/W5 [new file with mode: 0644]
tests/caf/basic/W6 [new file with mode: 0644]
tests/caf/basic/W7 [new file with mode: 0644]
tests/caf/basic/W8 [new file with mode: 0644]
tests/caf/basic/W9 [new file with mode: 0644]
tests/caf/bugs/D1

index 245c292..bef76cf 100644 (file)
 #ifndef _BinMDataStd_HeaderFile
 #define _BinMDataStd_HeaderFile
 
-#include <Standard.hxx>
+#include <Standard_GUID.hxx>
 #include <Standard_DefineAlloc.hxx>
 #include <Standard_Handle.hxx>
 
 #include <Standard_Integer.hxx>
+#include <BinObjMgt_Persistent.hxx>
+
 class BinMDF_ADriverTable;
 class CDM_MessageDriver;
 class BinMDataStd_NameDriver;
@@ -50,7 +52,6 @@ class BinMDataStd_ReferenceArrayDriver;
 class BinMDataStd_ByteArrayDriver;
 class BinMDataStd_NamedDataDriver;
 
-
 //! Storage and Retrieval drivers for modelling attributes.
 class BinMDataStd 
 {
@@ -66,7 +67,24 @@ public:
   
   Standard_EXPORT static Standard_Integer DocumentVersion();
 
-
+template<class T>
+static void SetAttributeID(const BinObjMgt_Persistent& theSource, const Handle(T)& anAtt)
+{
+  Standard_Boolean ok = Standard_True;
+  if(BinMDataStd::DocumentVersion() > 9) { // process user defined guid
+    const Standard_Integer& aPos = theSource.Position();
+    Standard_GUID aGuid;
+    ok = theSource >> aGuid;
+    if (!ok) {
+      theSource.SetPosition(aPos);
+      anAtt->SetID(T::GetID());
+      ok = Standard_True;
+    } else {
+      anAtt->SetID(aGuid);
+    }
+  } else
+    anAtt->SetID(T::GetID());
+}
 
 
 protected:
index 0067cbd..7bddede 100644 (file)
@@ -15,6 +15,7 @@
 
 
 #include <BinMDataStd_BooleanArrayDriver.hxx>
+#include <BinMDataStd.hxx>
 #include <BinObjMgt_Persistent.hxx>
 #include <CDM_MessageDriver.hxx>
 #include <Standard_Type.hxx>
@@ -49,8 +50,8 @@ Handle(TDF_Attribute) BinMDataStd_BooleanArrayDriver::NewEmpty() const
 //purpose  : persistent -> transient (retrieve)
 //=======================================================================
 Standard_Boolean BinMDataStd_BooleanArrayDriver::Paste(const BinObjMgt_Persistent&  theSource,
-                                                      const Handle(TDF_Attribute)& theTarget,
-                                                      BinObjMgt_RRelocationTable&  ) const
+                                                       const Handle(TDF_Attribute)& theTarget,
+                                                       BinObjMgt_RRelocationTable&  ) const
 {
   Standard_Integer aFirstInd, aLastInd;
   if (! (theSource >> aFirstInd >> aLastInd))
@@ -61,7 +62,7 @@ Standard_Boolean BinMDataStd_BooleanArrayDriver::Paste(const BinObjMgt_Persisten
   TColStd_Array1OfByte aTargetArray(0, (aLastInd - aFirstInd + 1) >> 3);
   theSource.GetByteArray (&aTargetArray(0), aTargetArray.Length());
 
-  Handle(TDataStd_BooleanArray) anAtt = Handle(TDataStd_BooleanArray)::DownCast(theTarget);
+  const Handle(TDataStd_BooleanArray) anAtt = Handle(TDataStd_BooleanArray)::DownCast(theTarget);
   anAtt->Init(aFirstInd, aLastInd);
   Handle(TColStd_HArray1OfByte) bytes = new TColStd_HArray1OfByte(aTargetArray.Lower(), aTargetArray.Upper());
   Standard_Integer lower = bytes->Lower(), i = lower, upper = bytes->Upper();
@@ -70,6 +71,7 @@ Standard_Boolean BinMDataStd_BooleanArrayDriver::Paste(const BinObjMgt_Persisten
     bytes->SetValue(i, aTargetArray.Value(i));
   }
   anAtt->SetInternalArray(bytes);
+  BinMDataStd::SetAttributeID(theSource, anAtt);
   return Standard_True;
 }
 
@@ -78,8 +80,8 @@ Standard_Boolean BinMDataStd_BooleanArrayDriver::Paste(const BinObjMgt_Persisten
 //purpose  : transient -> persistent (store)
 //=======================================================================
 void BinMDataStd_BooleanArrayDriver::Paste(const Handle(TDF_Attribute)& theSource,
-                                          BinObjMgt_Persistent&        theTarget,
-                                          BinObjMgt_SRelocationTable&  ) const
+                                           BinObjMgt_Persistent&        theTarget,
+                                           BinObjMgt_SRelocationTable&  ) const
 {
   Handle(TDataStd_BooleanArray) anAtt = Handle(TDataStd_BooleanArray)::DownCast(theSource);
   const Standard_Integer aFirstInd = anAtt->Lower();
@@ -97,4 +99,8 @@ void BinMDataStd_BooleanArrayDriver::Paste(const Handle(TDF_Attribute)& theSourc
   }
   Standard_Byte *aPtr = (Standard_Byte *) &aSourceArray(lower);
   theTarget.PutByteArray(aPtr, upper - lower + 1);
+
+  // process user defined guid
+  if(anAtt->ID() != TDataStd_BooleanArray::GetID()) 
+    theTarget << anAtt->ID();
 }
index 62960ce..974ed9e 100644 (file)
@@ -15,6 +15,7 @@
 
 
 #include <BinMDataStd_BooleanListDriver.hxx>
+#include <BinMDataStd.hxx>
 #include <BinObjMgt_Persistent.hxx>
 #include <CDM_MessageDriver.hxx>
 #include <Standard_Type.hxx>
@@ -49,25 +50,28 @@ Handle(TDF_Attribute) BinMDataStd_BooleanListDriver::NewEmpty() const
 //purpose  : persistent -> transient (retrieve)
 //=======================================================================
 Standard_Boolean BinMDataStd_BooleanListDriver::Paste(const BinObjMgt_Persistent&  theSource,
-                                                     const Handle(TDF_Attribute)& theTarget,
-                                                     BinObjMgt_RRelocationTable&  ) const
+                                                      const Handle(TDF_Attribute)& theTarget,
+                                                      BinObjMgt_RRelocationTable&  ) const
 {
   Standard_Integer aIndex, aFirstInd, aLastInd;
   if (! (theSource >> aFirstInd >> aLastInd))
     return Standard_False;
-  if(aLastInd == 0) return Standard_True;
-
-  const Standard_Integer aLength = aLastInd - aFirstInd + 1;
-  if (aLength <= 0)
-    return Standard_False;
-  TColStd_Array1OfByte aTargetArray(aFirstInd, aLastInd);
-  theSource.GetByteArray (&aTargetArray(aFirstInd), aLength);
 
   const Handle(TDataStd_BooleanList) anAtt = Handle(TDataStd_BooleanList)::DownCast(theTarget);
-  for (aIndex = aFirstInd; aIndex <= aLastInd; aIndex++)
-  {
-    anAtt->Append(aTargetArray.Value(aIndex) ? Standard_True : Standard_False);
+  if(aLastInd > 0) {
+
+    const Standard_Integer aLength = aLastInd - aFirstInd + 1;
+    if (aLength > 0) {    
+      TColStd_Array1OfByte aTargetArray(aFirstInd, aLastInd);
+      theSource.GetByteArray (&aTargetArray(aFirstInd), aLength);
+      for (aIndex = aFirstInd; aIndex <= aLastInd; aIndex++)
+      {
+        anAtt->Append(aTargetArray.Value(aIndex) ? Standard_True : Standard_False);
+      }
+    }
   }
+
+  BinMDataStd::SetAttributeID(theSource, anAtt);
   return Standard_True;
 }
 
@@ -93,4 +97,8 @@ void BinMDataStd_BooleanListDriver::Paste(const Handle(TDF_Attribute)& theSource
   }
   Standard_Byte *aPtr = (Standard_Byte *) &aSourceArray(aFirstInd);
   theTarget.PutByteArray(aPtr, aLength);
-}
+
+  // process user defined guid
+  if(anAtt->ID() != TDataStd_BooleanList::GetID()) 
+    theTarget << anAtt->ID();
+}
\ No newline at end of file
index 832d60f..2651f19 100644 (file)
@@ -50,8 +50,8 @@ Handle(TDF_Attribute) BinMDataStd_ByteArrayDriver::NewEmpty() const
 //purpose  : persistent -> transient (retrieve)
 //=======================================================================
 Standard_Boolean BinMDataStd_ByteArrayDriver::Paste(const BinObjMgt_Persistent&  theSource,
-                                                   const Handle(TDF_Attribute)& theTarget,
-                                                   BinObjMgt_RRelocationTable&  ) const
+                                                    const Handle(TDF_Attribute)& theTarget,
+                                                    BinObjMgt_RRelocationTable&  ) const
 {
   Standard_Integer aFirstInd, aLastInd;
   if (! (theSource >> aFirstInd >> aLastInd))
@@ -62,7 +62,7 @@ Standard_Boolean BinMDataStd_ByteArrayDriver::Paste(const BinObjMgt_Persistent&
   TColStd_Array1OfByte aTargetArray(aFirstInd, aLastInd);
   theSource.GetByteArray (&aTargetArray(aFirstInd), aTargetArray.Length());
 
-  Handle(TDataStd_ByteArray) anAtt = Handle(TDataStd_ByteArray)::DownCast(theTarget);
+  const Handle(TDataStd_ByteArray) anAtt = Handle(TDataStd_ByteArray)::DownCast(theTarget);
   Handle(TColStd_HArray1OfByte) bytes = new TColStd_HArray1OfByte(aFirstInd, aLastInd);
   for (Standard_Integer i = aFirstInd; i <= aLastInd; i++)
   {
@@ -79,6 +79,8 @@ Standard_Boolean BinMDataStd_ByteArrayDriver::Paste(const BinObjMgt_Persistent&
       aDelta = (aDeltaValue != 0);
   }
   anAtt->SetDelta(aDelta);
+
+  BinMDataStd::SetAttributeID(theSource, anAtt);
   return Standard_True;
 }
 
@@ -87,8 +89,8 @@ Standard_Boolean BinMDataStd_ByteArrayDriver::Paste(const BinObjMgt_Persistent&
 //purpose  : transient -> persistent (store)
 //=======================================================================
 void BinMDataStd_ByteArrayDriver::Paste(const Handle(TDF_Attribute)& theSource,
-                                       BinObjMgt_Persistent&        theTarget,
-                                       BinObjMgt_SRelocationTable&  ) const
+                                        BinObjMgt_Persistent&        theTarget,
+                                        BinObjMgt_SRelocationTable&  ) const
 {
   Handle(TDataStd_ByteArray) anAtt = Handle(TDataStd_ByteArray)::DownCast(theSource);
   const Standard_Integer aFirstInd = anAtt->Lower();
@@ -107,4 +109,8 @@ void BinMDataStd_ByteArrayDriver::Paste(const Handle(TDF_Attribute)& theSource,
   Standard_Byte *aPtr = (Standard_Byte *) &aSourceArray(lower);
   theTarget.PutByteArray(aPtr, bytes->Length());
   theTarget << (Standard_Byte)(anAtt->GetDelta() ? 1 : 0);
+  
+  // process user defined guid
+  if(anAtt->ID() != TDataStd_ByteArray::GetID()) 
+    theTarget << anAtt->ID();
 }
index 77ebe60..e208f8a 100644 (file)
@@ -83,14 +83,16 @@ Standard_Boolean BinMDataStd_ExtStringArrayDriver::Paste
     Standard_Boolean aDelta(Standard_False);
     if(BinMDataStd::DocumentVersion() > 2) {
       Standard_Byte aDeltaValue;
-         if (! (theSource >> aDeltaValue)) {
-           return Standard_False;
-         }
+      if (! (theSource >> aDeltaValue)) {
+        return Standard_False;
+      }
       else
-       aDelta = (aDeltaValue != 0);
-       }
+        aDelta = (aDeltaValue != 0);
+    }
     anAtt->SetDelta(aDelta);
   }
+
+  BinMDataStd::SetAttributeID(theSource, anAtt);
   return ok;
 }
 
@@ -104,7 +106,7 @@ void BinMDataStd_ExtStringArrayDriver::Paste
                                  BinObjMgt_Persistent&        theTarget,
                                  BinObjMgt_SRelocationTable&  ) const
 {
-  Handle(TDataStd_ExtStringArray) anAtt =
+  const Handle(TDataStd_ExtStringArray) anAtt =
     Handle(TDataStd_ExtStringArray)::DownCast(theSource);
   const TColStd_Array1OfExtendedString& aSourceArray = anAtt->Array()->Array1();
   const Standard_Integer aFirstInd = aSourceArray.Lower();
@@ -114,4 +116,8 @@ void BinMDataStd_ExtStringArrayDriver::Paste
     theTarget << anAtt->Value( i );
 
   theTarget << (Standard_Byte)(anAtt->GetDelta() ? 1 : 0);
+
+  // process user defined guid
+  if(anAtt->ID() != TDataStd_ExtStringArray::GetID()) 
+    theTarget << anAtt->ID();
 }
index 1027c6b..1df2237 100644 (file)
@@ -15,6 +15,7 @@
 
 
 #include <BinMDataStd_ExtStringListDriver.hxx>
+#include <BinMDataStd.hxx>
 #include <BinObjMgt_Persistent.hxx>
 #include <CDM_MessageDriver.hxx>
 #include <Standard_Type.hxx>
@@ -56,22 +57,24 @@ Standard_Boolean BinMDataStd_ExtStringListDriver::Paste
   Standard_Integer aFirstInd, aLastInd;
   if (! (theSource >> aFirstInd >> aLastInd))
     return Standard_False;
-  if(aLastInd == 0) return Standard_True;
-  const Standard_Integer aLength = aLastInd - aFirstInd + 1;
-  if (aLength <= 0)
-    return Standard_False;
-  const Handle(TDataStd_ExtStringList) anAtt =
-    Handle(TDataStd_ExtStringList)::DownCast(theTarget);
-  for (Standard_Integer i = aFirstInd; i <= aLastInd; i ++)
-  {
-    TCollection_ExtendedString aStr;
-    if ( !(theSource >> aStr) )
-    {
+
+  const Handle(TDataStd_ExtStringList) anAtt = Handle(TDataStd_ExtStringList)::DownCast(theTarget);
+  if(aLastInd > 0) {
+    const Standard_Integer aLength = aLastInd - aFirstInd + 1;
+    if (aLength <= 0)
       return Standard_False;
+    for (Standard_Integer i = aFirstInd; i <= aLastInd; i ++)
+    {
+      TCollection_ExtendedString aStr;
+      if ( !(theSource >> aStr) )
+      {
+        return Standard_False;
+      }
+      anAtt->Append(aStr);
     }
-    anAtt->Append(aStr);
   }
 
+  BinMDataStd::SetAttributeID(theSource, anAtt);
   return Standard_True;
 }
 
@@ -94,4 +97,8 @@ void BinMDataStd_ExtStringListDriver::Paste
   {
     theTarget << itr.Value();
   }
+
+  // process user defined guid
+  if(anAtt->ID() != TDataStd_ExtStringList::GetID()) 
+    theTarget << anAtt->ID();
 }
index 93ac3e5..29f44e5 100644 (file)
@@ -62,7 +62,7 @@ Standard_Boolean BinMDataStd_IntegerArrayDriver::Paste
   if (aLength <= 0)
     return Standard_False;
 
-  Handle(TDataStd_IntegerArray) anAtt =
+  const Handle(TDataStd_IntegerArray) anAtt =
     Handle(TDataStd_IntegerArray)::DownCast(theTarget);
   anAtt->Init(aFirstInd, aLastInd);
   TColStd_Array1OfInteger& aTargetArray = anAtt->Array()->ChangeArray1();
@@ -81,6 +81,8 @@ Standard_Boolean BinMDataStd_IntegerArrayDriver::Paste
     cout << "Current DocVersion field is not initialized. "  <<endl;
 #endif
   anAtt->SetDelta(aDelta);
+
+  BinMDataStd::SetAttributeID(theSource, anAtt);
   return Standard_True; 
 }
 
@@ -104,4 +106,8 @@ void BinMDataStd_IntegerArrayDriver::Paste
   Standard_Integer *aPtr = (Standard_Integer *) &aSourceArray(aFirstInd);
   theTarget.PutIntArray (aPtr, aLength);
   theTarget << (Standard_Byte)(anAtt->GetDelta() ? 1 : 0);
+
+  // process user defined guid
+  if(anAtt->ID() != TDataStd_IntegerArray::GetID()) 
+    theTarget << anAtt->ID();
 }
index ad0edaf..6945304 100644 (file)
@@ -15,6 +15,7 @@
 
 
 #include <BinMDataStd_IntegerListDriver.hxx>
+#include <BinMDataStd.hxx>
 #include <BinObjMgt_Persistent.hxx>
 #include <CDM_MessageDriver.hxx>
 #include <Standard_Type.hxx>
@@ -49,26 +50,24 @@ Handle(TDF_Attribute) BinMDataStd_IntegerListDriver::NewEmpty() const
 //purpose  : persistent -> transient (retrieve)
 //=======================================================================
 Standard_Boolean BinMDataStd_IntegerListDriver::Paste(const BinObjMgt_Persistent&  theSource,
-                                                     const Handle(TDF_Attribute)& theTarget,
-                                                     BinObjMgt_RRelocationTable&  ) const
+                                                      const Handle(TDF_Attribute)& theTarget,
+                                                      BinObjMgt_RRelocationTable&  ) const
 {
   Standard_Integer aIndex, aFirstInd, aLastInd;
   if (! (theSource >> aFirstInd >> aLastInd))
     return Standard_False;
-  if(aLastInd == 0) return Standard_True;
-
-  const Standard_Integer aLength = aLastInd - aFirstInd + 1;
-  if (aLength <= 0)
-    return Standard_False;
-
-  TColStd_Array1OfInteger aTargetArray(aFirstInd, aLastInd);
-  theSource.GetIntArray (&aTargetArray(aFirstInd), aLength);
-
   const Handle(TDataStd_IntegerList) anAtt = Handle(TDataStd_IntegerList)::DownCast(theTarget);
-  for (aIndex = aFirstInd; aIndex <= aLastInd; aIndex++)
-  {
-    anAtt->Append(aTargetArray.Value(aIndex));
+  if(aLastInd > 0) {
+    const Standard_Integer aLength = aLastInd - aFirstInd + 1;
+    if (aLength > 0) {
+      TColStd_Array1OfInteger aTargetArray(aFirstInd, aLastInd);
+      theSource.GetIntArray (&aTargetArray(aFirstInd), aLength);
+      for (aIndex = aFirstInd; aIndex <= aLastInd; aIndex++)  
+        anAtt->Append(aTargetArray.Value(aIndex));
+    }
   }
+
+  BinMDataStd::SetAttributeID(theSource, anAtt);
   return Standard_True;
 }
 
@@ -99,4 +98,8 @@ void BinMDataStd_IntegerListDriver::Paste(const Handle(TDF_Attribute)& theSource
     Standard_Integer *aPtr = (Standard_Integer *) &aSourceArray(aFirstInd);
     theTarget.PutIntArray(aPtr, aLength);
   }
+
+  // process user defined guid
+  if(anAtt->ID() != TDataStd_IntegerList::GetID()) 
+       theTarget << anAtt->ID();
 }
index 9346b5e..b0eafdb 100644 (file)
@@ -62,7 +62,7 @@ Standard_Boolean BinMDataStd_RealArrayDriver::Paste
   if (aLength <= 0)
     return Standard_False;
 
-  Handle(TDataStd_RealArray) anAtt =
+  const Handle(TDataStd_RealArray) anAtt =
     Handle(TDataStd_RealArray)::DownCast(theTarget);
   anAtt->Init(aFirstInd, aLastInd);
   TColStd_Array1OfReal& aTargetArray = anAtt->Array()->ChangeArray1();
@@ -78,6 +78,8 @@ Standard_Boolean BinMDataStd_RealArrayDriver::Paste
       aDelta = (aDeltaValue != 0);
   }
   anAtt->SetDelta(aDelta);
+
+  BinMDataStd::SetAttributeID(theSource, anAtt);
   return Standard_True; 
 }
 
@@ -101,4 +103,7 @@ void BinMDataStd_RealArrayDriver::Paste
   Standard_Real *aPtr = (Standard_Real *) &aSourceArray(aFirstInd);
   theTarget.PutRealArray (aPtr, aLength);
   theTarget << (Standard_Byte)(anAtt->GetDelta() ? 1 : 0);
+  // process user defined guid
+  if(anAtt->ID() != TDataStd_RealArray::GetID()) 
+    theTarget << anAtt->ID();
 }
index 9ea3139..957ca3e 100644 (file)
@@ -15,6 +15,7 @@
 
 
 #include <BinMDataStd_RealListDriver.hxx>
+#include <BinMDataStd.hxx>
 #include <BinObjMgt_Persistent.hxx>
 #include <CDM_MessageDriver.hxx>
 #include <Standard_Type.hxx>
@@ -49,26 +50,25 @@ Handle(TDF_Attribute) BinMDataStd_RealListDriver::NewEmpty() const
 //purpose  : persistent -> transient (retrieve)
 //=======================================================================
 Standard_Boolean BinMDataStd_RealListDriver::Paste(const BinObjMgt_Persistent&  theSource,
-                                                  const Handle(TDF_Attribute)& theTarget,
-                                                  BinObjMgt_RRelocationTable&  ) const
+                                                   const Handle(TDF_Attribute)& theTarget,
+                                                   BinObjMgt_RRelocationTable&  ) const
 {
   Standard_Integer aIndex, aFirstInd, aLastInd;
   if (! (theSource >> aFirstInd >> aLastInd))
     return Standard_False;
-  if(aLastInd == 0) return Standard_True;
-
-  const Standard_Integer aLength = aLastInd - aFirstInd + 1;
-  if (aLength <= 0)
-    return Standard_False;
-
-  TColStd_Array1OfReal aTargetArray(aFirstInd, aLastInd);
-  theSource.GetRealArray (&aTargetArray(aFirstInd), aLength);
 
   const Handle(TDataStd_RealList) anAtt = Handle(TDataStd_RealList)::DownCast(theTarget);
-  for (aIndex = aFirstInd; aIndex <= aLastInd; aIndex++)
-  {
-    anAtt->Append(aTargetArray.Value(aIndex));
+  if(aLastInd > 0) {
+    const Standard_Integer aLength = aLastInd - aFirstInd + 1;
+    if (aLength > 0) {    
+      TColStd_Array1OfReal aTargetArray(aFirstInd, aLastInd);
+      theSource.GetRealArray (&aTargetArray(aFirstInd), aLength);
+      for (aIndex = aFirstInd; aIndex <= aLastInd; aIndex++)
+        anAtt->Append(aTargetArray.Value(aIndex));  
+    }
   }
+
+  BinMDataStd::SetAttributeID(theSource, anAtt);
   return Standard_True;
 }
 
@@ -77,8 +77,8 @@ Standard_Boolean BinMDataStd_RealListDriver::Paste(const BinObjMgt_Persistent&
 //purpose  : transient -> persistent (store)
 //=======================================================================
 void BinMDataStd_RealListDriver::Paste(const Handle(TDF_Attribute)& theSource,
-                                      BinObjMgt_Persistent&        theTarget,
-                                      BinObjMgt_SRelocationTable&  ) const
+                                       BinObjMgt_Persistent&        theTarget,
+                                       BinObjMgt_SRelocationTable&  ) const
 {
   const Handle(TDataStd_RealList) anAtt = Handle(TDataStd_RealList)::DownCast(theSource);
   const Standard_Integer aFirstInd = (anAtt->Extent()> 0) ? 1 : 0;
@@ -99,4 +99,8 @@ void BinMDataStd_RealListDriver::Paste(const Handle(TDF_Attribute)& theSource,
     Standard_Real *aPtr = (Standard_Real *) &aSourceArray(aFirstInd);
     theTarget.PutRealArray(aPtr, aLength);
   }
+
+  // process user defined guid
+  if(anAtt->ID() != TDataStd_RealList::GetID()) 
+    theTarget << anAtt->ID();
 }
index 1717316..57b2490 100644 (file)
@@ -15,6 +15,7 @@
 
 
 #include <BinMDataStd_ReferenceArrayDriver.hxx>
+#include <BinMDataStd.hxx>
 #include <BinObjMgt_Persistent.hxx>
 #include <CDM_MessageDriver.hxx>
 #include <Standard_Type.hxx>
@@ -49,8 +50,8 @@ Handle(TDF_Attribute) BinMDataStd_ReferenceArrayDriver::NewEmpty() const
 //purpose  : persistent -> transient (retrieve)
 //=======================================================================
 Standard_Boolean BinMDataStd_ReferenceArrayDriver::Paste(const BinObjMgt_Persistent&  theSource,
-                                                        const Handle(TDF_Attribute)& theTarget,
-                                                        BinObjMgt_RRelocationTable&  ) const
+                                                         const Handle(TDF_Attribute)& theTarget,
+                                                         BinObjMgt_RRelocationTable&  ) const
 {
   Standard_Integer aFirstInd, aLastInd;
   if (! (theSource >> aFirstInd >> aLastInd))
@@ -59,7 +60,7 @@ Standard_Boolean BinMDataStd_ReferenceArrayDriver::Paste(const BinObjMgt_Persist
   if (aLength <= 0)
     return Standard_False;
 
-  Handle(TDataStd_ReferenceArray) anAtt = Handle(TDataStd_ReferenceArray)::DownCast(theTarget);
+  const Handle(TDataStd_ReferenceArray) anAtt = Handle(TDataStd_ReferenceArray)::DownCast(theTarget);
   anAtt->Init(aFirstInd, aLastInd);
   for (Standard_Integer i = aFirstInd; i <= aLastInd; i++)
   {
@@ -72,6 +73,7 @@ Standard_Boolean BinMDataStd_ReferenceArrayDriver::Paste(const BinObjMgt_Persist
       anAtt->SetValue(i, L);
   }
 
+  BinMDataStd::SetAttributeID(theSource, anAtt);
   return Standard_True;
 }
 
@@ -80,8 +82,8 @@ Standard_Boolean BinMDataStd_ReferenceArrayDriver::Paste(const BinObjMgt_Persist
 //purpose  : transient -> persistent (store)
 //=======================================================================
 void BinMDataStd_ReferenceArrayDriver::Paste(const Handle(TDF_Attribute)& theSource,
-                                            BinObjMgt_Persistent&        theTarget,
-                                            BinObjMgt_SRelocationTable&  ) const
+                                             BinObjMgt_Persistent&        theTarget,
+                                             BinObjMgt_SRelocationTable&  ) const
 {
   Handle(TDataStd_ReferenceArray) anAtt = Handle(TDataStd_ReferenceArray)::DownCast(theSource);
   Standard_Integer aFirstInd = anAtt->Lower(), aLastInd = anAtt->Upper(), i = aFirstInd;
@@ -98,4 +100,8 @@ void BinMDataStd_ReferenceArrayDriver::Paste(const Handle(TDF_Attribute)& theSou
       theTarget << entry;
     }
   }
+
+  // process user defined guid
+  if(anAtt->ID() != TDataStd_ReferenceArray::GetID()) 
+    theTarget << anAtt->ID();
 }
index 50b7edf..3f43858 100644 (file)
@@ -15,6 +15,7 @@
 
 
 #include <BinMDataStd_ReferenceListDriver.hxx>
+#include <BinMDataStd.hxx>
 #include <BinObjMgt_Persistent.hxx>
 #include <CDM_MessageDriver.hxx>
 #include <Standard_Type.hxx>
@@ -50,30 +51,32 @@ Handle(TDF_Attribute) BinMDataStd_ReferenceListDriver::NewEmpty() const
 //purpose  : persistent -> transient (retrieve)
 //=======================================================================
 Standard_Boolean BinMDataStd_ReferenceListDriver::Paste(const BinObjMgt_Persistent&  theSource,
-                                                       const Handle(TDF_Attribute)& theTarget,
-                                                       BinObjMgt_RRelocationTable&  ) const
+                                                        const Handle(TDF_Attribute)& theTarget,
+                                                        BinObjMgt_RRelocationTable&  ) const
 {
   Standard_Integer aFirstInd, aLastInd;
   if (! (theSource >> aFirstInd >> aLastInd))
     return Standard_False;
-  if(aLastInd == 0) return Standard_True;
-
-  const Standard_Integer aLength = aLastInd - aFirstInd + 1;
-  if (aLength <= 0)
-    return Standard_False;
 
   const Handle(TDataStd_ReferenceList) anAtt = Handle(TDataStd_ReferenceList)::DownCast(theTarget);
-  for (Standard_Integer i = aFirstInd; i <= aLastInd; i++)
-  {
-    TCollection_AsciiString entry;
-    if ( !(theSource >> entry) )
+  if(aLastInd > 0) {
+
+    const Standard_Integer aLength = aLastInd - aFirstInd + 1;
+    if (aLength <= 0)
       return Standard_False;
-    TDF_Label L;
-    TDF_Tool::Label(anAtt->Label().Data(), entry, L, Standard_True);
-    if (!L.IsNull())
-      anAtt->Append(L);
+    for (Standard_Integer i = aFirstInd; i <= aLastInd; i++)
+    {
+      TCollection_AsciiString entry;
+      if ( !(theSource >> entry) )
+        return Standard_False;
+      TDF_Label L;
+      TDF_Tool::Label(anAtt->Label().Data(), entry, L, Standard_True);
+      if (!L.IsNull())
+        anAtt->Append(L);
+    }
   }
 
+  BinMDataStd::SetAttributeID(theSource, anAtt);
   return Standard_True;
 }
 
@@ -82,8 +85,8 @@ Standard_Boolean BinMDataStd_ReferenceListDriver::Paste(const BinObjMgt_Persiste
 //purpose  : transient -> persistent (store)
 //=======================================================================
 void BinMDataStd_ReferenceListDriver::Paste(const Handle(TDF_Attribute)& theSource,
-                                           BinObjMgt_Persistent&        theTarget,
-                                           BinObjMgt_SRelocationTable&  ) const
+                                            BinObjMgt_Persistent&        theTarget,
+                                            BinObjMgt_SRelocationTable&  ) const
 {
   const Handle(TDataStd_ReferenceList) anAtt = Handle(TDataStd_ReferenceList)::DownCast(theSource);
   if (anAtt.IsNull())
@@ -103,4 +106,8 @@ void BinMDataStd_ReferenceListDriver::Paste(const Handle(TDF_Attribute)& theSour
       theTarget << entry;
     }
   }
+
+  // process user defined guid
+  if(anAtt->ID() != TDataStd_ReferenceList::GetID()) 
+    theTarget << anAtt->ID();
 }
index 48b40a8..91f9c65 100644 (file)
 #include <TDataStd_ReferenceList.hxx>
 #include <TDF_ListIteratorOfLabelList.hxx>
 #include <TDataStd_ListIteratorOfListOfExtendedString.hxx>
-#define DEB_DDataStd
+#define  MAXLENGTH 10
+//#define DEB_DDataStd
 
 //=======================================================================
 //function : DDataStd_SetInteger
@@ -116,16 +117,16 @@ static Standard_Integer DDataStd_SetInteger (Draw_Interpretor& di,
     if (!DDF::GetDF(arg[1],DF)) return 1;
     TDF_Label L;
     DDF::AddLabel(DF, arg[2], L);
-       if(nb == 4) 
+    if(nb == 4) 
       TDataStd_Integer::Set(L,Draw::Atoi(arg[3]));  
-       else {  
-         if (!Standard_GUID::CheckGUIDFormat(arg[4])) {
+    else {
+      if (!Standard_GUID::CheckGUIDFormat(arg[4])) {
         di<<"DDataStd_SetInteger: The format of GUID is invalid\n";
         return 1;
-         }
-         Standard_GUID guid(arg[4]);
-         TDataStd_Integer::Set(L, guid, Draw::Atoi(arg[3]));  
-     }
+      }
+      Standard_GUID guid(arg[4]);
+      TDataStd_Integer::Set(L, guid, Draw::Atoi(arg[3]));  
+    }
     return 0;
   }
   di << "DDataStd_SetInteger : Error\n";
@@ -146,18 +147,18 @@ static Standard_Integer DDataStd_SetReal (Draw_Interpretor& di,
     if (!DDF::GetDF(arg[1],DF)) return 1;
     TDF_Label L;
     DDF::AddLabel(DF, arg[2], L);
-       if(nb == 4) 
+    if(nb == 4) 
       TDataStd_Real::Set(L,Draw::Atof(arg[3]));  
-       else {  
-         if (!Standard_GUID::CheckGUIDFormat(arg[4])) {
+    else {
+      if (!Standard_GUID::CheckGUIDFormat(arg[4])) {
         di<<"DDataStd_SetReal: The format of GUID is invalid\n";
         return 1;
-         }
-         Standard_GUID guid(arg[4]); 
-         TDataStd_Real::Set(L, guid, Draw::Atof(arg[3]));  
-     }
-       return 0;
-       }
+      }
+      Standard_GUID guid(arg[4]); 
+      TDataStd_Real::Set(L, guid, Draw::Atof(arg[3]));  
+    }
+    return 0;
+  }
   di << "DDataStd_SetReal : Error\n";
   return 1;
 }
@@ -222,28 +223,28 @@ static Standard_Integer DDataStd_GetInteger (Draw_Interpretor& di,
     Handle(TDF_Data) DF;
     if (!DDF::GetDF(arg[1],DF)) return 1;
     Handle(TDataStd_Integer) A;
-       Standard_GUID aGuid;
-       Standard_GUID aNullGuid("00000000-0000-0000-0000-000000000000");
-       Standard_Boolean isdrawname(Standard_False);
-       if(nb < 5 ) {
+    Standard_GUID aGuid;
+    Standard_GUID aNullGuid("00000000-0000-0000-0000-000000000000");
+    Standard_Boolean isdrawname(Standard_False);
+    if(nb < 5 ) {
       if(nb == 4) { //DF, entry, guid
-           if (Standard_GUID::CheckGUIDFormat(arg[3])) 
+        if (Standard_GUID::CheckGUIDFormat(arg[3])) 
           aGuid = Standard_GUID(arg[3]);
-         }
-         if(Standard_GUID::IsEqual(aGuid, aNullGuid)) {
-           isdrawname = Standard_True;
-           aGuid = TDataStd_Integer::GetID();
-         }
-       } else if(nb == 5) {
-         isdrawname = Standard_True; 
-         if (Standard_GUID::CheckGUIDFormat(arg[4])) 
+      }
+      if(Standard_GUID::IsEqual(aGuid, aNullGuid)) {
+        isdrawname = Standard_True;
+        aGuid = TDataStd_Integer::GetID();
+      }
+    } else if(nb == 5) {
+      isdrawname = Standard_True; 
+      if (Standard_GUID::CheckGUIDFormat(arg[4])) 
         aGuid = Standard_GUID(arg[4]);
-         else {
+      else {
         di<<"DDataStd_GetInteger: The format of GUID is invalid\n";
         return 1;
-         }
-       } 
-                 
+      }
+    } 
+
     if (!DDF::Find(DF,arg[2],aGuid,A)) return 1;
     if (nb == 4 && isdrawname) Draw::Set(arg[3],A->Get());
     else         Draw::Set(arg[2],A->Get());
@@ -267,28 +268,28 @@ static Standard_Integer DDataStd_GetReal (Draw_Interpretor& di,
     Handle(TDF_Data) DF;
     if (!DDF::GetDF(arg[1],DF)) return 1;
     Handle(TDataStd_Real) A;
-       Standard_GUID aGuid;
+    Standard_GUID aGuid;
     Standard_GUID aNullGuid("00000000-0000-0000-0000-000000000000");
-       Standard_Boolean isdrawname(Standard_False);
+    Standard_Boolean isdrawname(Standard_False);
     if(nb < 5 ) {
-         if(nb == 4) {
-           if (Standard_GUID::CheckGUIDFormat(arg[3])) 
+      if(nb == 4) {
+        if (Standard_GUID::CheckGUIDFormat(arg[3])) 
           aGuid = Standard_GUID(arg[3]);
-         }
-         if(Standard_GUID::IsEqual(aGuid, aNullGuid)) {
-           isdrawname = Standard_True;
-           aGuid = TDataStd_Real::GetID();
-         }
-       }
-       else if(nb == 5) {
-         isdrawname = Standard_True; 
-         if (Standard_GUID::CheckGUIDFormat(arg[4])) 
+      }
+      if(Standard_GUID::IsEqual(aGuid, aNullGuid)) {
+        isdrawname = Standard_True;
+        aGuid = TDataStd_Real::GetID();
+      }
+    }
+    else if(nb == 5) {
+      isdrawname = Standard_True; 
+      if (Standard_GUID::CheckGUIDFormat(arg[4])) 
         aGuid = Standard_GUID(arg[4]);
-         else {
+      else {
         di<<"DDataStd_GetReal: The format of GUID is invalid\n";
         return 1;
-         }
-       } 
+      }
+    } 
     if (!DDF::Find(DF,arg[2],aGuid,A)) return 1;
     if (nb == 4 && isdrawname) Draw::Set(arg[3],A->Get());
     else         Draw::Set(arg[2],A->Get());
@@ -490,30 +491,57 @@ static Standard_Integer DDataStd_GetUAttribute (Draw_Interpretor& di,
 
 
 //=======================================================================
-//function : SetIntArray (DF, entry , isDelta, From, To,  elmt1, elmt2, ...
+//function : SetIntArray (DF, entry , isDelta, [-g Guid,] From, To,  elmt1, elmt2, ...
 //=======================================================================
 static Standard_Integer DDataStd_SetIntArray (Draw_Interpretor& di,
                                               Standard_Integer nb,
                                               const char** arg) 
 {
-  Handle(TDF_Data) DF;
-  if (!DDF::GetDF(arg[1],DF))  return 1; 
-  TDF_Label label;
-  DDF::AddLabel(DF, arg[2], label);
-  Standard_Boolean isDelta = Draw::Atoi(arg[3]) != 0;
-  Standard_Integer From = Draw::Atoi(arg[4]), To = Draw::Atoi( arg[5] ), j;
-  di << "Array of Standard_Integer with bounds from = " << From  << " to = " << To  << "\n";
-  Handle(TDataStd_IntegerArray) A = TDataStd_IntegerArray::Set(label, From, To, isDelta);
-  
-  if (nb > 6) {
-    j = 6;
-    for(Standard_Integer i = From; i<=To; i++) {
-      A->SetValue(i, Draw::Atoi(arg[j]) ); 
-      j++;
+  if (nb >= 6) {  
+    Handle(TDF_Data) DF;
+    if (!DDF::GetDF(arg[1],DF))  return 1; 
+    TDF_Label label;
+    DDF::AddLabel(DF, arg[2], label);
+    Standard_Boolean isDelta = Draw::Atoi(arg[3]) != 0;
+    Standard_GUID guid;
+    Standard_Boolean isGuid(Standard_False);
+    Standard_Character c1(arg[4][0]), c2(arg[4][1]);
+    if(c1 == '-' && c2 == 'g') { //guid
+      if (!Standard_GUID::CheckGUIDFormat(arg[5])) {
+        di<<"DDataStd_SetIntArray: The format of GUID is invalid\n";
+        return 1;
+      }
+      guid = Standard_GUID (arg[5]);
+      isGuid = Standard_True;
     }
-  }
-
-  return 0; 
+    Standard_Integer j(4);
+    if(isGuid) j = 6;
+    if((strlen(arg[j]) > MAXLENGTH || strlen(arg[j+1]) > MAXLENGTH) || 
+      !TCollection_AsciiString (arg[j]).IsIntegerValue() || 
+      !TCollection_AsciiString (arg[j+1]).IsIntegerValue())
+    {
+      di << "DDataStd_SetIntArray: From, To may be wrong\n";
+      return 1;
+    }
+    Standard_Integer From = Draw::Atoi(arg[j]), To = Draw::Atoi( arg[j+1] );
+    di << "Array of Standard_Integer with bounds from = " << From  << " to = " << To  << "\n";
+    Handle(TDataStd_IntegerArray) A;
+    if(!isGuid) 
+      A = TDataStd_IntegerArray::Set(label, From, To, isDelta);
+    else 
+      A = TDataStd_IntegerArray::Set(label, guid, From, To, isDelta);
+
+    if ((!isGuid && nb > 6) || (isGuid && nb > 8)) {
+      j = j + 2;
+      for(Standard_Integer i = From; i<=To; i++) {
+        A->SetValue(i, Draw::Atoi(arg[j]) ); 
+        j++;
+      }
+    }
+    return 0; 
+  } 
+  di << "DDataStd_SetIntArray: Error\n";
+  return 1; 
 } 
 
 //=======================================================================
@@ -549,38 +577,50 @@ static Standard_Integer DDataStd_SetIntArrayValue (Draw_Interpretor&,
 } 
 
 //=======================================================================
-//function : GetIntArray (DF, entry )
+//function : GetIntArray (DF, entry [, guid] )
 //=======================================================================
 static Standard_Integer DDataStd_GetIntArray (Draw_Interpretor& di,
-                                              Standard_Integer, 
+                                              Standard_Integer nb, 
                                               const char** arg) 
 {   
 
+  if (nb >= 3) 
+  {  
+    Handle(TDF_Data) DF;
+    if (!DDF::GetDF(arg[1],DF))  return 1;  
+    TDF_Label label;
+    if( !DDF::FindLabel(DF, arg[2], label) ) {
+      di << "No label for entry"  << "\n";
+      return 1;
+    }
+    Standard_GUID aGuid;
+    if(nb == 4) {
+      if (Standard_GUID::CheckGUIDFormat(arg[3])) 
+        aGuid = Standard_GUID(arg[3]);
+      else {
+        di << "Wrong GUID format"  << "\n";
+        return 1; 
+      }
+    } else
+      aGuid = TDataStd_IntegerArray::GetID();
+    Handle(TDataStd_IntegerArray) A;
+    if ( !label.FindAttribute(aGuid, A) ) { 
+      di << "There is no TDataStd_IntegerArray with the specified GUID under label"  << "\n";
+      return 1;
+    }
 
-  Handle(TDF_Data) DF;
-  if (!DDF::GetDF(arg[1],DF))  return 1;  
-  TDF_Label label;
-  if( !DDF::FindLabel(DF, arg[2], label) ) {
-    di << "No label for entry"  << "\n";
-    return 1;
-  }
-  Handle(TDataStd_IntegerArray) A;
-  if ( !label.FindAttribute(TDataStd_IntegerArray::GetID(), A) ) { 
-    di << "There is no TDataStd_IntegerArray under label"  << "\n";
-    return 1;
-  }
-  
-  for(Standard_Integer i = A->Lower(); i<=A->Upper(); i++){
-    //cout <<  A->Value(i)   << endl;
-    di  <<  A->Value(i);
-    if(i<A->Upper())  
-     di<<" ";
-  }
-  di<<"\n";
-  return 0; 
+    for(Standard_Integer i = A->Lower(); i<=A->Upper(); i++){
+      //cout <<  A->Value(i)   << endl;
+      di  <<  A->Value(i);
+      if(i<A->Upper())  
+        di<<" ";
+    }
+    di<<"\n";
+    return 0; 
+  } 
+  di << "DDataStd_GetIntArray: Error\n";
+  return 1; 
 } 
-
 //=======================================================================
 //function : GetIntArrayValue (DF, entry, index)
 //=======================================================================
@@ -590,20 +630,20 @@ static Standard_Integer DDataStd_GetIntArrayValue (Draw_Interpretor& di,
 {
   Handle(TDF_Data) DF;
   if (!DDF::GetDF(arg[1],DF))
-      return 1;
+    return 1;
 
   TDF_Label label;
   if (!DDF::FindLabel(DF, arg[2], label)) {
     di << "No label for entry"  << "\n";
     return 1;
   }
+
   Handle(TDataStd_IntegerArray) A;
   if ( !label.FindAttribute(TDataStd_IntegerArray::GetID(), A) ) { 
     di << "There is no TDataStd_IntegerArray under label"  << "\n";
     return 1;
   }
-  
+
   Standard_Integer index = Draw::Atoi(arg[3]);
   if (index < A->Lower() || index > A->Upper()) {
     di << "Index is out of range\n";
@@ -647,22 +687,22 @@ static Standard_Integer DDataStd_ChangeIntArray (Draw_Interpretor& di,
       Handle(TColStd_HArray1OfInteger) arr;
       Standard_Integer i;
       if(indx > up) {
-       up = indx;
-       arr = new TColStd_HArray1OfInteger(low, up);
-       for(i=low; i<= Arr->Upper(); i++)
-         arr->SetValue(i, Arr->Value(i));
-       for(i=Arr->Upper()+1; i<= up; i++) {
-         if(i == up)
-           arr->SetValue(i, val);
-         else
-           arr->SetValue(i, 0);
-       }
+        up = indx;
+        arr = new TColStd_HArray1OfInteger(low, up);
+        for(i=low; i<= Arr->Upper(); i++)
+          arr->SetValue(i, Arr->Value(i));
+        for(i=Arr->Upper()+1; i<= up; i++) {
+          if(i == up)
+            arr->SetValue(i, val);
+          else
+            arr->SetValue(i, 0);
+        }
       } else if(indx < up) {//clip array : indx to be negative
-       up = abs(indx);
-       arr = new TColStd_HArray1OfInteger(low, up);
-       for(i=low; i< up; i++)
-         arr->SetValue(i, Arr->Value(i));
-       arr->SetValue(up, val);
+        up = abs(indx);
+        arr = new TColStd_HArray1OfInteger(low, up);
+        for(i=low; i< up; i++)
+          arr->SetValue(i, Arr->Value(i));
+        arr->SetValue(up, val);
       }
       A->ChangeArray(arr);
     }
@@ -702,35 +742,57 @@ static Standard_Integer DDataStd_SetIntArrayTest (Draw_Interpretor& di,
 } 
 
 //=======================================================================
-//function : SetRealArray (DF, entry , isDelta, From, To,  elmt1, elmt2, ...
+//function : SetRealArray (DF, entry , isDelta, [-g Guid,] From, To,  elmt1, elmt2, ...
 //=======================================================================
 static Standard_Integer DDataStd_SetRealArray (Draw_Interpretor& di,
                                                Standard_Integer nb, 
                                                const char** arg) 
 {   
-
-
-  Handle(TDF_Data) DF;
-  if (!DDF::GetDF(arg[1],DF))  return 1;  
-  TDF_Label label; 
-  DDF::AddLabel(DF, arg[2], label);
-  Standard_Boolean isDelta = Draw::Atoi(arg[3]) != 0;
-  Standard_Integer From = Draw::Atoi(arg[4]), To = Draw::Atoi( arg[5] ), j;
-  di << " Array of Standard_Real with bounds from = " << From  << " to = " << To  << "\n";
-  Handle(TDataStd_RealArray) A = TDataStd_RealArray::Set(label, From, To, isDelta);
-  
-  if (nb > 6) {
-    j = 6;
-    for(Standard_Integer i = From; i<=To; i++) {
-      A->SetValue(i, Draw::Atof(arg[j]) );
-      j++;
+  if (nb >= 6) {  
+    Handle(TDF_Data) DF;
+    if (!DDF::GetDF(arg[1],DF))  return 1;  
+    TDF_Label label; 
+    DDF::AddLabel(DF, arg[2], label);
+    Standard_Boolean isDelta = Draw::Atoi(arg[3]) != 0;
+    Standard_GUID guid;
+    Standard_Boolean isGuid(Standard_False);
+    Standard_Character c1(arg[4][0]), c2(arg[4][1]);
+    if(c1 == '-' && c2 == 'g') { //guid
+      if (!Standard_GUID::CheckGUIDFormat(arg[5])) {
+        di<<"DDataStd_SetRealArray: The format of GUID is invalid\n";
+        return 1;
+      }
+      guid = Standard_GUID (arg[5]);
+      isGuid = Standard_True;
     }
-  }
-
-  return 0;  
+    Standard_Integer j(4);
+    if(isGuid) j = 6;
+    if((strlen(arg[j]) > MAXLENGTH || strlen(arg[j+1]) > MAXLENGTH) || 
+      !TCollection_AsciiString (arg[j]).IsIntegerValue() || 
+      !TCollection_AsciiString (arg[j+1]).IsIntegerValue())
+    {
+      di << "DDataStd_SetRealArray: From, To may be wrong\n";
+      return 1;
+    }
+    Standard_Integer From = Draw::Atoi(arg[j]), To = Draw::Atoi( arg[j+1] );
+    di << " Array of Standard_Real with bounds from = " << From  << " to = " << To  << "\n";
+    Handle(TDataStd_RealArray) A;
+    if(!isGuid) 
+      A = TDataStd_RealArray::Set(label, From, To, isDelta);
+    else 
+      A = TDataStd_RealArray::Set(label, guid, From, To, isDelta);
+    if ((!isGuid && nb > 6) || (isGuid && nb > 8)) {
+      j = j + 2;
+      for(Standard_Integer i = From; i<=To; i++) {
+        A->SetValue(i, Draw::Atof(arg[j]) );
+        j++;
+      }
+    }
+    return 0;  
+  } 
+  di << "DDataStd_SetRealArray: Error\n";
+  return 1; 
 } 
-
 //=======================================================================
 //function : SetRealArrayValue (DF, entry, index value)
 //=======================================================================
@@ -764,38 +826,55 @@ static Standard_Integer DDataStd_SetRealArrayValue (Draw_Interpretor&,
 } 
 
 //=======================================================================
-//function : GetRealArray (DF, entry )
+//function : GetRealArray (DF, entry [, guid])
 //=======================================================================
 static Standard_Integer DDataStd_GetRealArray (Draw_Interpretor& di,
-                                               Standard_Integer, 
+                                               Standard_Integer nb, 
                                                const char** arg) 
 {   
+  if (nb >= 3) 
+  {  
+    Handle(TDF_Data) DF;
+    if (!DDF::GetDF(arg[1],DF))  return 1;  
+    TDF_Label label;
+    if( !DDF::FindLabel(DF, arg[2], label) ) { 
+      di << "No label for entry"  << "\n";
+      return 1; 
+    }
+    Standard_GUID aGuid;
+    if(nb == 4) {
+      if (Standard_GUID::CheckGUIDFormat(arg[3])) 
+        aGuid = Standard_GUID(arg[3]);
+      else {
+        di << "Wrong GUID format"  << "\n";
+        return 1; 
+      }
+    } else
+      aGuid = TDataStd_RealArray::GetID();
 
-  Handle(TDF_Data) DF;
-  if (!DDF::GetDF(arg[1],DF))  return 1;  
-  TDF_Label label;
-  if( !DDF::FindLabel(DF, arg[2], label) ) { 
-    di << "No label for entry"  << "\n";
-    return 1; 
-  }
-  Handle(TDataStd_RealArray) A;
-  if ( !label.FindAttribute(TDataStd_RealArray::GetID(), A) ) { 
-    di << "There is no TDataStd_RealArray under label"  << "\n";
-    return 1; 
-  }
-  
-  for(Standard_Integer i = A->Lower(); i<=A->Upper(); i++){
-    //cout <<  A->Value(i)   << endl; 
-    di   <<  A->Value(i);
-    if(i<A->Upper())  
-     di<<" ";
-  }  
-  di<<"\n";
-
-  return 0;  
-} 
+    Handle(TDataStd_RealArray) A;
+    if ( !label.FindAttribute(aGuid, A) ) {
+      di << "There is no TDataStd_RealArray with the specified GUID at the label"  << "\n";
+#ifdef DEB_DDataStd
+      aGuid.ShallowDump(cout);
+#endif
+      return 1; 
+    }
 
+    for(Standard_Integer i = A->Lower(); i<=A->Upper(); i++){
+#ifdef DEB_DDataStd
+      cout <<  A->Value(i)   << endl; 
+#endif
+      di   <<  A->Value(i);
+      if(i<A->Upper())  
+        di<<" ";
+    }  
+    di<<"\n";
+    return 0;
+  } 
+  di << "TDataStd_RealArray: Error\n";
+  return 1; 
+} 
 //=======================================================================
 //function : GetRealArrayValue (DF, entry, index)
 //=======================================================================
@@ -805,20 +884,20 @@ static Standard_Integer DDataStd_GetRealArrayValue (Draw_Interpretor& di,
 {
   Handle(TDF_Data) DF;
   if (!DDF::GetDF(arg[1],DF))
-      return 1;
+    return 1;
 
   TDF_Label label;
   if (!DDF::FindLabel(DF, arg[2], label)) {
     di << "No label for entry"  << "\n";
     return 1;
   }
+
   Handle(TDataStd_RealArray) A;
   if ( !label.FindAttribute(TDataStd_RealArray::GetID(), A) ) { 
     di << "There is no TDataStd_RealArray under label"  << "\n";
     return 1;
   }
-  
+
   Standard_Integer index = Draw::Atoi(arg[3]);
   if (index < A->Lower() || index > A->Upper()) {
     di << "Index is out of range\n";
@@ -862,22 +941,22 @@ static Standard_Integer DDataStd_ChangeRealArray (Draw_Interpretor& di,
       Handle(TColStd_HArray1OfReal) arr;
       Standard_Integer i;
       if(indx > up) {
-       up = indx;
-       arr = new TColStd_HArray1OfReal(low, up);
-       for(i=low; i<= Arr->Upper(); i++)
-         arr->SetValue(i, Arr->Value(i));
-       for(i=Arr->Upper()+1; i<= up; i++) {
-         if(i == up)
-           arr->SetValue(i, val);
-         else
-           arr->SetValue(i, 0);
-       }
+        up = indx;
+        arr = new TColStd_HArray1OfReal(low, up);
+        for(i=low; i<= Arr->Upper(); i++)
+          arr->SetValue(i, Arr->Value(i));
+        for(i=Arr->Upper()+1; i<= up; i++) {
+          if(i == up)
+            arr->SetValue(i, val);
+          else
+            arr->SetValue(i, 0);
+        }
       } else if(indx < up) {//clip array : indx to be negative
-       up = abs(indx);
-       arr = new TColStd_HArray1OfReal(low, up);
-       for(i=low; i< up; i++)
-         arr->SetValue(i, Arr->Value(i));
-       arr->SetValue(up, val);
+        up = abs(indx);
+        arr = new TColStd_HArray1OfReal(low, up);
+        for(i=low; i< up; i++)
+          arr->SetValue(i, Arr->Value(i));
+        arr->SetValue(up, val);
       }
       A->ChangeArray(arr);
     }
@@ -1096,31 +1175,58 @@ static Standard_Integer DDataStd_GetFunction (Draw_Interpretor& di,
 } 
 
 //=======================================================================
-//function : SetExtStringArray (DF, entry , isDelta, From, To,  elmt1, elmt2, ...
+//function : SetExtStringArray (DF, entry , isDelta, [-g Guid, ]From, To,  elmt1, elmt2, ...
 //=======================================================================
 static Standard_Integer DDataStd_SetExtStringArray (Draw_Interpretor& di,
-                                                                           Standard_Integer nb, 
-                                                                           const char** arg) 
-{   
-  Handle(TDF_Data) DF;
-  if (!DDF::GetDF(arg[1],DF))  return 1; 
-  TDF_Label label;
-  DDF::AddLabel(DF, arg[2], label);
-  Standard_Boolean isDelta = Draw::Atoi(arg[3]) != 0;
+                                                    Standard_Integer nb, 
+                                                    const char** arg) 
+{
+  if (nb >= 6) {  
+    Handle(TDF_Data) DF;
+    if (!DDF::GetDF(arg[1],DF))  return 1; 
+    TDF_Label label;
+    DDF::AddLabel(DF, arg[2], label);
+    Standard_Boolean isDelta = Draw::Atoi(arg[3]) != 0;
 
-  Standard_Integer From = Draw::Atoi(arg[4]), To = Draw::Atoi( arg[5] ), j;
-  di << "Array of ExtString with bounds from = " << From  << " to = " << To  << "\n";
-  Handle(TDataStd_ExtStringArray) A = TDataStd_ExtStringArray::Set(label, From, To, isDelta);
-  
-  if (nb > 6) {
-    j = 6;
-    for(Standard_Integer i = From; i<=To; i++) {
-      A->SetValue(i, arg[j] ); 
-      j++;
+    Standard_GUID guid;
+    Standard_Boolean isGuid(Standard_False);
+    Standard_Character c1(arg[4][0]), c2(arg[4][1]);
+    if(c1 == '-' && c2 == 'g') { //guid
+      if (!Standard_GUID::CheckGUIDFormat(arg[5])) {
+        di<<"DDataStd_SetExtStringArray: The format of GUID is invalid\n";
+        return 1;
+      }
+      guid = Standard_GUID (arg[5]);
+      isGuid = Standard_True;
     }
-  }
+    Standard_Integer j(4);
+    if(isGuid) j = 6;
+    if((strlen(arg[j]) > MAXLENGTH || strlen(arg[j+1]) > MAXLENGTH) || 
+      !TCollection_AsciiString (arg[j]).IsIntegerValue() || 
+      !TCollection_AsciiString (arg[j+1]).IsIntegerValue())
+    {
+      di << "DDataStd_SetExtStringArray: From, To may be wrong\n";
+      return 1;
+    }
+    Standard_Integer From = Draw::Atoi(arg[j]), To = Draw::Atoi( arg[j+1] );
+    di << "Array of ExtString with bounds from = " << From  << " to = " << To  << "\n";
+    Handle(TDataStd_ExtStringArray) A;
+    if(!isGuid) 
+      A = TDataStd_ExtStringArray::Set(label, From, To, isDelta);
+    else 
+      A = TDataStd_ExtStringArray::Set(label, guid, From, To, isDelta);
 
-  return 0; 
+    if ((!isGuid && nb > 6) || (isGuid && nb > 8)) {
+      j = j + 2;
+      for(Standard_Integer i = From; i<=To; ++i) {
+        A->SetValue(i, arg[j] );
+        j++;
+      }
+    }
+    return 0; 
+  }
+  di << "TDataStd_ExtStringArray: Error\n";
+  return 1; 
 } 
 
 //=======================================================================
@@ -1158,33 +1264,46 @@ static Standard_Integer DDataStd_SetExtStringArrayValue (Draw_Interpretor&,
 //function : GetExtStringArray (DF, entry )
 //=======================================================================
 static Standard_Integer DDataStd_GetExtStringArray (Draw_Interpretor& di,
-                                                   Standard_Integer, 
-                                                   const char** arg) 
+                                                    Standard_Integer nb, 
+                                                    const char** arg) 
 {   
+  if (nb >= 3) 
+  {  
 
+    Handle(TDF_Data) DF;
+    if (!DDF::GetDF(arg[1],DF))  return 1;  
+    TDF_Label label;
+    if( !DDF::FindLabel(DF, arg[2], label) ) {
+      di << "No label for entry"  << "\n";
+      return 1;
+    }
+    Standard_GUID aGuid;
+    if(nb == 4) {
+      if (Standard_GUID::CheckGUIDFormat(arg[3])) 
+        aGuid = Standard_GUID(arg[3]);
+      else {
+        di << "Wrong GUID format"  << "\n";
+        return 1; 
+      }
+    } else
+      aGuid = TDataStd_ExtStringArray::GetID();
+    Handle(TDataStd_ExtStringArray) A;
+    if ( !label.FindAttribute(aGuid, A) ) { 
+      di << "There is no TDataStd_ExtStringArray  with the specified GUID at the label"  << "\n";
+      return 1;
+    }
 
-  Handle(TDF_Data) DF;
-  if (!DDF::GetDF(arg[1],DF))  return 1;  
-  TDF_Label label;
-  if( !DDF::FindLabel(DF, arg[2], label) ) {
-    di << "No label for entry"  << "\n";
-    return 1;
-  }
-  Handle(TDataStd_ExtStringArray) A;
-  if ( !label.FindAttribute(TDataStd_ExtStringArray::GetID(), A) ) { 
-    di << "There is no TDataStd_ExtStringArray under label"  << "\n";
-    return 1;
-  }
-  
-  for(Standard_Integer i = A->Lower(); i<=A->Upper(); i++){
-    TCollection_AsciiString anAsciiString(A->Value(i),'?');
-    di << anAsciiString.ToCString();
-    if(i<A->Upper())  
-      di<<" ";
-  }
-  di<<"\n";
-  return 0; 
+    for(Standard_Integer i = A->Lower(); i<=A->Upper(); i++){
+      TCollection_AsciiString anAsciiString(A->Value(i),'?');
+      di << anAsciiString.ToCString();
+      if(i<A->Upper())  
+        di<<" ";
+    }
+    di<<"\n";
+    return 0; 
+  } 
+  di << "DDataStd_GetExtStringArray: Error\n";
+  return 1; 
 } 
 
 //=======================================================================
@@ -1254,22 +1373,22 @@ static Standard_Integer DDataStd_ChangeExtStrArray (Draw_Interpretor& di,
       Handle(TColStd_HArray1OfExtendedString) arr;
       Standard_Integer i;
       if(indx > up) {
-       up = indx;
-       arr = new TColStd_HArray1OfExtendedString(low, up);
-       for(i=low; i<= Arr->Upper(); i++)
-         arr->SetValue(i, Arr->Value(i));
-       for(i=Arr->Upper()+1; i<= up; i++) {
-         if(i == up)
-           arr->SetValue(i, val);
-         else
-           arr->SetValue(i, 0);
-       }
+        up = indx;
+        arr = new TColStd_HArray1OfExtendedString(low, up);
+        for(i=low; i<= Arr->Upper(); i++)
+          arr->SetValue(i, Arr->Value(i));
+        for(i=Arr->Upper()+1; i<= up; i++) {
+          if(i == up)
+            arr->SetValue(i, val);
+          else
+            arr->SetValue(i, 0);
+        }
       } else if(indx < up) {//clip array : indx to be negative
-       up = abs(indx);
-       arr = new TColStd_HArray1OfExtendedString(low, up);
-       for(i=low; i< up; i++)
-         arr->SetValue(i, Arr->Value(i));
-       arr->SetValue(up, val);
+        up = abs(indx);
+        arr = new TColStd_HArray1OfExtendedString(low, up);
+        for(i=low; i< up; i++)
+          arr->SetValue(i, Arr->Value(i));
+        arr->SetValue(up, val);
       }
       A->ChangeArray(arr);
     }    
@@ -1348,15 +1467,15 @@ static Standard_Integer DDataStd_GetUTFtoFile (Draw_Interpretor& di,
     for(;anIt.More();anIt.Next()) {
       const TDF_Label& aLab = anIt.Value();
       if(!aLab.IsNull()) {
-       Handle(TDataStd_Name) anAtt;
-       if(aLab.FindAttribute(TDataStd_Name::GetID(), anAtt)) {
-         if(anAtt->Get().Length()) { 
-           if (aF)
-             aES +='\n';         
-           aES +=anAtt->Get(); 
-           aF = Standard_True;
-         }
-       }
+        Handle(TDataStd_Name) anAtt;
+        if(aLab.FindAttribute(TDataStd_Name::GetID(), anAtt)) {
+          if(anAtt->Get().Length()) { 
+            if (aF)
+              aES +='\n';
+            aES +=anAtt->Get();
+            aF = Standard_True;
+          }
+        }
       }
     }
 
@@ -1392,7 +1511,7 @@ static Standard_Integer DDataStd_GetUTFtoFile (Draw_Interpretor& di,
 }
 
 //=======================================================================
-//function : SetByteArray (DF, entry, isDelta, From, To, elmt1, elmt2, ...  )
+//function : SetByteArray (DF, entry, isDelta, [-g Guid,] From, To, elmt1, elmt2, ...  )
 //=======================================================================
 static Standard_Integer DDataStd_SetByteArray (Draw_Interpretor& di,
                                               Standard_Integer nb, 
@@ -1404,12 +1523,36 @@ static Standard_Integer DDataStd_SetByteArray (Draw_Interpretor& di,
     TDF_Label label;
     DDF::AddLabel(DF, arg[2], label);
     Standard_Boolean isDelta = Draw::Atoi(arg[3]) != 0;
-    Standard_Integer From = Draw::Atoi(arg[4]), To = Draw::Atoi( arg[5] ), j;
+    Standard_GUID guid;
+    Standard_Boolean isGuid(Standard_False);
+    Standard_Character c1(arg[4][0]), c2(arg[4][1]);
+    if(c1 == '-' && c2 == 'g') { //guid
+      if (!Standard_GUID::CheckGUIDFormat(arg[5])) {
+        di<<"DDataStd_SetByteArray: The format of GUID is invalid\n";
+        return 1;
+      }
+      guid = Standard_GUID (arg[5]);
+      isGuid = Standard_True;
+    }
+    Standard_Integer j(4);
+    if(isGuid) j = 6;
+    if((strlen(arg[j]) > MAXLENGTH || strlen(arg[j+1]) > MAXLENGTH) || 
+      !TCollection_AsciiString (arg[j]).IsIntegerValue() || 
+      !TCollection_AsciiString (arg[j+1]).IsIntegerValue())
+    {
+      di << "DDataStd_SetByteArray: From, To may be wrong\n";
+      return 1;
+    }
+    Standard_Integer From = Draw::Atoi(arg[j]), To = Draw::Atoi( arg[j+1] );
     di << "Array of Standard_Byte with bounds from = " << From  << " to = " << To  << "\n";
-    Handle(TDataStd_ByteArray) A = TDataStd_ByteArray::Set(label, From, To, isDelta);
-    
-    if (nb > 6) {
-      j = 6;
+    Handle(TDataStd_ByteArray) A;
+    if(!isGuid) 
+      A = TDataStd_ByteArray::Set(label, From, To, isDelta);
+    else 
+      A = TDataStd_ByteArray::Set(label, guid, From, To, isDelta);
+
+    if ((!isGuid && nb > 6) || (isGuid && nb > 8)) {
+      j = j + 2;
       for(Standard_Integer i = From; i<=To; ++i) {
         Standard_Integer ival = Draw::Atoi(arg[j]);
         if(ival < 0 || 255 < ival) {
@@ -1465,32 +1608,56 @@ static Standard_Integer DDataStd_SetByteArrayValue (Draw_Interpretor&,
 } 
 
 //=======================================================================
-//function : SetBooleanArray (DF, entry, isDelta, From, To, elmt1, elmt2, ...  )
+//function : SetBooleanArray (DF, entry, [-g Guid,] From, To, elmt1, elmt2, ...  )
 //=======================================================================
 static Standard_Integer DDataStd_SetBooleanArray (Draw_Interpretor& di,
                                                   Standard_Integer nb, 
                                                   const char** arg) 
 {
-  if (nb >= 6) 
+  if (nb >= 5) 
   {  
     Handle(TDF_Data) DF;
     if (!DDF::GetDF(arg[1],DF))
-        return 1; 
+      return 1; 
 
     TDF_Label label;
     DDF::AddLabel(DF, arg[2], label);
-    Standard_Integer From = Draw::Atoi(arg[4]), To = Draw::Atoi( arg[5] ), j;
+    Standard_GUID guid;
+    Standard_Boolean isGuid(Standard_False);
+    Standard_Character c1(arg[3][0]), c2(arg[3][1]);
+    if(c1 == '-' && c2 == 'g') { //guid
+      if (!Standard_GUID::CheckGUIDFormat(arg[4])) {
+        di<<"DDataStd_SetBooleanArray: The format of GUID is invalid\n";
+        return 1;
+      }
+      guid = Standard_GUID (arg[4]);
+      isGuid = Standard_True;
+    }
+    Standard_Integer j(3);
+    if(isGuid) j = 5;
+    if((strlen(arg[j]) > MAXLENGTH || strlen(arg[j+1]) > MAXLENGTH) || 
+      !TCollection_AsciiString (arg[j]).IsIntegerValue() || 
+      !TCollection_AsciiString (arg[j+1]).IsIntegerValue())
+    {
+      di << "DDataStd_SetBooleanArray: From, To may be wrong\n";
+      return 1;
+    }
+    Standard_Integer From = Draw::Atoi(arg[j]), To = Draw::Atoi( arg[j+1] );
     di << "Array of Standard_Boolean with bounds from = " << From  << " to = " << To  << "\n";
-    Handle(TDataStd_BooleanArray) A = TDataStd_BooleanArray::Set(label, From, To);
-    
-    if (nb > 6) {
-      j = 6;
+    Handle(TDataStd_BooleanArray) A;
+    if(!isGuid) 
+      A = TDataStd_BooleanArray::Set(label, From, To);
+    else 
+      A = TDataStd_BooleanArray::Set(label, guid, From, To);
+
+    if ((!isGuid && nb > 5) || (isGuid && nb > 7)) {
+      j = j + 2;
       for(Standard_Integer i = From; i<=To; i++) 
       {
         Standard_Integer ival = Draw::Atoi(arg[j]);
         if(ival > 1) 
         {
-          cout << "Bad value = " << ival<< ". 0 or 1 is expected." << endl;
+          cout << "Bad value (" <<i <<") = " << ival<< ". 0 or 1 is expected." << endl;
           return 1;
         }
         A->SetValue(i, ival != 0); 
@@ -1542,7 +1709,7 @@ static Standard_Integer DDataStd_SetBooleanArrayValue (Draw_Interpretor& di,
 } 
 
 //=======================================================================
-//function : DDataStd_SetExtStringList (DF, entry, elmt1, elmt2, ...  )
+//function : DDataStd_SetExtStringList (DF, entry, [-g guid,] elmt1, elmt2, ...  )
 //=======================================================================
 static Standard_Integer DDataStd_SetExtStringList (Draw_Interpretor& di,
                                                  Standard_Integer nb, 
@@ -1552,12 +1719,34 @@ static Standard_Integer DDataStd_SetExtStringList (Draw_Interpretor& di,
   {  
     Handle(TDF_Data) DF;
     if (!DDF::GetDF(arg[1],DF))
-        return 1; 
+      return 1; 
 
     TDF_Label label;
     DDF::AddLabel(DF, arg[2], label);
-    Handle(TDataStd_ExtStringList) A = TDataStd_ExtStringList::Set(label);
-    for(Standard_Integer i = 3; i <= nb - 1; i++) 
+    Standard_GUID guid;
+    Standard_Boolean isGuid(Standard_False);
+    if(nb > 4) {
+      Standard_Character c1(arg[3][0]), c2(arg[3][1]);
+      if(c1 == '-' && c2 == 'g') { //guid
+        if (!Standard_GUID::CheckGUIDFormat(arg[4])) {
+          di<<"DDataStd_SetExtStringList: The format of GUID is invalid\n";
+          return 1;
+        }
+        guid = Standard_GUID (arg[4]);
+        isGuid = Standard_True;
+      }
+    }
+    Standard_Integer j(0);
+    Handle(TDataStd_ExtStringList) A;
+    if(!isGuid) {
+      A = TDataStd_ExtStringList::Set(label);
+      j = 3;
+    }
+    else {
+      A = TDataStd_ExtStringList::Set(label, guid);
+      j = 5;
+    }
+    for(Standard_Integer i = j; i <= nb - 1; i++) 
     {
       TCollection_ExtendedString aValue(arg[i]);     
       A->Append(aValue); 
@@ -1569,7 +1758,7 @@ static Standard_Integer DDataStd_SetExtStringList (Draw_Interpretor& di,
 } 
 //
 //=======================================================================
-//function : DDataStd_SetReferenceList (DF, entry, elmt1, elmt2, ...  )
+//function : DDataStd_SetReferenceList (DF, entry, [-g guid] elmt1, elmt2, ...  )
 //=======================================================================
 static Standard_Integer DDataStd_SetReferenceList (Draw_Interpretor& di,
                                                    Standard_Integer nb, 
@@ -1579,21 +1768,41 @@ static Standard_Integer DDataStd_SetReferenceList (Draw_Interpretor& di,
   {  
     Handle(TDF_Data) DF;
     if (!DDF::GetDF(arg[1],DF))
-        return 1; 
+      return 1; 
 
     TDF_Label label;
     DDF::AddLabel(DF, arg[2], label);
-    if(!label.IsNull()) {
-      Handle(TDataStd_ReferenceList) A = TDataStd_ReferenceList::Set(label);
-      for(Standard_Integer i = 3; i <= nb - 1; i++) 
-      {
-        TDF_Label aValueLabel;
-        DDF::AddLabel(DF, arg[i], aValueLabel);
-        if(aValueLabel.IsNull()) continue;
-        A->Append(aValueLabel); 
+    Standard_GUID guid;
+    Standard_Boolean isGuid(Standard_False);
+    if(nb > 4) {
+      Standard_Character c1(arg[3][0]), c2(arg[3][1]);
+      if(c1 == '-' && c2 == 'g') { //guid
+        if (!Standard_GUID::CheckGUIDFormat(arg[4])) {
+          di<<"DDataStd_SetReferenceList: The format of GUID is invalid\n";
+          return 1;
+        }
+        guid = Standard_GUID (arg[4]);
+        isGuid = Standard_True;
       }
-      return 0; 
     }
+    Standard_Integer j(0);
+    Handle(TDataStd_ReferenceList) A;
+    if(!isGuid) {
+      A = TDataStd_ReferenceList::Set(label);
+      j = 3;
+    }
+    else {
+      A = TDataStd_ReferenceList::Set(label, guid);
+      j = 5;
+    }
+    for(Standard_Integer i = j; i <= nb - 1; i++) 
+    {
+      TDF_Label aValueLabel;
+      DDF::AddLabel(DF, arg[i], aValueLabel);
+      if(aValueLabel.IsNull()) continue;
+      A->Append(aValueLabel); 
+    }
+    return 0; 
   }
   di << "DDataStd_SetReferenceList: Error\n";
   return 1; 
@@ -1601,7 +1810,7 @@ static Standard_Integer DDataStd_SetReferenceList (Draw_Interpretor& di,
 
 
 //=======================================================================
-//function : SetBooleanList (DF, entry, elmt1, elmt2, ...  )
+//function : SetBooleanList (DF, entry, [-g Guid,] elmt1, elmt2, ...  )
 //=======================================================================
 static Standard_Integer DDataStd_SetBooleanList (Draw_Interpretor& di,
                                                  Standard_Integer nb, 
@@ -1615,8 +1824,30 @@ static Standard_Integer DDataStd_SetBooleanList (Draw_Interpretor& di,
 
     TDF_Label label;
     DDF::AddLabel(DF, arg[2], label);
-    Handle(TDataStd_BooleanList) A = TDataStd_BooleanList::Set(label);
-    for(Standard_Integer i = 3; i <= nb - 1; i++) 
+    Standard_GUID guid;
+    Standard_Boolean isGuid(Standard_False);
+    if(nb > 4) {
+      Standard_Character c1(arg[3][0]), c2(arg[3][1]);
+      if(c1 == '-' && c2 == 'g') { //guid
+        if (!Standard_GUID::CheckGUIDFormat(arg[4])) {
+          di<<"DDataStd_SetBooleanList: The format of GUID is invalid\n";
+          return 1;
+        }
+        guid = Standard_GUID (arg[4]);
+        isGuid = Standard_True;
+      }
+    }
+    Standard_Integer j(0);
+    Handle(TDataStd_BooleanList) A;
+    if(!isGuid) {
+      A = TDataStd_BooleanList::Set(label);
+      j = 3;
+    }
+    else {
+      A = TDataStd_BooleanList::Set(label, guid);
+      j = 5;
+    }
+    for(Standard_Integer i = j; i <= nb - 1; i++) 
     {
       Standard_Integer ival = Draw::Atoi(arg[i]);
       if(ival > 1) 
@@ -1633,7 +1864,7 @@ static Standard_Integer DDataStd_SetBooleanList (Draw_Interpretor& di,
 } 
 
 //=======================================================================
-//function : SetIntegerList (DF, entry, elmt1, elmt2, ...  )
+//function : SetIntegerList (DF, entry, [-g guid] elmt1, elmt2, ...  )
 //=======================================================================
 static Standard_Integer DDataStd_SetIntegerList (Draw_Interpretor& di,
                                                  Standard_Integer nb, 
@@ -1643,12 +1874,34 @@ static Standard_Integer DDataStd_SetIntegerList (Draw_Interpretor& di,
   {  
     Handle(TDF_Data) DF;
     if (!DDF::GetDF(arg[1],DF))
-        return 1; 
+      return 1; 
 
     TDF_Label label;
     DDF::AddLabel(DF, arg[2], label);
-    Handle(TDataStd_IntegerList) A = TDataStd_IntegerList::Set(label);
-    for(Standard_Integer i = 3; i <= nb - 1; i++) 
+    Standard_GUID guid;
+    Standard_Boolean isGuid(Standard_False);
+    if(nb > 4) {
+      Standard_Character c1(arg[3][0]), c2(arg[3][1]);
+      if(c1 == '-' && c2 == 'g') { //guid
+        if (!Standard_GUID::CheckGUIDFormat(arg[4])) {
+          di<<"DDataStd_SetIntegerList: The format of GUID is invalid\n";
+          return 1;
+        }
+        guid = Standard_GUID (arg[4]);
+        isGuid = Standard_True;
+      }
+    }
+    Standard_Integer j(0);
+    Handle(TDataStd_IntegerList) A;
+    if(!isGuid) {
+      A = TDataStd_IntegerList::Set(label);
+      j = 3;
+    }
+    else {
+      A = TDataStd_IntegerList::Set(label, guid);
+      j = 5;
+    }
+    for(Standard_Integer i = j; i <= nb - 1; i++) 
     {
       Standard_Integer ival = Draw::Atoi(arg[i]);
       A->Append(ival); 
@@ -1660,7 +1913,7 @@ static Standard_Integer DDataStd_SetIntegerList (Draw_Interpretor& di,
 } 
 
 //=======================================================================
-//function : SetRealList (DF, entry, elmt1, elmt2, ...  )
+//function : SetRealList (DF, entry, [-g guid,] elmt1, elmt2, ...  )
 //=======================================================================
 static Standard_Integer DDataStd_SetRealList (Draw_Interpretor& di,
                                               Standard_Integer nb, 
@@ -1670,12 +1923,34 @@ static Standard_Integer DDataStd_SetRealList (Draw_Interpretor& di,
   {  
     Handle(TDF_Data) DF;
     if (!DDF::GetDF(arg[1],DF))
-        return 1; 
+      return 1; 
 
     TDF_Label label;
     DDF::AddLabel(DF, arg[2], label);
-    Handle(TDataStd_RealList) A = TDataStd_RealList::Set(label);
-    for(Standard_Integer i = 3; i <= nb - 1; i++) 
+    Standard_GUID guid;
+    Standard_Boolean isGuid(Standard_False);
+    if(nb > 4) {
+      Standard_Character c1(arg[3][0]), c2(arg[3][1]);
+      if(c1 == '-' && c2 == 'g') { //guid
+        if (!Standard_GUID::CheckGUIDFormat(arg[4])) {
+          di<<"DDataStd_SetRealList: The format of GUID is invalid\n";
+          return 1;
+        }
+        guid = Standard_GUID (arg[4]);
+        isGuid = Standard_True;
+      }
+    }
+    Standard_Integer j(0);
+    Handle(TDataStd_RealList) A;
+    if(!isGuid) {
+      A = TDataStd_RealList::Set(label);
+      j = 3;
+    }
+    else {
+      A = TDataStd_RealList::Set(label, guid);
+      j = 5;
+    }
+    for(Standard_Integer i = j; i <= nb - 1; i++) 
     {
       Standard_Real fval = Draw::Atof(arg[i]);
       A->Append(fval); 
@@ -2168,36 +2443,48 @@ static Standard_Integer DDataStd_RemoveReferenceList (Draw_Interpretor& di,
 } 
 
 //=======================================================================
-//function : GetByteArray (DF, entry )
+//function : GetByteArray (DF, entry [, guid] )
 //=======================================================================
 static Standard_Integer DDataStd_GetByteArray (Draw_Interpretor& di,
-                                              Standard_Integer, 
+                                              Standard_Integer nb, 
                                               const char** arg) 
 {   
+  if (nb >= 3) 
+  {  
+    Handle(TDF_Data) DF;
+    if (!DDF::GetDF(arg[1],DF))  return 1;  
+    TDF_Label label;
+    if( !DDF::FindLabel(DF, arg[2], label) ) {
+      di << "No label for entry"  << "\n";
+      return 1;
+    }
+    Standard_GUID aGuid;
+    if(nb == 4) {
+      if (Standard_GUID::CheckGUIDFormat(arg[3])) 
+        aGuid = Standard_GUID(arg[3]);
+      else {
+        di << "Wrong GUID format"  << "\n";
+        return 1; 
+      }
+    } else
+      aGuid = TDataStd_ByteArray::GetID();
+    Handle(TDataStd_ByteArray) A;
+    if ( !label.FindAttribute(aGuid, A) ) { 
+      di << "There is no TDataStd_ByteArray  with the specified GUID at the label"  << "\n";
+      return 1;
+    }
 
-
-  Handle(TDF_Data) DF;
-  if (!DDF::GetDF(arg[1],DF))  return 1;  
-  TDF_Label label;
-  if( !DDF::FindLabel(DF, arg[2], label) ) {
-    di << "No label for entry"  << "\n";
-    return 1;
-  }
-  Handle(TDataStd_ByteArray) A;
-  if ( !label.FindAttribute(TDataStd_ByteArray::GetID(), A) ) { 
-    di << "There is no TDataStd_ByteArray at label"  << "\n";
-    return 1;
-  }
-  
-  for(Standard_Integer i = A->Lower(); i<=A->Upper(); i++){
-    //cout <<  A->Value(i)   << endl;
-    di  <<  A->Value(i);
-    if(i<A->Upper())  
-     di<<" ";
+    for(Standard_Integer i = A->Lower(); i<=A->Upper(); i++){
+      //cout <<  A->Value(i)   << endl;
+      di  <<  A->Value(i);
+      if(i<A->Upper())  
+        di<<" ";
+    }
+    di<<"\n";
+    return 0; 
   }
-  di<<"\n";
-  return 0; 
+  di << "DDataStd_GetByteArray: Error\n";
+  return 1; 
 } 
 
 //=======================================================================
@@ -2235,38 +2522,53 @@ static Standard_Integer DDataStd_GetByteArrayValue (Draw_Interpretor& di,
 } 
 
 //=======================================================================
-//function : GetBooleanArray (DF, entry )
+//function : GetBooleanArray (DF, entry [, guid] )
 //=======================================================================
 static Standard_Integer DDataStd_GetBooleanArray (Draw_Interpretor& di,
-                                                  Standard_Integer, 
+                                                  Standard_Integer nb, 
                                                   const char** arg) 
 {   
-  Handle(TDF_Data) DF;
-  if (!DDF::GetDF(arg[1],DF)) 
+  if (nb >= 3) 
+  {
+    Handle(TDF_Data) DF;
+    if (!DDF::GetDF(arg[1],DF)) 
       return 1;  
 
-  TDF_Label label;
-  if ( !DDF::FindLabel(DF, arg[2], label) ) 
-  {
-    di << "No label for entry"  << "\n";
-    return 1;
-  }
-  Handle(TDataStd_BooleanArray) A;
-  if ( !label.FindAttribute(TDataStd_BooleanArray::GetID(), A) ) 
-  {
-    di << "There is no TDataStd_BooleanArray at label"  << "\n";
-    return 1;
-  }
-  
-  for (Standard_Integer i = A->Lower(); i<=A->Upper(); i++)
-  {
-    di << (Standard_Integer) A->Value(i);
-    if (i < A->Upper())  
-     di << " ";
+    TDF_Label label;
+    if ( !DDF::FindLabel(DF, arg[2], label) ) 
+    {
+      di << "No label for entry"  << "\n";
+      return 1;
+    }
+    Standard_GUID aGuid;
+    if(nb == 4) {
+      if (Standard_GUID::CheckGUIDFormat(arg[3])) 
+        aGuid = Standard_GUID(arg[3]);
+      else {
+        di << "Wrong GUID format"  << "\n";
+        return 1; 
+      }
+    } else
+      aGuid = TDataStd_BooleanArray::GetID();
+
+    Handle(TDataStd_BooleanArray) A;
+    if ( !label.FindAttribute(aGuid, A) ) 
+    {
+      di << "There is no TDataStd_BooleanArray at label"  << "\n";
+      return 1;
+    }
+
+    for (Standard_Integer i = A->Lower(); i<=A->Upper(); i++)
+    {
+      di << (Standard_Integer) A->Value(i);
+      if (i < A->Upper())  
+        di << " ";
+    }
+    di << "\n";
+    return 0;
   }
-  di << "\n";
-  return 0; 
+  di << "DDataStd_GetBooleanArray: Error\n";
+  return 1; 
 }
 
 //=======================================================================
@@ -2329,7 +2631,7 @@ static Standard_Integer DDataStd_ChangeByteArray (Draw_Interpretor& di,
     Standard_Integer ival  = Draw::Atoi(arg[4]);
     if (ival > 255 || ival < 0) {
         di << "DDataStd_ChangeByteArray: Bad value = " <<ival << "\n";
-       return 1;
+        return 1;
       }
     Standard_Integer low = A->Lower(), up = A->Upper();
     if(low <= indx && indx <= up)
@@ -2339,22 +2641,22 @@ static Standard_Integer DDataStd_ChangeByteArray (Draw_Interpretor& di,
       Handle(TColStd_HArray1OfByte) arr;
       Standard_Integer i;
       if(indx > up) {
-       up = indx;
-       arr = new TColStd_HArray1OfByte(low, up);
-       for(i=low; i<= Arr->Upper(); i++)
-         arr->SetValue(i, Arr->Value(i));
-       for(i=Arr->Upper()+1; i<= up; i++) {
-         if(i == up)
-           arr->SetValue(i, (Standard_Byte)ival);
-         else
-           arr->SetValue(i, 0);
-       }
+        up = indx;
+        arr = new TColStd_HArray1OfByte(low, up);
+        for(i=low; i<= Arr->Upper(); i++)
+          arr->SetValue(i, Arr->Value(i));
+        for(i=Arr->Upper()+1; i<= up; i++) {
+          if(i == up)
+            arr->SetValue(i, (Standard_Byte)ival);
+          else
+            arr->SetValue(i, 0);
+        }
       } else if(indx < up) {//clip array : indx to be negative
-       up = abs(indx);
-       arr = new TColStd_HArray1OfByte(low, up);
-       for(i=low; i< up; i++)
-         arr->SetValue(i, Arr->Value(i));
-       arr->SetValue(up, (Standard_Byte)ival);
+        up = abs(indx);
+        arr = new TColStd_HArray1OfByte(low, up);
+        for(i=low; i< up; i++)
+          arr->SetValue(i, Arr->Value(i));
+        arr->SetValue(up, (Standard_Byte)ival);
       }
       A->ChangeArray(arr);
     }
@@ -2365,13 +2667,13 @@ static Standard_Integer DDataStd_ChangeByteArray (Draw_Interpretor& di,
 }
 
 //=======================================================================
-//function : GetBooleanList (DF, entry )
+//function : GetBooleanList (DF, entry [, guid])
 //=======================================================================
 static Standard_Integer DDataStd_GetBooleanList (Draw_Interpretor& di,
                                                  Standard_Integer nb, 
                                                  const char** arg) 
 {   
-  if (nb == 3) {
+  if (nb >= 3) {
     Handle(TDF_Data) DF;
     if (!DDF::GetDF(arg[1],DF)) 
       return 1;  
@@ -2382,14 +2684,24 @@ static Standard_Integer DDataStd_GetBooleanList (Draw_Interpretor& di,
       di << "No label for entry"  << "\n";
       return 1;
     }
+    Standard_GUID aGuid;
+    if(nb == 4) {
+      if (Standard_GUID::CheckGUIDFormat(arg[3])) 
+        aGuid = Standard_GUID(arg[3]);
+      else {
+        di << "Wrong GUID format"  << "\n";
+        return 1; 
+      }
+    } else
+      aGuid = TDataStd_BooleanList::GetID();
+
     Handle(TDataStd_BooleanList) A;
-    if ( !label.FindAttribute(TDataStd_BooleanList::GetID(), A) ) 
+    if ( !label.FindAttribute(aGuid, A) ) 
     {
-      di << "There is no TDataStd_BooleanList at label"  << "\n";
+      di << "There is no TDataStd_BooleanList with the specified Guid at the label"  << "\n";
       return 1;
     }
-  
+
     const TDataStd_ListOfByte& bList = A->List();
     Standard_Boolean isEmpty = (bList.Extent() > 0) ? Standard_False : Standard_True;
     if(!isEmpty) {
@@ -2400,7 +2712,7 @@ static Standard_Integer DDataStd_GetBooleanList (Draw_Interpretor& di,
       }
       di << "\n";
     } else 
-       di << "List is empty\n";
+      di << "List is empty\n";
     return 0; 
   }
   di << "DDataStd_GetBooleanList: Error\n";
@@ -2408,13 +2720,13 @@ static Standard_Integer DDataStd_GetBooleanList (Draw_Interpretor& di,
 }
 
 //=======================================================================
-//function : GetIntegerList (DF, entry )
+//function : GetIntegerList (DF, entry [, guid])
 //=======================================================================
 static Standard_Integer DDataStd_GetIntegerList (Draw_Interpretor& di,
                                                  Standard_Integer nb, 
                                                  const char** arg) 
 { 
-  if (nb == 3) {
+  if (nb >= 3) {
     Handle(TDF_Data) DF;
     if (!DDF::GetDF(arg[1],DF)) 
       return 1;  
@@ -2425,14 +2737,24 @@ static Standard_Integer DDataStd_GetIntegerList (Draw_Interpretor& di,
       di << "No label for entry"  << "\n";
       return 1;
     }
+    Standard_GUID aGuid;
+    if(nb == 4) {
+      if (Standard_GUID::CheckGUIDFormat(arg[3])) 
+        aGuid = Standard_GUID(arg[3]);
+      else {
+        di << "Wrong GUID format"  << "\n";
+        return 1; 
+      }
+    } else
+      aGuid = TDataStd_IntegerList::GetID();
+
     Handle(TDataStd_IntegerList) A;
-    if ( !label.FindAttribute(TDataStd_IntegerList::GetID(), A) ) 
+    if ( !label.FindAttribute(aGuid, A) ) 
     {
-      di << "There is no TDataStd_IntegerList at label"  << "\n";
+      di << "There is no TDataStd_IntegerList with the specified GUID at the label"  << "\n";
       return 1;
     }
-  
+
     const TColStd_ListOfInteger& iList = A->List();
     Standard_Boolean isEmpty = (iList.Extent() > 0) ? Standard_False : Standard_True;
     if(!isEmpty) {
@@ -2452,13 +2774,13 @@ static Standard_Integer DDataStd_GetIntegerList (Draw_Interpretor& di,
 }
 
 //=======================================================================
-//function : GetRealList (DF, entry )
+//function : GetRealList (DF, entry [, guid])
 //=======================================================================
 static Standard_Integer DDataStd_GetRealList (Draw_Interpretor& di,
                                               Standard_Integer nb, 
                                               const char** arg) 
 {   
-  if (nb == 3) {  
+  if (nb >= 3) {  
     Handle(TDF_Data) DF;
     if (!DDF::GetDF(arg[1],DF)) 
       return 1;  
@@ -2469,14 +2791,24 @@ static Standard_Integer DDataStd_GetRealList (Draw_Interpretor& di,
       di << "No label for entry"  << "\n";
       return 1;
     }
+    Standard_GUID aGuid;
+    if(nb == 4) {
+      if (Standard_GUID::CheckGUIDFormat(arg[3])) 
+        aGuid = Standard_GUID(arg[3]);
+      else {
+        di << "Wrong GUID format"  << "\n";
+        return 1; 
+      }
+    } else
+      aGuid = TDataStd_RealList::GetID();
+
     Handle(TDataStd_RealList) A;
-    if ( !label.FindAttribute(TDataStd_RealList::GetID(), A) ) 
+    if ( !label.FindAttribute(aGuid, A) ) 
     {
-      di << "There is no TDataStd_RealList at label"  << "\n";
+      di << "There is no TDataStd_RealList with the specified GUID at the label"  << "\n";
       return 1;
     }
-  
+
     const TColStd_ListOfReal& rList = A->List();
     Standard_Boolean isEmpty = (rList.Extent() > 0) ? Standard_False : Standard_True;
     if(!isEmpty) {
@@ -2495,13 +2827,13 @@ static Standard_Integer DDataStd_GetRealList (Draw_Interpretor& di,
 }
 
 //=======================================================================
-//function : DDataStd_GetExtStringList (DF, entry)
+//function : DDataStd_GetExtStringList (DF, entry [, guid])
 //=======================================================================
 static Standard_Integer DDataStd_GetExtStringList (Draw_Interpretor& di,
                                                  Standard_Integer nb, 
                                                  const char** arg) 
 {
-  if (nb == 3) 
+  if (nb >= 3) 
   {  
     Handle(TDF_Data) DF;
     if (!DDF::GetDF(arg[1],DF))
@@ -2513,9 +2845,19 @@ static Standard_Integer DDataStd_GetExtStringList (Draw_Interpretor& di,
       di << "No label for entry"  << "\n";
       return 1;
     }
+    Standard_GUID aGuid;
+    if(nb == 4) {
+      if (Standard_GUID::CheckGUIDFormat(arg[3])) 
+        aGuid = Standard_GUID(arg[3]);
+      else {
+        di << "Wrong GUID format"  << "\n";
+        return 1; 
+      }
+    } else
+      aGuid = TDataStd_ExtStringList::GetID();
 
     Handle(TDataStd_ExtStringList) A;
-    if ( !label.FindAttribute(TDataStd_ExtStringList::GetID(), A) ) 
+    if ( !label.FindAttribute(aGuid, A) ) 
     {
       di << "There is no TDataStd_ExtStringList at label"  << "\n";
       return 1;
@@ -2542,17 +2884,17 @@ static Standard_Integer DDataStd_GetExtStringList (Draw_Interpretor& di,
 } 
 
 //=======================================================================
-//function : DDataStd_GetReferenceList (DF, entry )
+//function : DDataStd_GetReferenceList (DF, entry [, guid])
 //=======================================================================
 static Standard_Integer DDataStd_GetReferenceList (Draw_Interpretor& di,
                                                    Standard_Integer nb, 
                                                    const char** arg) 
 {
-  if (nb == 3) 
+  if (nb >= 3) 
   {  
     Handle(TDF_Data) DF;
     if (!DDF::GetDF(arg[1],DF))
-        return 1; 
+      return 1; 
 
     TDF_Label label;
     if ( !DDF::FindLabel(DF, arg[2], label) ) 
@@ -2560,14 +2902,24 @@ static Standard_Integer DDataStd_GetReferenceList (Draw_Interpretor& di,
       di << "No label for entry"  << "\n";
       return 1;
     }
-    
+    Standard_GUID aGuid;
+    if(nb == 4) {
+      if (Standard_GUID::CheckGUIDFormat(arg[3])) 
+        aGuid = Standard_GUID(arg[3]);
+      else {
+        di << "Wrong GUID format"  << "\n";
+        return 1; 
+      }
+    } else
+      aGuid = TDataStd_ReferenceList::GetID();
+
     Handle(TDataStd_ReferenceList) A;
-    if ( !label.FindAttribute(TDataStd_ReferenceList::GetID(), A) ) 
+    if ( !label.FindAttribute(aGuid, A) ) 
     {
-      di << "There is no TDataStd_ReferenceList at label"  << "\n";
+      di << "There is no TDataStd_ReferenceList [with the specified guid] at the label"  << "\n";
       return 1;
     }
-    
+
     const TDF_LabelList& aList = A->List();
     Standard_Boolean isEmpty = (aList.Extent() > 0) ? Standard_False : Standard_True;
     if(!isEmpty) {
@@ -2689,9 +3041,9 @@ static Standard_Integer DDataStd_ChangeIntPackedMap_Add (Draw_Interpretor& di,
     if(!aHMap.IsNull()) {
       ahMap->ChangeMap().Assign(aHMap->Map());
       for(i=1; i<=aNum;i++) {
-       Standard_Integer val = Draw::Atoi(arg[i+2]);
-       if(!ahMap->Map().Contains(val))
-         ahMap->ChangeMap().Add(val);
+        Standard_Integer val = Draw::Atoi(arg[i+2]);
+        if(!ahMap->Map().Contains(val))
+          ahMap->ChangeMap().Add(val);
       }
       
       A->ChangeMap(ahMap);
@@ -2732,9 +3084,9 @@ static Standard_Integer DDataStd_ChangeIntPackedMap_Rem (Draw_Interpretor& di,
     if(!aHMap.IsNull()) {
       ahMap->ChangeMap().Assign(aHMap->Map());
       for(i=1; i<=aNum;i++) {
-       Standard_Integer val = Draw::Atoi(arg[i+2]);
-       if(ahMap->Map().Contains(val))
-         ahMap->ChangeMap().Remove(val);
+        Standard_Integer val = Draw::Atoi(arg[i+2]);
+        if(ahMap->Map().Contains(val))
+          ahMap->ChangeMap().Remove(val);
       }
       
       A->ChangeMap(ahMap);
@@ -2775,11 +3127,11 @@ static Standard_Integer DDataStd_ChangeIntPackedMap_AddRem (Draw_Interpretor& di
     if(!aHMap.IsNull()) {
       ahMap->ChangeMap().Assign(aHMap->Map());
       for(i=1; i<=aNum;i++) {
-       Standard_Integer val = Draw::Atoi(arg[i+2]);
-       if(!ahMap->Map().Contains(val))
-         ahMap->ChangeMap().Add(val);
-       else
-         ahMap->ChangeMap().Remove(val);
+        Standard_Integer val = Draw::Atoi(arg[i+2]);
+        if(!ahMap->Map().Contains(val))
+          ahMap->ChangeMap().Add(val);
+        else
+          ahMap->ChangeMap().Remove(val);
       }
       
       A->ChangeMap(ahMap);
@@ -2918,20 +3270,20 @@ static Standard_Integer DDataStd_SetAsciiString (Draw_Interpretor& di,
     TDF_Label aLabel;
     DDF::AddLabel(DF, arg[2], aLabel);
     TCollection_AsciiString aString(arg[3]);
-       Standard_GUID aGuid (TDataStd_AsciiString::GetID());
-       if(nb == 5) {
-         if (!Standard_GUID::CheckGUIDFormat(arg[4])) {
+    Standard_GUID aGuid (TDataStd_AsciiString::GetID());
+    if(nb == 5) {
+      if (!Standard_GUID::CheckGUIDFormat(arg[4])) {
         di<<"DDataStd_SetAsciiString: The format of GUID is invalid\n";
         return 1;
-         }
-         aGuid = Standard_GUID (arg[4]);
-       } 
+      }
+      aGuid = Standard_GUID (arg[4]);
+    } 
 
     Handle(TDataStd_AsciiString) anAtt = TDataStd_AsciiString::Set(aLabel, aGuid, aString);
     if(anAtt.IsNull()) {
       di << "AsciiString attribute is not found or not set"  << "\n";
       return 1;
-       }
+    }
   
     cout << "String = " << anAtt->Get().ToCString() << " is kept in DF" << endl;
     return 0; 
@@ -2959,14 +3311,14 @@ static Standard_Integer DDataStd_GetAsciiString (Draw_Interpretor& di,
       if (!Standard_GUID::CheckGUIDFormat(arg[3])) {
         di<<"DDataStd_GetAsciiString: The format of GUID is invalid\n";
         return 1;
-         }
-         aGuid = Standard_GUID(arg[3]);
-       }
-       Handle(TDataStd_AsciiString) anAtt;
-       if( !aLabel.FindAttribute(aGuid, anAtt) ) {
+      }
+      aGuid = Standard_GUID(arg[3]);
+    }
+    Handle(TDataStd_AsciiString) anAtt;
+    if( !aLabel.FindAttribute(aGuid, anAtt) ) {
       cout << "AsciiString attribute is not found or not set"  << endl;
-         return 1;
-       }
+      return 1;
+    }
 
 #ifdef DEB_DDataStd
       cout << "String = " << anAtt->Get().ToCString()  << endl;
@@ -3064,9 +3416,9 @@ static Standard_Integer DDataStd_GetNDIntegers (Draw_Interpretor& di,
 //function :  GetNDInteger(DF, entry, key [drawname])
 //=======================================================================
 static Standard_Integer DDataStd_GetNDInteger (Draw_Interpretor& di,
-                                               Standard_Integer nb, 
-                                               const char** arg) 
-{   
+                                              Standard_Integer nb, 
+                                              const char** arg) 
+{
 
   if (nb >=4) {
     Handle(TDF_Data) DF;
@@ -3088,7 +3440,7 @@ static Standard_Integer DDataStd_GetNDInteger (Draw_Interpretor& di,
     } else {
       cout << "Key = "  << arg[3]  << " Value = " <<anAtt->GetInteger(arg[3])<<endl;
       if(nb == 5) 
-       Draw::Set(arg[4], anAtt->GetInteger(arg[3]));
+        Draw::Set(arg[4], anAtt->GetInteger(arg[3]));
       return 0; 
     }
   }
@@ -3196,7 +3548,7 @@ static Standard_Integer DDataStd_GetNDReal (Draw_Interpretor& di,
     } else {
       cout << "Key = "  << arg[3]  << " Value = " <<anAtt->GetReal(arg[3])<<endl;
       if(nb == 5) 
-       Draw::Set(arg[4], anAtt->GetReal(arg[3]));
+        Draw::Set(arg[4], anAtt->GetReal(arg[3]));
       return 0; 
     }
   }
@@ -3306,7 +3658,7 @@ static Standard_Integer DDataStd_GetNDString (Draw_Interpretor& di,
       TCollection_AsciiString aValue (anAtt->GetString(arg[3]), '?');
       cout << "Key = "  << arg[3]  << " Value = " << aValue.ToCString() << endl;
       if(nb == 5) 
-       Draw::Set(arg[4], aValue.ToCString());
+        Draw::Set(arg[4], aValue.ToCString());
       return 0; 
     }
   }
@@ -3414,7 +3766,7 @@ static Standard_Integer DDataStd_GetNDByte (Draw_Interpretor& di,
     } else {
       cout << "Key = "  << arg[3]  << " Value = " <<anAtt->GetByte(arg[3])<< endl;
       if(nb == 5) 
-       Draw::Set(arg[4], anAtt->GetByte(arg[3]));
+        Draw::Set(arg[4], anAtt->GetByte(arg[3]));
       return 0; 
     }
   }
@@ -3492,14 +3844,14 @@ static Standard_Integer DDataStd_GetNDIntArrays (Draw_Interpretor& di,
       cout << "Key = "  << aStr.ToCString()<< endl;
       Handle(TColStd_HArray1OfInteger) anArrValue = itr.Value();      
       if(!anArrValue.IsNull()) {
-       Standard_Integer lower = anArrValue->Lower();
-       Standard_Integer upper = anArrValue->Upper();
-       for(Standard_Integer i = lower; i<=upper;i++) {
-         Standard_Integer aValue = anArrValue->Value(i);
-         cout << "\tValue("<<i<<") = " <<aValue<<endl;
-       }
+        Standard_Integer lower = anArrValue->Lower();
+        Standard_Integer upper = anArrValue->Upper();
+        for(Standard_Integer i = lower; i<=upper;i++) {
+          Standard_Integer aValue = anArrValue->Value(i);
+          cout << "\tValue("<<i<<") = " <<aValue<<endl;
+        }
       } else 
-        cout << "\tthe specified array is Null "<<endl;
+        cout << "\tthe specified array is Null "<<endl;
     }
     return 0; 
   }
@@ -3537,14 +3889,14 @@ static Standard_Integer DDataStd_GetNDIntArray (Draw_Interpretor& di,
 
       Handle(TColStd_HArray1OfInteger) anArrValue = anAtt->GetArrayOfIntegers(arg[3]);      
       if(!anArrValue.IsNull()) {
-       Standard_Integer lower = anArrValue->Lower();
-       Standard_Integer upper = anArrValue->Upper();
-       for(Standard_Integer i = lower; i<=upper;i++) {
-         Standard_Integer aValue = anArrValue->Value(i);
-         cout << "\tValue("<<i<<") = " <<aValue<<endl;
-       }
+        Standard_Integer lower = anArrValue->Lower();
+        Standard_Integer upper = anArrValue->Upper();
+        for(Standard_Integer i = lower; i<=upper;i++) {
+          Standard_Integer aValue = anArrValue->Value(i);
+          cout << "\tValue("<<i<<") = " <<aValue<<endl;
+        }
       } else 
-       cout << "\tthe specified array is Null or not found"<<endl;
+        cout << "\tthe specified array is Null or not found"<<endl;
       return 0; 
     }
   }
@@ -3622,14 +3974,14 @@ static Standard_Integer DDataStd_GetNDRealArrays (Draw_Interpretor& di,
       cout << "Key = "  << aStr.ToCString()<<endl;
       Handle(TColStd_HArray1OfReal) anArrValue = itr.Value();      
       if(!anArrValue.IsNull()) {
-       Standard_Integer lower = anArrValue->Lower();
-       Standard_Integer upper = anArrValue->Upper();
-       for(Standard_Integer i = lower; i<=upper;i++) {
-         Standard_Real aValue = anArrValue->Value(i);
-         cout << "\tValue("<<i<<") = " <<aValue<<endl;
-       }
+        Standard_Integer lower = anArrValue->Lower();
+        Standard_Integer upper = anArrValue->Upper();
+        for(Standard_Integer i = lower; i<=upper;i++) {
+          Standard_Real aValue = anArrValue->Value(i);
+          cout << "\tValue("<<i<<") = " <<aValue<<endl;
+        }
       } else 
-        cout << "\tthe specified array is Null "<<endl;
+        cout << "\tthe specified array is Null "<<endl;
     }
     return 0; 
   }
@@ -3667,14 +4019,14 @@ static Standard_Integer DDataStd_GetNDRealArray (Draw_Interpretor& di,
 
       Handle(TColStd_HArray1OfReal) anArrValue = anAtt->GetArrayOfReals(arg[3]);      
       if(!anArrValue.IsNull()) {
-       Standard_Integer lower = anArrValue->Lower();
-       Standard_Integer upper = anArrValue->Upper();
-       for(Standard_Integer i = lower; i<=upper;i++) {
-         Standard_Real aValue = anArrValue->Value(i);
-         cout << "\tValue("<<i<<") = " <<aValue<<endl;
-       }
+        Standard_Integer lower = anArrValue->Lower();
+        Standard_Integer upper = anArrValue->Upper();
+        for(Standard_Integer i = lower; i<=upper;i++) {
+          Standard_Real aValue = anArrValue->Value(i);
+          cout << "\tValue("<<i<<") = " <<aValue<<endl;
+        }
       } else 
-       cout << "\tthe specified array is Null or not found"<<endl;
+        cout << "\tthe specified array is Null or not found"<<endl;
       return 0; 
     }
   }
@@ -3683,34 +4035,62 @@ static Standard_Integer DDataStd_GetNDRealArray (Draw_Interpretor& di,
 }
 
 //=======================================================================
-//function : SetRefArray (DF, entry , From, To,  elmt1, elmt2, ...
+//function : SetRefArray (DF, entry , [-g Guid,] From, To,  elmt1, elmt2, ...
 //=======================================================================
 static Standard_Integer DDataStd_SetRefArray (Draw_Interpretor& di,
                                               Standard_Integer nb,
                                               const char** arg) 
 {
-  Handle(TDF_Data) DF;
-  if (!DDF::GetDF(arg[1],DF))  return 1;  
-  TDF_Label label; 
-  DDF::AddLabel(DF, arg[2], label);
-  Standard_Integer From = Draw::Atoi(arg[3]), To = Draw::Atoi( arg[4] ), j;
-  di << "RefArray with bounds from = " << From  << " to = " << To  << "\n";
+  if (nb >= 5) 
+  {  
+    Handle(TDF_Data) DF;
+    if (!DDF::GetDF(arg[1],DF))  return 1;  
+    TDF_Label label; 
+    DDF::AddLabel(DF, arg[2], label);
+    Standard_GUID guid;
+    Standard_Boolean isGuid(Standard_False);
+    Standard_Character c1(arg[3][0]), c2(arg[3][1]);
+    if(c1 == '-' && c2 == 'g') { //guid
+      if (!Standard_GUID::CheckGUIDFormat(arg[4])) {
+        di<<"DDataStd_SetRefArray: The format of GUID is invalid\n";
+        return 1;
+      }
+      guid = Standard_GUID (arg[4]);
+      isGuid = Standard_True;
+    }
+    Standard_Integer j(3);
+    if(isGuid) j = 5;
 
-  Handle(TDataStd_ReferenceArray) A = TDataStd_ReferenceArray::Set(label, From, To);
-  
-  if (nb >= 6) {
-    j = 5;
-    for(Standard_Integer i = From; i<=To; i++) { 
-      TDF_Label aRefLabel; 
-      DDF::AddLabel(DF, arg[j], aRefLabel);
-      A->SetValue(i, aRefLabel); 
-      j++;
+    if((strlen(arg[j]) > MAXLENGTH || strlen(arg[j+1]) > MAXLENGTH) || 
+      !TCollection_AsciiString (arg[j]).IsIntegerValue() || 
+      !TCollection_AsciiString (arg[j+1]).IsIntegerValue())
+    {
+      di << "DDataStd_SetRefArray: From, To may be wrong\n";
+      return 1;
     }
-  }
-  return 0;  
+    Standard_Integer From = Draw::Atoi(arg[j]), To = Draw::Atoi( arg[j+1] );
+    di << "RefArray with bounds from = " << From  << " to = " << To  << "\n";
+
+    Handle(TDataStd_ReferenceArray) A;
+    if(!isGuid) 
+      A = TDataStd_ReferenceArray::Set(label, From, To);
+    else 
+      A = TDataStd_ReferenceArray::Set(label, guid, From, To);
+
+    if ((!isGuid && nb > 5) || (isGuid && nb > 7)) {
+      j = j + 2;
+      for(Standard_Integer i = From; i<=To; i++) { 
+        TDF_Label aRefLabel; 
+        DDF::AddLabel(DF, arg[j], aRefLabel);
+        A->SetValue(i, aRefLabel); 
+        j++;
+      }
+    }
+    return 0;
+  } 
+  di << "DDataStd_SetRefArray: Error\n";
+  return 1; 
 } 
-
 //=======================================================================
 //function : SetRefArrayValue (DF, entry, index, value)
 //=======================================================================
@@ -3745,75 +4125,102 @@ static Standard_Integer DDataStd_SetRefArrayValue (Draw_Interpretor&,
 } 
 
 //=======================================================================
-//function : GetRefArray (DF, entry )
+//function : GetRefArray (DF, entry [, guid])
 //=======================================================================
 static Standard_Integer DDataStd_GetRefArray (Draw_Interpretor& di,
-                                              Standard_Integer, 
+                                              Standard_Integer nb, 
                                               const char** arg) 
 {   
+  if (nb >= 3) 
+  {
+    Handle(TDF_Data) DF;
+    if (!DDF::GetDF(arg[1],DF))  return 1;  
+    TDF_Label label;
+    if( !DDF::FindLabel(DF, arg[2], label) ) {
+      di << "No label for entry" << "\n";
+      return 1;
+    }
+    Standard_GUID aGuid;
+    if(nb == 4) {
+      if (Standard_GUID::CheckGUIDFormat(arg[3])) 
+        aGuid = Standard_GUID(arg[3]);
+      else {
+        di << "Wrong GUID format" << "\n";
+        return 1; 
+      }
+    } else
+      aGuid = TDataStd_ReferenceArray::GetID();
 
-  Handle(TDF_Data) DF;
-  if (!DDF::GetDF(arg[1],DF))  return 1;  
-  TDF_Label label;
-  if( !DDF::FindLabel(DF, arg[2], label) ) {
-    di << "No label for entry"  << "\n";
-    return 1;
-  }
-  Handle(TDataStd_ReferenceArray) A;
-  if ( !label.FindAttribute(TDataStd_ReferenceArray::GetID(), A) ) { 
-    di << "There is no TDataStd_ReferenceArray under label"  << "\n";
-    return 1;
-  }
-  
-  for(Standard_Integer i = A->Lower(); i<=A->Upper(); i++){ 
-    const TDF_Label& aLabel = A->Value(i);
-    TCollection_AsciiString entry;
-    TDF_Tool::Entry(aLabel, entry);
-    di  <<  entry.ToCString();
-    if(i<A->Upper())  
-      di<<" ";
-  }
-  di<<"\n";
-  return 0; 
-} 
+    Handle(TDataStd_ReferenceArray) A;
+    if ( !label.FindAttribute(aGuid, A) ) { 
+      di << "There is no TDataStd_ReferenceArray at the label" << "\n";
+      return 1;
+    }
 
+    for(Standard_Integer i = A->Lower(); i<=A->Upper(); i++){ 
+      const TDF_Label& aLabel = A->Value(i);
+      TCollection_AsciiString entry;
+      TDF_Tool::Entry(aLabel, entry);
+      di  <<  entry.ToCString();
+      if(i<A->Upper())  
+        di<<" ";
+    }
+    di<<"\n";
+    return 0; 
+  } 
+  di << "TDataStd_ReferenceArray: Error\n";
+  return 1; 
+}
 //=======================================================================
 //function : GetRefArrayValue (DF, entry, index)
 //=======================================================================
 static Standard_Integer DDataStd_GetRefArrayValue (Draw_Interpretor& di,
-                                                   Standard_Integer, 
+                                                   Standard_Integer nb, 
                                                    const char** arg) 
 {
-  Handle(TDF_Data) DF;
-  if (!DDF::GetDF(arg[1],DF))
+  if (nb >= 3) 
+  {
+    Handle(TDF_Data) DF;
+    if (!DDF::GetDF(arg[1],DF))
       return 1;
 
-  TDF_Label label;
-  if (!DDF::FindLabel(DF, arg[2], label)) {
-    di << "No label for entry"  << "\n";
-    return 1;
-  }
-  Handle(TDataStd_ReferenceArray) A;
-  if ( !label.FindAttribute(TDataStd_ReferenceArray::GetID(), A) ) { 
-    di << "There is no TDataStd_ReferenceArray under label"  << "\n";
-    return 1;
-  }
-  
-  Standard_Integer index = Draw::Atoi(arg[3]);
-  if (index < A->Lower() || index > A->Upper()) {
-    di << "Index is out of range\n";
-    return 1;
-  } else {
-    const TDF_Label& value = A->Value(index);
-    TCollection_AsciiString entry;
-    TDF_Tool::Entry(value, entry);
-    di << entry.ToCString() << "\n";
-  }
+    TDF_Label label;
+    if (!DDF::FindLabel(DF, arg[2], label)) {
+      di << "No label for entry"  << "\n";
+      return 1;
+    }
+    Standard_GUID aGuid;
+    if(nb == 4) {
+      if (Standard_GUID::CheckGUIDFormat(arg[3])) 
+        aGuid = Standard_GUID(arg[3]);
+      else {
+        di << "Wrong GUID format"  << "\n";
+        return 1; 
+      }
+    } else
+      aGuid = TDataStd_ReferenceArray::GetID();
 
-  return 0; 
-} 
+    Handle(TDataStd_ReferenceArray) A;
+    if ( !label.FindAttribute(aGuid, A) ) { 
+      di << "There is no TDataStd_ReferenceArray at the label"  << "\n";
+      return 1;
+    }
+
+    Standard_Integer index = Draw::Atoi(arg[3]);
+    if (index < A->Lower() || index > A->Upper()) {
+      di << "Index is out of range\n";
+      return 1;
+    } else {
+      const TDF_Label& value = A->Value(index);
+      TCollection_AsciiString entry;
+      TDF_Tool::Entry(value, entry);
+      di << entry.ToCString() << "\n";
+    }
+    return 0; 
+  } 
+  di << "TDataStd_ReferenceArray: Error\n";
+  return 1; 
+}
 
 //=======================================================================
 //function : DDataStd_SetTriangulation
@@ -3925,7 +4332,7 @@ void DDataStd::BasicCommands (Draw_Interpretor& theCommands)
                    __FILE__, DDataStd_SetInteger, g);
 
   theCommands.Add ("SetIntArray", 
-                   "SetIntArray (DF, entry, isDelta, From, To, [elmt1, elmt2, ...])",
+                   "SetIntArray (DF, entry, isDelta, [-g Guid,] From, To [, elmt1, elmt2, ...])",
                    __FILE__, DDataStd_SetIntArray, g);
 
   theCommands.Add ("SetIntArrayValue", 
@@ -3937,7 +4344,7 @@ void DDataStd::BasicCommands (Draw_Interpretor& theCommands)
                    __FILE__, DDataStd_SetReal, g); 
 
   theCommands.Add ("SetRealArray", 
-                   "SetRealArray (DF, entry, isDelta, From, To, [elmt1, elmt2, ...])",
+                   "SetRealArray (DF, entry, isDelta, [-g Guid,] From, To [, elmt1, elmt2, ...])",
                    __FILE__, DDataStd_SetRealArray, g);
 
   theCommands.Add ("SetRealArrayValue", 
@@ -3945,7 +4352,7 @@ void DDataStd::BasicCommands (Draw_Interpretor& theCommands)
                    __FILE__, DDataStd_SetRealArrayValue, g);
 
   theCommands.Add ("SetByteArray", 
-                   "SetByteArray (DF, entry, isDelta, From, To, [elmt1, elmt2, ...])",
+                   "SetByteArray (DF, entry, isDelta, [-g Guid,] From, To [, elmt1, elmt2, ...])",
                    __FILE__, DDataStd_SetByteArray, g);
 
   theCommands.Add ("SetByteArrayValue", 
@@ -3953,7 +4360,7 @@ void DDataStd::BasicCommands (Draw_Interpretor& theCommands)
                    __FILE__, DDataStd_SetByteArrayValue, g);
 
   theCommands.Add ("SetExtStringArray", 
-                   "SetExtStringArray (DF, entry, isDelta, From, To, [elmt1, elmt2, ...])",
+                   "SetExtStringArray (DF, entry, isDelta, [-g Guid,] From, To [, elmt1, elmt2, ...])",
                    __FILE__, DDataStd_SetExtStringArray, g);
 
   theCommands.Add ("SetExtStringArrayValue", 
@@ -3961,7 +4368,7 @@ void DDataStd::BasicCommands (Draw_Interpretor& theCommands)
                    __FILE__, DDataStd_SetExtStringArrayValue, g);
 
   theCommands.Add ("SetRefArray", 
-                   "SetRefArray (DF, entry,  From, To, [lab1, lab2, ...])",
+                   "SetRefArray (DF, entry, [-g Guid,] From, To [, lab1, lab2, ...])",
                    __FILE__, DDataStd_SetRefArray, g);
 
   theCommands.Add ("SetRefArrayValue", 
@@ -3993,7 +4400,7 @@ void DDataStd::BasicCommands (Draw_Interpretor& theCommands)
                    __FILE__, DDataStd_SetAsciiString, g);
 
   theCommands.Add ("SetBooleanArray", 
-                   "SetBooleanArray (DF, entry, isDelta, From, To, [elmt1, elmt2, ...])",
+                   "SetBooleanArray (DF, entry, [-g Guid,] From, To [, elmt1, elmt2, ...])",
                    __FILE__, DDataStd_SetBooleanArray, g);
 
   theCommands.Add ("SetBooleanArrayValue", 
@@ -4001,32 +4408,30 @@ void DDataStd::BasicCommands (Draw_Interpretor& theCommands)
                    __FILE__, DDataStd_SetBooleanArrayValue, g);
 
   theCommands.Add ("SetBooleanList", 
-                   "SetBooleanList (DF, entry, elmt1, elmt2, ...  )",
+                   "SetBooleanList (DF, entry, [-g Guid,] elmt1, elmt2, ...  )",
                    __FILE__, DDataStd_SetBooleanList, g);
 
   theCommands.Add ("SetIntegerList", 
-                   "SetIntegerList (DF, entry, elmt1, elmt2, ...  )",
+                   "SetIntegerList (DF, entry, [-g Guid,] elmt1, elmt2, ...  )",
                    __FILE__, DDataStd_SetIntegerList, g);
 
   theCommands.Add ("SetRealList", 
-                   "SetRealList (DF, entry, elmt1, elmt2, ...  )",
+                   "SetRealList (DF, entry, [-g guid,] elmt1, elmt2, ...  )",
                    __FILE__, DDataStd_SetRealList, g);
 
    theCommands.Add ("SetExtStringList", 
-                   "SetExtStringList (DF, entry, elmt1, elmt2, ...  )",
+                   "SetExtStringList (DF, entry,[-g Guid,] elmt1, elmt2, ...  )",
                    __FILE__, DDataStd_SetExtStringList, g);
 
    theCommands.Add ("SetReferenceList", 
-                   "SetReferenceList (DF, entry, elmt1, elmt2, ...  )",
+                   "SetReferenceList (DF, entry, [-g Guid,] elmt1, elmt2, ...  )",
                    __FILE__, DDataStd_SetReferenceList, g);
 
-  theCommands.Add ("SetTriangulation", 
+   theCommands.Add ("SetTriangulation", 
                    "SetTriangulation (DF, entry, face) - adds label with passed entry to \
                     DF and put an attribute with the triangulation from passed face",
                    __FILE__, DDataStd_SetTriangulation, g);
 
-   // Insert before and after (for lists)
-
    theCommands.Add ("InsertBeforeExtStringList", 
                    "InsertBeforeExtStringList (DF, entry, index, value )",
                    __FILE__, DDataStd_InsertBeforeExtStringList, g);
@@ -4098,7 +4503,7 @@ void DDataStd::BasicCommands (Draw_Interpretor& theCommands)
                     __FILE__, DDataStd_GetInteger, g);
 
   theCommands.Add ("GetIntArray", 
-                   "GetIntArray (DF, entry )",
+                   "GetIntArray (DF, entry [, guid])",
                    __FILE__, DDataStd_GetIntArray, g);
 
   theCommands.Add ("GetIntArrayValue", 
@@ -4106,7 +4511,7 @@ void DDataStd::BasicCommands (Draw_Interpretor& theCommands)
                    __FILE__, DDataStd_GetIntArrayValue, g);
 
   theCommands.Add ("GetRealArray", 
-                   "GetRealArray (DF, entry )",
+                   "GetRealArray (DF, entry [, guid])",
                    __FILE__, DDataStd_GetRealArray, g);
 
   theCommands.Add ("GetRealArrayValue", 
@@ -4114,7 +4519,7 @@ void DDataStd::BasicCommands (Draw_Interpretor& theCommands)
                    __FILE__, DDataStd_GetRealArrayValue, g);
 
   theCommands.Add ("GetByteArray", 
-                   "GetByteArray (DF, entry )",
+                   "GetByteArray (DF, entry [, guid])",
                    __FILE__, DDataStd_GetByteArray, g);
 
   theCommands.Add ("GetByteArrayValue", 
@@ -4122,7 +4527,7 @@ void DDataStd::BasicCommands (Draw_Interpretor& theCommands)
                    __FILE__, DDataStd_GetByteArrayValue, g);
 
   theCommands.Add ("GetExtStringArray", 
-                   "GetExtStringArray (DF, entry )",
+                   "GetExtStringArray (DF, entry [, guid])",
                    __FILE__, DDataStd_GetExtStringArray, g);
 
   theCommands.Add ("GetExtStringArrayValue", 
@@ -4130,7 +4535,7 @@ void DDataStd::BasicCommands (Draw_Interpretor& theCommands)
                    __FILE__, DDataStd_GetExtStringArrayValue, g);
 
   theCommands.Add ("GetRefArray", 
-                   "GetRefArray (DF, entry )",
+                   "GetRefArray (DF, entry [, guid])",
                    __FILE__, DDataStd_GetRefArray, g);
 
   theCommands.Add ("GetRefArrayValue", 
@@ -4175,7 +4580,7 @@ void DDataStd::BasicCommands (Draw_Interpretor& theCommands)
                    __FILE__, DDataStd_DumpRelation, g);
 
   theCommands.Add ("GetBooleanArray", 
-                   "GetBooleanArray (DF, entry )",
+                   "GetBooleanArray (DF, entry [, guid])",
                    __FILE__, DDataStd_GetBooleanArray, g);
 
   theCommands.Add ("GetBooleanArrayValue", 
@@ -4183,23 +4588,23 @@ void DDataStd::BasicCommands (Draw_Interpretor& theCommands)
                    __FILE__, DDataStd_GetBooleanArrayValue, g);
 
   theCommands.Add ("GetBooleanList", 
-                   "GetBooleanList (DF, entry )",
+                   "GetBooleanList (DF, entry [, guid])",
                    __FILE__, DDataStd_GetBooleanList, g);
 
   theCommands.Add ("GetIntegerList", 
-                   "GetIntegerList (DF, entry )",
+                   "GetIntegerList (DF, entry [, guid])",
                    __FILE__, DDataStd_GetIntegerList, g);
 
   theCommands.Add ("GetRealList", 
-                   "GetRealList (DF, entry )",
+                   "GetRealList (DF, entry [, guid])",
                    __FILE__, DDataStd_GetRealList, g);
 
   theCommands.Add ("GetExtStringList", 
-                   "GetExtStringList (DF, entry)",
+                   "GetExtStringList (DF, entry [, guid])",
                    __FILE__, DDataStd_GetExtStringList, g);
 
    theCommands.Add ("GetReferenceList", 
-                    "GetReferenceList (DF, entry)",
+                    "GetReferenceList (DF, entry [, guid])",
                    __FILE__, DDataStd_GetReferenceList, g);
 
 // ========================= UTF =====================================
index 383fb0c..768abb9 100644 (file)
@@ -23,7 +23,6 @@
 #include <Standard_Integer.hxx>
 
 class Standard_ErrorHandler;
-class Standard_GUID;
 class Standard_Persistent;
 class Standard_Transient;
 class Standard_Failure;
index e7b1851..3d39075 100644 (file)
@@ -17,7 +17,6 @@
 #ifndef _Standard_GUID_HeaderFile
 #define _Standard_GUID_HeaderFile
 
-#include <Standard.hxx>
 #include <Standard_DefineAlloc.hxx>
 #include <Standard_Handle.hxx>
 
index 7e30016..9f39588 100644 (file)
@@ -18,7 +18,6 @@
 #include <TDF_Data.hxx>
 #include <TDF_Attribute.hxx>
 
-
 //! Create a transient label tree from persistent data
 class StdLPersistent_Data::Parser
 {
@@ -44,10 +43,12 @@ public:
       // read persistent attribute
       Handle(StdObjMgt_Persistent)& aPAttrib = myAttribIter.ChangeValue();
       myAttribIter.Next();
-
       // create transient attribute and add it to the label
-      if (aPAttrib)
-        theLabel.AddAttribute (aPAttrib->CreateAttribute());
+      if (aPAttrib) {
+        Handle (TDF_Attribute) anAtt = aPAttrib->CreateAttribute();
+        anAtt->SetID();
+        theLabel.AddAttribute (anAtt);
+      }
     }
 
     // Read child labels count
index ac2fe9e..7a97ae9 100644 (file)
@@ -140,7 +140,14 @@ public:
   
   //! Returns the ID of the attribute.
   Standard_EXPORT virtual const Standard_GUID& ID() const = 0;
-  
+
+  //! Sets specific ID of the attribute (supports several attributes 
+  //! of one type at the same label feature).
+  Standard_EXPORT virtual void SetID(const Standard_GUID& theGuid);
+
+  //! Sets default ID defined in nested class (to be used for attributes having User ID feature).
+  Standard_EXPORT virtual void SetID();
+
   //! Returns   the   label to which  the   attribute is
   //! attached. If the  label is not  included in a  DF,
   //! the label is null. See Label.
index 0d382e6..98d272d 100644 (file)
@@ -57,5 +57,13 @@ inline Standard_Boolean TDF_Attribute::IsForgotten() const
 
 // operator <<
 inline Standard_OStream& operator << (Standard_OStream& anOS,
-                              const Handle(TDF_Attribute)& anAtt)
+                                      const Handle(TDF_Attribute)& anAtt)
 { return anAtt->Dump(anOS); }
+
+//=======================================================================
+inline void TDF_Attribute::SetID(const Standard_GUID& )
+{}
+
+//=======================================================================
+inline void TDF_Attribute::SetID()
+{}
\ No newline at end of file
index 18a662c..2a17a47 100644 (file)
@@ -108,7 +108,7 @@ void TDF_CopyTool::Copy
     if (theLabMap.IsBound(sLab)) {
       TDF_Label tIns(theLabMap.Find(sLab));
       TDF_CopyTool::CopyLabels(sLab,tIns,
-                              theLabMap,theAttMap,srcLabs,srcAtts);
+        theLabMap,theAttMap,srcLabs,srcAtts);
     }
     // if not bound : do nothing!
   }
@@ -127,7 +127,7 @@ void TDF_CopyTool::Copy
       // 2 - The target attribute is present BUT its privilege over the
       // source one must be ignored. The source attribute can be copied.
       if ((sAtt != tAtt) && aPrivilegeFilter.IsIgnored(tAtt->ID()))
-       sAtt->Paste(tAtt,aRelocationTable);
+        sAtt->Paste(tAtt,aRelocationTable);
     }
   }
 }
@@ -148,7 +148,7 @@ void TDF_CopyTool::CopyLabels
  const TDF_AttributeMap& aSrcAttributeMap)
 {
   TDF_CopyTool::CopyAttributes(aSLabel,aTargetLabel,
-                              aAttMap,aSrcAttributeMap);
+    aAttMap,aSrcAttributeMap);
 
   // Does the same for the children.
   for (TDF_ChildIterator childItr(aSLabel); childItr.More(); childItr.Next()){
@@ -157,13 +157,12 @@ void TDF_CopyTool::CopyLabels
       TDF_Label childTIns = aTargetLabel.FindChild(childSLab.Tag());
       aLabMap.Bind(childSLab,childTIns);
       TDF_CopyTool::CopyLabels(childSLab,childTIns,
-                              aLabMap,aAttMap,
-                              aSrcLabelMap,aSrcAttributeMap);
+        aLabMap,aAttMap,
+        aSrcLabelMap,aSrcAttributeMap);
     }
   }
 }
 
-
 //=======================================================================
 //function : CopyAttributes
 //purpose  : Internal attribute copy method.
@@ -184,17 +183,19 @@ void TDF_CopyTool::CopyAttributes
     if (aSrcAttributeMap.Contains(sAtt)) {
       const Standard_GUID& id = sAtt->ID();
       if (!aTargetLabel.FindAttribute(id,tAtt)) {
-       tAtt = sAtt->NewEmpty();
-       aTargetLabel.AddAttribute(tAtt);
-       aAttMap.Bind(sAtt,tAtt);
+        tAtt = sAtt->NewEmpty();
+        if(tAtt->ID() != id) 
+          tAtt->SetID(id);//
+        aTargetLabel.AddAttribute(tAtt);
+        aAttMap.Bind(sAtt,tAtt);
       }
       else {
-       // Some attributes have the same ID, but are different and
-       // exclusive. This obliged to test the dynamic type identity.
-       if (tAtt->IsInstance(sAtt->DynamicType()))
-         aAttMap.Bind(sAtt,tAtt);
-       else
-         throw Standard_TypeMismatch("TDF_CopyTool: Cannot paste to a different type attribute.");
+        // Some attributes have the same ID, but are different and
+        // exclusive. This obliged to test the dynamic type identity.
+        if (tAtt->IsInstance(sAtt->DynamicType()))
+          aAttMap.Bind(sAtt,tAtt);
+        else
+          throw Standard_TypeMismatch("TDF_CopyTool: Cannot paste to a different type attribute.");
       }
     }
   }
index bd8ad05..72374cf 100644 (file)
@@ -128,6 +128,15 @@ void TDataStd_AsciiString::SetID( const Standard_GUID&  theGuid)
 }
 
 //=======================================================================
+//function : SetID
+//purpose  : sets default ID
+//=======================================================================
+void TDataStd_AsciiString::SetID()
+{
+  Backup();
+  myID = GetID();
+}
+//=======================================================================
 //function : NewEmpty
 //purpose  : 
 //=======================================================================
index 54c8207..c224ada 100644 (file)
@@ -62,7 +62,10 @@ public:
   Standard_EXPORT void Set (const TCollection_AsciiString& S);
   
   //! Sets the explicit user defined GUID  to the attribute.
-  Standard_EXPORT void SetID (const Standard_GUID& guid);
+  Standard_EXPORT void SetID (const Standard_GUID& guid) Standard_OVERRIDE;
+
+  //! Sets default GUID for the attribute.
+  Standard_EXPORT void SetID() Standard_OVERRIDE;
 
   Standard_EXPORT const TCollection_AsciiString& Get() const;
   
index 39b0df2..b1e0b2d 100644 (file)
@@ -60,6 +60,30 @@ const Standard_GUID& TDataStd_BooleanArray::GetID()
 }
 
 //=======================================================================
+//function : SetAttr
+//purpose  : Implements Set functionality
+//=======================================================================
+static Handle(TDataStd_BooleanArray) SetAttr(const TDF_Label&       label,
+                                             const Standard_Integer lower,
+                                             const Standard_Integer upper,
+                                             const Standard_GUID&   theGuid) 
+{
+  Handle(TDataStd_BooleanArray) A;
+  if (!label.FindAttribute (theGuid, A)) 
+  {
+    A = new TDataStd_BooleanArray;
+    A->SetID(theGuid);
+    A->Init (lower, upper); 
+    label.AddAttribute(A);
+  }
+  else if (lower != A->Lower() || upper != A->Upper())
+  {
+    A->Init(lower, upper);
+  }
+  return A;
+}
+
+//=======================================================================
 //function : TDataStd_BooleanArray
 //purpose  : Empty Constructor
 //=======================================================================
@@ -73,14 +97,13 @@ TDataStd_BooleanArray::TDataStd_BooleanArray()
 //purpose  : 
 //=======================================================================
 void TDataStd_BooleanArray::Init(const Standard_Integer lower,
-                                const Standard_Integer upper)
+                                 const Standard_Integer upper)
 {
+  Standard_RangeError_Raise_if(upper < lower,"TDataStd_BooleanArray::Init");
   Backup();
-
   myLower = lower;
   myUpper = upper;
-  if (myUpper >= myLower)
-    myValues = new TColStd_HArray1OfByte(0, Length() >> 3, 0/*initialize to FALSE*/);
+  myValues = new TColStd_HArray1OfByte(0, Length() >> 3, 0/*initialize to FALSE*/);
 }
 
 //=======================================================================
@@ -88,30 +111,31 @@ void TDataStd_BooleanArray::Init(const Standard_Integer lower,
 //purpose  : 
 //=======================================================================
 Handle(TDataStd_BooleanArray) TDataStd_BooleanArray::Set(const TDF_Label&       label,
-                                                        const Standard_Integer lower,
-                                                        const Standard_Integer upper) 
+                                                         const Standard_Integer lower,
+                                                         const Standard_Integer upper) 
 {
-  Handle(TDataStd_BooleanArray) A;
-  if (!label.FindAttribute (TDataStd_BooleanArray::GetID(), A)) 
-  {
-    A = new TDataStd_BooleanArray;
-    A->Init (lower, upper); 
-    label.AddAttribute(A);
-  }
-  else if (lower != A->Lower() || upper != A->Upper())
-  {
-    A->Init(lower, upper);
-  }
-  return A;
+  return SetAttr(label, lower, upper, GetID());
 }
 
 
 //=======================================================================
+//function : Set
+//purpose  : Set user defined attribute with specific ID
+//=======================================================================
+Handle(TDataStd_BooleanArray) TDataStd_BooleanArray::Set(const TDF_Label&       label,
+                                                         const Standard_GUID&   theGuid,
+                                                         const Standard_Integer lower,
+                                                         const Standard_Integer upper)
+{
+  return SetAttr(label, lower, upper, theGuid);
+}
+
+//=======================================================================
 //function : SetValue
 //purpose  : 
 //=======================================================================
 void TDataStd_BooleanArray::SetValue (const Standard_Integer index,
-                                     const Standard_Boolean value) 
+                                      const Standard_Boolean value) 
 {
 
   if (myValues.IsNull()) 
@@ -204,10 +228,31 @@ void TDataStd_BooleanArray::SetInternalArray (const Handle(TColStd_HArray1OfByte
 //=======================================================================
 const Standard_GUID& TDataStd_BooleanArray::ID () const 
 { 
-  return GetID(); 
+  return myID; 
 }
 
 //=======================================================================
+//function : SetID
+//purpose  :
+//=======================================================================
+
+void TDataStd_BooleanArray::SetID( const Standard_GUID&  theGuid)
+{  
+  if(myID == theGuid) return;
+  Backup();
+  myID = theGuid;
+}
+
+//=======================================================================
+//function : SetID
+//purpose  : sets default ID
+//=======================================================================
+void TDataStd_BooleanArray::SetID()
+{
+  Backup();
+  myID = GetID();
+}
+//=======================================================================
 //function : NewEmpty
 //purpose  : 
 //=======================================================================
@@ -234,6 +279,7 @@ void TDataStd_BooleanArray::Restore(const Handle(TDF_Attribute)& With)
     {
       myValues->SetValue(i, with_array.Value(i));
     }
+    myID = anArray->ID();
   }
   else
   {
@@ -256,9 +302,10 @@ void TDataStd_BooleanArray::Paste (const Handle(TDF_Attribute)& Into,
       anArray->Init(myLower, myUpper);
       for (Standard_Integer i = myLower; i <= myUpper; i++)
       {
-       anArray->SetValue(i, Value(i));
+        anArray->SetValue(i, Value(i));
       }
     }
+    anArray->SetID(myID);
   }
 }
 
@@ -268,6 +315,10 @@ void TDataStd_BooleanArray::Paste (const Handle(TDF_Attribute)& Into,
 //=======================================================================
 Standard_OStream& TDataStd_BooleanArray::Dump (Standard_OStream& anOS) const
 {  
-  anOS << "BooleanArray";
+  anOS << "\nBooleanArray: ";
+  Standard_Character sguid[Standard_GUID_SIZE_ALLOC];
+  myID.ToCString(sguid);
+  anOS << sguid;
+  anOS <<endl;
   return anOS;
 }
index 0080cd6..9a48804 100644 (file)
@@ -24,6 +24,7 @@
 #include <TDF_Attribute.hxx>
 #include <Standard_Boolean.hxx>
 #include <Standard_OStream.hxx>
+#include <Standard_GUID.hxx>
 class Standard_GUID;
 class TDF_Label;
 class TDF_Attribute;
@@ -45,22 +46,33 @@ public:
   //! Returns an ID for array.
   Standard_EXPORT static const Standard_GUID& GetID();
   
-  //! Finds or creates an attribute with the array.
+  //! Finds or creates an attribute with internal boolean array.
   Standard_EXPORT static Handle(TDataStd_BooleanArray) Set (const TDF_Label& label, const Standard_Integer lower, const Standard_Integer upper);
-  
+
+  //! Finds or creates an attribute with the array using explicit user defined <guid>.
+  Standard_EXPORT static Handle(TDataStd_BooleanArray) Set (const TDF_Label& label, const Standard_GUID&   theGuid, 
+                                                            const Standard_Integer lower, const Standard_Integer upper);
+
   //! Initialize the inner array with bounds from <lower> to <upper>
   Standard_EXPORT void Init (const Standard_Integer lower, const Standard_Integer upper);
   
   //! Sets the <Index>th element of the array to <Value>
   //! OutOfRange exception is raised if <Index> doesn't respect Lower and Upper bounds of the internal  array.
   Standard_EXPORT void SetValue (const Standard_Integer index, const Standard_Boolean value);
-  
+
+  //! Sets the explicit GUID (user defined) for the attribute.
+  Standard_EXPORT void SetID( const Standard_GUID&  theGuid) Standard_OVERRIDE;
+
+  //! Sets default GUID for the attribute.
+  Standard_EXPORT void SetID() Standard_OVERRIDE;
+
   //! Return the value of the <Index>th element of the array.
   Standard_EXPORT Standard_Boolean Value (const Standard_Integer Index) const;
-Standard_Boolean operator () (const Standard_Integer Index) const
-{
-  return Value(Index);
-}
+
+  Standard_Boolean operator () (const Standard_Integer Index) const
+  {
+    return Value(Index);
+  }
   
   //! Returns the lower boundary of the array.
   Standard_EXPORT Standard_Integer Lower() const;
@@ -103,7 +115,7 @@ private:
   Handle(TColStd_HArray1OfByte) myValues;
   Standard_Integer myLower;
   Standard_Integer myUpper;
-
+  Standard_GUID myID;
 
 };
 
index a4920c3..317cf0b 100644 (file)
@@ -35,6 +35,23 @@ const Standard_GUID& TDataStd_BooleanList::GetID()
 }
 
 //=======================================================================
+//function : SetAttr
+//purpose  : Implements Set functionality
+//=======================================================================
+static Handle(TDataStd_BooleanList) SetAttr(const TDF_Label&       label,
+                                            const Standard_GUID&   theGuid) 
+{
+  Handle(TDataStd_BooleanList) A;
+  if (!label.FindAttribute (theGuid, A)) 
+  {
+    A = new TDataStd_BooleanList;
+    A->SetID(theGuid);
+    label.AddAttribute(A);
+  }
+  return A;
+}
+
+//=======================================================================
 //function : TDataStd_BooleanList
 //purpose  : Empty Constructor
 //=======================================================================
@@ -49,16 +66,19 @@ TDataStd_BooleanList::TDataStd_BooleanList()
 //=======================================================================
 Handle(TDataStd_BooleanList) TDataStd_BooleanList::Set(const TDF_Label& label) 
 {
-  Handle(TDataStd_BooleanList) A;
-  if (!label.FindAttribute (TDataStd_BooleanList::GetID(), A)) 
-  {
-    A = new TDataStd_BooleanList;
-    label.AddAttribute(A);
-  }
-  return A;
+  return SetAttr(label, GetID());
 }
 
 //=======================================================================
+//function : Set
+//purpose  : Set user defined attribute with specific ID
+//=======================================================================
+Handle(TDataStd_BooleanList) TDataStd_BooleanList::Set(const TDF_Label& label,
+                                                       const Standard_GUID&   theGuid) 
+{
+  return SetAttr(label, theGuid); 
+}
+//=======================================================================
 //function : IsEmpty
 //purpose  : 
 //=======================================================================
@@ -207,7 +227,30 @@ Standard_Boolean TDataStd_BooleanList::Remove(const Standard_Integer index)
 //=======================================================================
 const Standard_GUID& TDataStd_BooleanList::ID () const 
 { 
-  return GetID(); 
+  return myID; 
+}
+
+//=======================================================================
+//function : SetID
+//purpose  :
+//=======================================================================
+
+void TDataStd_BooleanList::SetID( const Standard_GUID&  theGuid)
+{  
+  if(myID == theGuid) return;
+  Backup();
+  myID = theGuid;
+}
+
+//=======================================================================
+//function : SetID
+//purpose  : sets default ID
+//=======================================================================
+
+void TDataStd_BooleanList::SetID()
+{  
+  Backup();
+  myID = GetID();
 }
 
 //=======================================================================
@@ -232,6 +275,7 @@ void TDataStd_BooleanList::Restore(const Handle(TDF_Attribute)& With)
   {
     myList.Append (itr.Value() ? 1 : 0);
   }
+  myID = aList->ID();
 }
 
 //=======================================================================
@@ -248,6 +292,7 @@ void TDataStd_BooleanList::Paste (const Handle(TDF_Attribute)& Into,
   {
     aList->Append (itr.Value() != 0);
   }
+  aList->SetID(myID);
 }
 
 //=======================================================================
@@ -256,6 +301,10 @@ void TDataStd_BooleanList::Paste (const Handle(TDF_Attribute)& Into,
 //=======================================================================
 Standard_OStream& TDataStd_BooleanList::Dump (Standard_OStream& anOS) const
 {  
-  anOS << "BooleanList";
+  anOS << "\nBooleanList: ";
+  Standard_Character sguid[Standard_GUID_SIZE_ALLOC];
+  myID.ToCString(sguid);
+  anOS << sguid;
+  anOS << endl;
   return anOS;
 }
index 8bac5e4..3879cfd 100644 (file)
@@ -24,6 +24,8 @@
 #include <Standard_Boolean.hxx>
 #include <Standard_Integer.hxx>
 #include <Standard_OStream.hxx>
+#include <Standard_GUID.hxx>
+
 class Standard_GUID;
 class TDF_Label;
 class TDF_Attribute;
@@ -47,6 +49,9 @@ public:
   
   //! Finds or creates a list of boolean values attribute.
   Standard_EXPORT static Handle(TDataStd_BooleanList) Set (const TDF_Label& label);
+
+  //! Finds or creates a list of boolean values attribute with explicit user defined <guid>.
+  Standard_EXPORT static Handle(TDataStd_BooleanList) Set (const TDF_Label& label, const Standard_GUID& theGuid);
   
   Standard_EXPORT TDataStd_BooleanList();
   
@@ -78,7 +83,13 @@ public:
   
   //! Removes a value at <index> position.
   Standard_EXPORT Standard_Boolean Remove (const Standard_Integer index);
-  
+
+  //! Sets the explicit GUID (user defined) for the attribute.
+  Standard_EXPORT void SetID( const Standard_GUID&  theGuid) Standard_OVERRIDE;
+
+  //! Sets default GUID for the attribute.
+  Standard_EXPORT void SetID() Standard_OVERRIDE;
+
   Standard_EXPORT const Standard_GUID& ID() const Standard_OVERRIDE;
   
   Standard_EXPORT void Restore (const Handle(TDF_Attribute)& With) Standard_OVERRIDE;
@@ -103,7 +114,7 @@ private:
 
 
   TDataStd_ListOfByte myList;
-
+  Standard_GUID myID;
 
 };
 
index 441ad0e..b886c55 100644 (file)
@@ -40,20 +40,44 @@ const Standard_GUID& TDataStd_ByteArray::GetID()
 //function : TDataStd_ByteArray
 //purpose  : Empty Constructor
 //=======================================================================
-TDataStd_ByteArray::TDataStd_ByteArray() : myIsDelta(Standard_False){}
-
+TDataStd_ByteArray::TDataStd_ByteArray() : myIsDelta(Standard_False)
+{}
 
 //=======================================================================
+//function : SetAttr
+//purpose  : Implements Set functionality
+//=======================================================================
+static Handle(TDataStd_ByteArray) SetAttr(const TDF_Label&       label,
+                                          const Standard_Integer lower,
+                                          const Standard_Integer upper,
+                                          const Standard_Boolean isDelta,
+                                          const Standard_GUID&   theGuid) 
+{
+  Handle(TDataStd_ByteArray) A;
+  if (!label.FindAttribute (theGuid, A)) 
+  {
+    A = new TDataStd_ByteArray;
+    A->Init (lower, upper);
+    A->SetDelta(isDelta); 
+    A->SetID(theGuid);
+    label.AddAttribute(A);
+  }
+  else if (lower != A->Lower() || upper != A->Upper())
+  {
+    A->Init(lower, upper);
+  }
+  return A;
+}
+//=======================================================================
 //function : Init
 //purpose  : 
 //=======================================================================
 void TDataStd_ByteArray::Init(const Standard_Integer lower,
-                             const Standard_Integer upper)
+                              const Standard_Integer upper)
 {
+  Standard_RangeError_Raise_if(upper < lower,"TDataStd_ByteArray::Init");
   Backup();
-
-  if (upper >= lower)
-    myValue = new TColStd_HArray1OfByte(lower, upper, 0x00);
+  myValue = new TColStd_HArray1OfByte(lower, upper, 0x00);
 }
 
 //=======================================================================
@@ -61,19 +85,24 @@ void TDataStd_ByteArray::Init(const Standard_Integer lower,
 //purpose  : 
 //=======================================================================
 Handle(TDataStd_ByteArray) TDataStd_ByteArray::Set(const TDF_Label&       label,
-                                                  const Standard_Integer lower,
-                                                  const Standard_Integer upper,
-                                                const Standard_Boolean isDelta) 
+                                                   const Standard_Integer lower,
+                                                   const Standard_Integer upper,
+                                                   const Standard_Boolean isDelta) 
 {
-  Handle(TDataStd_ByteArray) A;
-  if (!label.FindAttribute (TDataStd_ByteArray::GetID(), A)) 
-  {
-    A = new TDataStd_ByteArray;
-    A->Init (lower, upper);
-    A->SetDelta(isDelta); 
-    label.AddAttribute(A);
-  }
-  return A;
+  return SetAttr(label, lower, upper, isDelta, GetID());
+}
+
+//=======================================================================
+//function : Set
+//purpose  : Set user defined attribute with specific ID
+//=======================================================================
+Handle(TDataStd_ByteArray) TDataStd_ByteArray::Set(const TDF_Label&       label,
+                                                   const Standard_GUID&   theGuid,
+                                                   const Standard_Integer lower,
+                                                   const Standard_Integer upper,
+                                                   const Standard_Boolean isDelta) 
+{
+  return SetAttr(label, lower, upper, isDelta, theGuid);
 }
 
 //=======================================================================
@@ -81,7 +110,7 @@ Handle(TDataStd_ByteArray) TDataStd_ByteArray::Set(const TDF_Label&       label,
 //purpose  : 
 //=======================================================================
 void TDataStd_ByteArray::SetValue (const Standard_Integer index,
-                                  const Standard_Byte value) 
+                                   const Standard_Byte value) 
 {
   if (myValue.IsNull()) 
     return;
@@ -140,7 +169,7 @@ Standard_Integer TDataStd_ByteArray::Length (void) const
 //         : that holds <newArray>
 //=======================================================================
 void TDataStd_ByteArray::ChangeArray (const Handle(TColStd_HArray1OfByte)& newArray,
-                                     const Standard_Boolean isCheckItems)
+                                      const Standard_Boolean isCheckItems)
 {
 
   Standard_Integer aLower    = newArray->Lower();
@@ -153,13 +182,13 @@ void TDataStd_ByteArray::ChangeArray (const Handle(TColStd_HArray1OfByte)& newAr
     if(isCheckItems) {
       Standard_Boolean isEqual = Standard_True;
       for(i = aLower; i <= anUpper; i++) {
-       if(myValue->Value(i) != newArray->Value(i)) {
-         isEqual = Standard_False;
-         break;
-       }
+        if(myValue->Value(i) != newArray->Value(i)) {
+          isEqual = Standard_False;
+          break;
+        }
       }
       if(isEqual)
-       return;
+        return;
     }
   }
   
@@ -178,7 +207,30 @@ void TDataStd_ByteArray::ChangeArray (const Handle(TColStd_HArray1OfByte)& newAr
 //=======================================================================
 const Standard_GUID& TDataStd_ByteArray::ID () const 
 { 
-  return GetID(); 
+  return myID; 
+}
+
+//=======================================================================
+//function : SetID
+//purpose  :
+//=======================================================================
+
+void TDataStd_ByteArray::SetID( const Standard_GUID&  theGuid)
+{  
+  if(myID == theGuid) return;
+  Backup();
+  myID = theGuid;
+}
+
+//=======================================================================
+//function : SetID
+//purpose  : sets default ID
+//=======================================================================
+
+void TDataStd_ByteArray::SetID()
+{
+  Backup();
+  myID = GetID();
 }
 
 //=======================================================================
@@ -205,6 +257,7 @@ void TDataStd_ByteArray::Restore(const Handle(TDF_Attribute)& With)
     for (; i <= upper; i++)
       myValue->SetValue(i, with_array.Value(i));
     myIsDelta = anArray->myIsDelta;
+    myID = anArray->ID();
   }
   else
     myValue.Nullify();
@@ -215,7 +268,7 @@ void TDataStd_ByteArray::Restore(const Handle(TDF_Attribute)& With)
 //purpose  : 
 //=======================================================================
 void TDataStd_ByteArray::Paste (const Handle(TDF_Attribute)& Into,
-                               const Handle(TDF_RelocationTable)& ) const
+                                const Handle(TDF_RelocationTable)& ) const
 {
   if (!myValue.IsNull()) 
   {
@@ -224,6 +277,7 @@ void TDataStd_ByteArray::Paste (const Handle(TDF_Attribute)& Into,
     {
       anAtt->ChangeArray( myValue, Standard_False);
       anAtt->SetDelta(myIsDelta);
+      anAtt->SetID(myID);
     }
   }
 }
@@ -234,7 +288,10 @@ void TDataStd_ByteArray::Paste (const Handle(TDF_Attribute)& Into,
 //=======================================================================
 Standard_OStream& TDataStd_ByteArray::Dump (Standard_OStream& anOS) const
 {  
-  anOS << "ByteArray";
+  anOS << "\nByteArray: ";
+  Standard_Character sguid[Standard_GUID_SIZE_ALLOC];
+  myID.ToCString(sguid);
+  anOS << sguid << endl;
   return anOS;
 }
 
index f8ceedb..16cf2ed 100644 (file)
@@ -25,6 +25,8 @@
 #include <Standard_Integer.hxx>
 #include <Standard_Byte.hxx>
 #include <Standard_OStream.hxx>
+#include <Standard_GUID.hxx>
+
 class TDataStd_DeltaOnModificationOfByteArray;
 class Standard_GUID;
 class TDF_Label;
@@ -43,6 +45,7 @@ class TDataStd_ByteArray : public TDF_Attribute
   DEFINE_STANDARD_RTTIEXT(TDataStd_ByteArray, TDF_Attribute)
 public:
 
+  
   //! Static methods
   //! ==============
   //! Returns an ID for array.
@@ -55,6 +58,11 @@ public:
   //! attribute is returned.
   Standard_EXPORT static Handle(TDataStd_ByteArray) Set (const TDF_Label& label, const Standard_Integer lower, const Standard_Integer upper, const Standard_Boolean isDelta = Standard_False);
   
+  //! Finds or creates an attribute with byte array and explicit user defined <guid> on the specified label.
+  Standard_EXPORT static Handle(TDataStd_ByteArray) Set (const TDF_Label& label, const Standard_GUID&   theGuid,
+                                                         const Standard_Integer lower, const Standard_Integer upper, 
+                                                         const Standard_Boolean isDelta = Standard_False);
+  
   //! Initialize the inner array with bounds from <lower> to <upper>
   Standard_EXPORT void Init (const Standard_Integer lower, const Standard_Integer upper);
   
@@ -62,12 +70,19 @@ public:
   //! OutOfRange exception is raised if <Index> doesn't respect Lower and Upper bounds of the internal  array.
   Standard_EXPORT void SetValue (const Standard_Integer index, const Standard_Byte value);
   
+  //! Sets the explicit GUID (user defined) for the attribute.
+  Standard_EXPORT void SetID( const Standard_GUID&  theGuid) Standard_OVERRIDE;
+
+  //! Sets default GUID for the attribute.
+  Standard_EXPORT void SetID() Standard_OVERRIDE;
+
   //! Return the value of the <Index>th element of the array.
   Standard_EXPORT Standard_Byte Value (const Standard_Integer Index) const;
-Standard_Byte operator () (const Standard_Integer Index) const
-{
-  return Value(Index);
-}
+
+  Standard_Byte operator () (const Standard_Integer Index) const
+  {
+    return Value(Index);
+  }
   
   //! Returns the lower boundary of the array.
   Standard_EXPORT Standard_Integer Lower() const;
@@ -117,6 +132,7 @@ private:
 
   Handle(TColStd_HArray1OfByte) myValue;
   Standard_Boolean myIsDelta;
+  Standard_GUID myID;
 
 };
 
index e35f56a..a25618c 100644 (file)
@@ -37,7 +37,31 @@ const Standard_GUID& TDataStd_ExtStringArray::GetID()
   return anExtStringArrayID; 
 }
 
-
+//=======================================================================
+//function : SetAttr
+//purpose  : Implements Set functionality
+//=======================================================================
+Handle(TDataStd_ExtStringArray) SetAttr(const TDF_Label&       label,
+                                        const Standard_Integer lower,
+                                        const Standard_Integer upper,
+                                        const Standard_Boolean isDelta,
+                                        const Standard_GUID&   theGuid) 
+{
+  Handle(TDataStd_ExtStringArray) A;
+  if (!label.FindAttribute (theGuid, A)) 
+  {
+    A = new TDataStd_ExtStringArray;
+    A->SetID(theGuid);
+    A->Init (lower, upper); 
+    A->SetDelta(isDelta); 
+    label.AddAttribute(A);
+  }
+  else if (lower != A->Lower() || upper != A->Upper())
+  {
+    A->Init(lower, upper);
+  }
+  return A;
+}
 //=======================================================================
 //function : TDataStd_ExtStringArray::TDataStd_ExtStringArray
 //purpose  : 
@@ -52,8 +76,9 @@ TDataStd_ExtStringArray::TDataStd_ExtStringArray()
 //=======================================================================
 
 void TDataStd_ExtStringArray::Init(const Standard_Integer lower,
-                               const Standard_Integer upper)
+                                   const Standard_Integer upper)
 {
+  Standard_RangeError_Raise_if(upper < lower,"TDataStd_ExtStringArray::Init");
   Backup();
   myValue = new TColStd_HArray1OfExtendedString(lower, upper, "");
 }
@@ -64,27 +89,30 @@ void TDataStd_ExtStringArray::Init(const Standard_Integer lower,
 //=======================================================================
 
 Handle(TDataStd_ExtStringArray) TDataStd_ExtStringArray::Set (
-                                         const TDF_Label& label,
-                                         const Standard_Integer lower,
-                                         const Standard_Integer upper,
-                                         const Standard_Boolean isDelta) 
+                                          const TDF_Label& label,
+                                          const Standard_Integer lower,
+                                          const Standard_Integer upper,
+                                          const Standard_Boolean isDelta) 
 
 {
-  Handle(TDataStd_ExtStringArray) A;
-  if (!label.FindAttribute (TDataStd_ExtStringArray::GetID(), A)) {
-    A = new TDataStd_ExtStringArray;
-    A->Init (lower, upper);
-    A->SetDelta(isDelta); 
-    label.AddAttribute(A);
-  }
-  else if (lower != A->Lower() || upper != A->Upper())
-  {
-    A->Init (lower, upper); 
-  }
-  return A;
+  return SetAttr(label, lower, upper, isDelta, GetID());
 }
 
+//=======================================================================
+//function : Set
+//purpose  : Set user defined attribute with specific ID
+//=======================================================================
+
+Handle(TDataStd_ExtStringArray) TDataStd_ExtStringArray::Set (
+                                          const TDF_Label& label,
+                                          const Standard_GUID& theGuid,
+                                          const Standard_Integer lower,
+                                          const Standard_Integer upper,
+                                          const Standard_Boolean isDelta) 
 
+{
+  return SetAttr(label, lower, upper, isDelta, theGuid);
+}
 //=======================================================================
 //function : SetValue
 //purpose  : 
@@ -108,12 +136,12 @@ void TDataStd_ExtStringArray::SetValue(const Standard_Integer index, const TColl
 
 const TCollection_ExtendedString& TDataStd_ExtStringArray::Value (const Standard_Integer index) const 
 {
-    if (myValue.IsNull()) 
-    {
-        static TCollection_ExtendedString staticEmptyValue;
-        return staticEmptyValue;
-    }
-    return myValue->Value(index); 
+  if (myValue.IsNull()) 
+  {
+    static TCollection_ExtendedString staticEmptyValue;
+    return staticEmptyValue;
+  }
+  return myValue->Value(index); 
 }
 
 //=======================================================================
@@ -158,7 +186,7 @@ Standard_Integer TDataStd_ExtStringArray::Length (void) const
 //=======================================================================
 
 void TDataStd_ExtStringArray::ChangeArray(const Handle(TColStd_HArray1OfExtendedString)& newArray,
-                                         const Standard_Boolean isCheckItems) 
+                                          const Standard_Boolean isCheckItems) 
 {
   Standard_Integer aLower    = newArray->Lower();
   Standard_Integer anUpper   = newArray->Upper();
@@ -170,13 +198,13 @@ void TDataStd_ExtStringArray::ChangeArray(const Handle(TColStd_HArray1OfExtended
     Standard_Boolean isEqual = Standard_True;
     if(isCheckItems) {
       for(i = aLower; i <= anUpper; i++) {
-       if(myValue->Value(i) != newArray->Value(i)) {
-         isEqual = Standard_False;
-         break;
-       }
+        if(myValue->Value(i) != newArray->Value(i)) {
+          isEqual = Standard_False;
+          break;
+        }
       }
       if(isEqual)
-       return;
+        return;
     }
   }
 
@@ -195,8 +223,30 @@ void TDataStd_ExtStringArray::ChangeArray(const Handle(TColStd_HArray1OfExtended
 //purpose  : 
 //=======================================================================
 
-const Standard_GUID& TDataStd_ExtStringArray::ID () const { return GetID(); }
+const Standard_GUID& TDataStd_ExtStringArray::ID () const { return myID; }
+
+//=======================================================================
+//function : SetID
+//purpose  :
+//=======================================================================
+
+void TDataStd_ExtStringArray::SetID( const Standard_GUID&  theGuid)
+{  
+  if(myID == theGuid) return;
+  Backup();
+  myID = theGuid;
+}
+
+//=======================================================================
+//function : SetID
+//purpose  : sets default ID
+//=======================================================================
 
+void TDataStd_ExtStringArray::SetID()
+{  
+  Backup();
+  myID = GetID();
+}
 
 //=======================================================================
 //function : NewEmpty
@@ -224,6 +274,7 @@ void TDataStd_ExtStringArray::Restore(const Handle(TDF_Attribute)& With)
     for(i = lower; i<=upper; i++)
       myValue->SetValue(i, anArray->Value(i));
     myIsDelta = anArray->myIsDelta;
+    myID = anArray->ID();
   }
   else
     myValue.Nullify();
@@ -235,13 +286,14 @@ void TDataStd_ExtStringArray::Restore(const Handle(TDF_Attribute)& With)
 //=======================================================================
 
 void TDataStd_ExtStringArray::Paste (const Handle(TDF_Attribute)& Into,
-                                  const Handle(TDF_RelocationTable)& ) const
+                                     const Handle(TDF_RelocationTable)& ) const
 {
   if(!myValue.IsNull()) {
     Handle(TDataStd_ExtStringArray) anAtt = Handle(TDataStd_ExtStringArray)::DownCast(Into);
     if(!anAtt.IsNull()) {
       anAtt->ChangeArray( myValue, Standard_False );
       anAtt->SetDelta(myIsDelta);
+      anAtt->SetID(myID);
     }
   }
 }
@@ -253,7 +305,7 @@ void TDataStd_ExtStringArray::Paste (const Handle(TDF_Attribute)& Into,
 
 Standard_OStream& TDataStd_ExtStringArray::Dump (Standard_OStream& anOS) const
 {  
-  anOS << "ExtStringArray :";
+  anOS << "\nExtStringArray :";
   if(!myValue.IsNull()) {
     Standard_Integer i, lower, upper;
     lower = myValue->Lower();
@@ -262,6 +314,9 @@ Standard_OStream& TDataStd_ExtStringArray::Dump (Standard_OStream& anOS) const
       anOS << "\t" <<myValue->Value(i)<<endl;
   }
   anOS << " Delta is " << (myIsDelta ? "ON":"OFF");
+  Standard_Character sguid[Standard_GUID_SIZE_ALLOC];
+  myID.ToCString(sguid);
+  anOS << sguid;
   anOS << endl;
   return anOS;
 }
index 78eb44c..a738351 100644 (file)
@@ -24,6 +24,8 @@
 #include <TDF_Attribute.hxx>
 #include <Standard_Integer.hxx>
 #include <Standard_OStream.hxx>
+#include <Standard_GUID.hxx>
+
 class TDataStd_DeltaOnModificationOfExtStringArray;
 class Standard_GUID;
 class TDF_Label;
@@ -55,20 +57,34 @@ public:
   //! If attribute is already set, all input parameters are refused and the found
   //! attribute is returned.
   Standard_EXPORT static Handle(TDataStd_ExtStringArray) Set (const TDF_Label& label, const Standard_Integer lower, const Standard_Integer upper, const Standard_Boolean isDelta = Standard_False);
-  
+
+  //! Finds, or creates, an ExtStringArray attribute with explicit user defined <guid>.
+  //! The ExtStringArray attribute  is  returned.
+  Standard_EXPORT static Handle(TDataStd_ExtStringArray) Set (const TDF_Label& label,  const Standard_GUID&   theGuid,
+                                                              const Standard_Integer lower, const Standard_Integer upper,
+                                                              const Standard_Boolean isDelta = Standard_False);
+
+
   //! Initializes the inner array with bounds from <lower> to <upper>
   Standard_EXPORT void Init (const Standard_Integer lower, const Standard_Integer upper);
   
   //! Sets  the   <Index>th  element  of   the  array to <Value>
   //! OutOfRange exception is raised if <Index> doesn't respect Lower and Upper bounds of the internal  array.
   Standard_EXPORT void SetValue (const Standard_Integer Index, const TCollection_ExtendedString& Value);
-  
+
+  //! Sets the explicit GUID (user defined) for the attribute.
+  Standard_EXPORT void SetID( const Standard_GUID&  theGuid) Standard_OVERRIDE;
+
+  //! Sets default GUID for the attribute.
+  Standard_EXPORT void SetID() Standard_OVERRIDE;
+
   //! Returns the value of  the  <Index>th element of the array
   Standard_EXPORT const TCollection_ExtendedString& Value (const Standard_Integer Index) const;
-const TCollection_ExtendedString& operator () (const Standard_Integer Index) const
-{
-  return Value(Index);
-}
+
+  const TCollection_ExtendedString& operator () (const Standard_Integer Index) const
+  {
+    return Value(Index);
+  }
   
   //! Return the lower bound.
   Standard_EXPORT Standard_Integer Lower() const;
@@ -118,6 +134,7 @@ private:
 
   Handle(TColStd_HArray1OfExtendedString) myValue;
   Standard_Boolean myIsDelta;
+  Standard_GUID myID;
 
 };
 
index fc4bc3e..5d96fed 100644 (file)
@@ -36,27 +36,46 @@ const Standard_GUID& TDataStd_ExtStringList::GetID()
 }
 
 //=======================================================================
-//function : TDataStd_ExtStringList
-//purpose  : Empty Constructor
+//function : SetAttr
+//purpose  : Implements Set functionality
 //=======================================================================
-TDataStd_ExtStringList::TDataStd_ExtStringList() 
+static Handle(TDataStd_ExtStringList) SetAttr(const TDF_Label&       label,
+                                              const Standard_GUID&   theGuid) 
 {
-
+  Handle(TDataStd_ExtStringList) A;
+  if (!label.FindAttribute (theGuid, A)) 
+  {
+    A = new TDataStd_ExtStringList;
+    A->SetID(theGuid);
+    label.AddAttribute(A);
+  }
+  return A;
 }
 
 //=======================================================================
+//function : TDataStd_ExtStringList
+//purpose  : Empty Constructor
+//=======================================================================
+TDataStd_ExtStringList::TDataStd_ExtStringList()
+{}
+
+//=======================================================================
 //function : Set
 //purpose  : 
 //=======================================================================
 Handle(TDataStd_ExtStringList) TDataStd_ExtStringList::Set(const TDF_Label& label) 
 {
-  Handle(TDataStd_ExtStringList) A;
-  if (!label.FindAttribute (TDataStd_ExtStringList::GetID(), A)) 
-  {
-    A = new TDataStd_ExtStringList;
-    label.AddAttribute(A);
-  }
-  return A;
+  return SetAttr(label, GetID());
+}
+
+//=======================================================================
+//function : Set
+//purpose  : Set user defined attribute with specific ID
+//=======================================================================
+Handle(TDataStd_ExtStringList) TDataStd_ExtStringList::Set(const TDF_Label& label,
+                                                           const Standard_GUID&   theGuid) 
+{
+  return SetAttr(label, theGuid);
 }
 
 //=======================================================================
@@ -102,7 +121,7 @@ void TDataStd_ExtStringList::Append(const TCollection_ExtendedString& value)
 //purpose  : 
 //=======================================================================
 Standard_Boolean TDataStd_ExtStringList::InsertBefore(const TCollection_ExtendedString& value,
-                                                     const TCollection_ExtendedString& before_value)
+                                                      const TCollection_ExtendedString& before_value)
 {
   TDataStd_ListIteratorOfListOfExtendedString itr(myList);
   for (; itr.More(); itr.Next())
@@ -145,7 +164,7 @@ Standard_Boolean TDataStd_ExtStringList::InsertBefore(const Standard_Integer ind
 //purpose  : 
 //=======================================================================
 Standard_Boolean TDataStd_ExtStringList::InsertAfter(const TCollection_ExtendedString& value,
-                                                    const TCollection_ExtendedString& after_value)
+                                                     const TCollection_ExtendedString& after_value)
 {
   TDataStd_ListIteratorOfListOfExtendedString itr(myList);
   for (; itr.More(); itr.Next())
@@ -267,10 +286,32 @@ const TDataStd_ListOfExtendedString& TDataStd_ExtStringList::List() const
 //=======================================================================
 const Standard_GUID& TDataStd_ExtStringList::ID () const 
 { 
-  return GetID(); 
+  return myID; 
+}
+
+//=======================================================================
+//function : SetID
+//purpose  :
+//=======================================================================
+
+void TDataStd_ExtStringList::SetID( const Standard_GUID&  theGuid)
+{  
+  if(myID == theGuid) return;
+  Backup();
+  myID = theGuid;
 }
 
 //=======================================================================
+//function : SetID
+//purpose  : sets default ID
+//=======================================================================
+
+void TDataStd_ExtStringList::SetID()
+{
+  Backup();
+  myID = GetID();
+}
+//=======================================================================
 //function : NewEmpty
 //purpose  : 
 //=======================================================================
@@ -292,6 +333,7 @@ void TDataStd_ExtStringList::Restore(const Handle(TDF_Attribute)& With)
   {
     myList.Append(itr.Value());
   }
+  myID = aList->ID();
 }
 
 //=======================================================================
@@ -299,7 +341,7 @@ void TDataStd_ExtStringList::Restore(const Handle(TDF_Attribute)& With)
 //purpose  : 
 //=======================================================================
 void TDataStd_ExtStringList::Paste (const Handle(TDF_Attribute)& Into,
-                                   const Handle(TDF_RelocationTable)& ) const
+                                    const Handle(TDF_RelocationTable)& ) const
 {
   Handle(TDataStd_ExtStringList) aList = Handle(TDataStd_ExtStringList)::DownCast(Into);
   aList->Clear();
@@ -308,6 +350,7 @@ void TDataStd_ExtStringList::Paste (const Handle(TDF_Attribute)& Into,
   {
     aList->Append(itr.Value());
   }
+  aList->SetID(myID);
 }
 
 //=======================================================================
@@ -316,6 +359,10 @@ void TDataStd_ExtStringList::Paste (const Handle(TDF_Attribute)& Into,
 //=======================================================================
 Standard_OStream& TDataStd_ExtStringList::Dump (Standard_OStream& anOS) const
 {  
-  anOS << "ExtStringList";
+  anOS << "\nExtStringList: ";
+  Standard_Character sguid[Standard_GUID_SIZE_ALLOC];
+  myID.ToCString(sguid);
+  anOS << sguid;
+  anOS << endl;
   return anOS;
 }
index cd9b69a..e90ce3a 100644 (file)
@@ -24,6 +24,8 @@
 #include <Standard_Boolean.hxx>
 #include <Standard_Integer.hxx>
 #include <Standard_OStream.hxx>
+#include <Standard_GUID.hxx>
+
 class Standard_GUID;
 class TDF_Label;
 class TCollection_ExtendedString;
@@ -46,8 +48,11 @@ public:
   //! Returns the ID of the list of strings attribute.
   Standard_EXPORT static const Standard_GUID& GetID();
   
-  //! Finds or creates a list of string values attribute.
+  //! Finds or creates a list of string values attribute with explicit user defined <guid>.
   Standard_EXPORT static Handle(TDataStd_ExtStringList) Set (const TDF_Label& label);
+
+  //! Finds or creates a list of string values attribute.
+  Standard_EXPORT static Handle(TDataStd_ExtStringList) Set (const TDF_Label& label, const Standard_GUID& theGuid);
   
   Standard_EXPORT TDataStd_ExtStringList();
   
@@ -58,7 +63,13 @@ public:
   Standard_EXPORT void Prepend (const TCollection_ExtendedString& value);
   
   Standard_EXPORT void Append (const TCollection_ExtendedString& value);
-  
+  //! Sets the explicit GUID (user defined) for the attribute.
+  Standard_EXPORT void SetID( const Standard_GUID&  theGuid) Standard_OVERRIDE;
+
+  //! Sets default GUID for the attribute.
+  Standard_EXPORT void SetID() Standard_OVERRIDE;
+
   //! Inserts the <value> before the first meet of <before_value>.
   Standard_EXPORT Standard_Boolean InsertBefore (const TCollection_ExtendedString& value, const TCollection_ExtendedString& before_value);
   
@@ -111,7 +122,7 @@ private:
 
 
   TDataStd_ListOfExtendedString myList;
-
+  Standard_GUID myID;
 
 };
 
index 8916077..e15b207 100644 (file)
@@ -135,6 +135,17 @@ void TDataStd_Integer::SetID( const Standard_GUID&  theGuid)
   Backup();
   myID = theGuid;
 }
+
+//=======================================================================
+//function : SetID
+//purpose  : sets default ID
+//=======================================================================
+void TDataStd_Integer::SetID()
+{
+  Backup();
+  myID = GetID();
+}
+
 //=======================================================================
 //function : NewEmpty
 //purpose  : 
index 731b60e..6096d57 100644 (file)
@@ -61,7 +61,10 @@ public:
   Standard_EXPORT void Set (const Standard_Integer V);
  
   //! Sets the explicit GUID (user defined) for the attribute.
-  Standard_EXPORT void SetID (const Standard_GUID& guid);
+  Standard_EXPORT void SetID (const Standard_GUID& guid) Standard_OVERRIDE;
+
+  //! Sets default GUID for the attribute.
+  Standard_EXPORT void SetID() Standard_OVERRIDE;
 
   //! Returns the integer value contained in the attribute.
   Standard_EXPORT Standard_Integer Get() const;
index 1e7c5e8..d2c3c6d 100644 (file)
@@ -37,6 +37,31 @@ const Standard_GUID& TDataStd_IntegerArray::GetID()
   return TDataStd_IntegerArrayID; 
 }
 
+//=======================================================================
+//function : SetAttr
+//purpose  : Implements Set functionality
+//=======================================================================
+static Handle(TDataStd_IntegerArray) SetAttr(const TDF_Label&       label,
+                                             const Standard_Integer lower,
+                                             const Standard_Integer upper,
+                                             const Standard_Boolean isDelta,
+                                             const Standard_GUID&   theGuid) 
+{
+  Handle(TDataStd_IntegerArray) A;
+  if (!label.FindAttribute (theGuid, A)) 
+  {
+    A = new TDataStd_IntegerArray;
+    A->Init (lower, upper);
+    A->SetDelta(isDelta); 
+    A->SetID(theGuid);
+    label.AddAttribute(A);
+  }
+  else if (lower != A->Lower() || upper != A->Upper())
+  {
+    A->Init(lower, upper);
+  }
+  return A;
+}
 
 //=======================================================================
 //function : TDataStd_IntegerArray
@@ -44,7 +69,8 @@ const Standard_GUID& TDataStd_IntegerArray::GetID()
 //=======================================================================
 
 TDataStd_IntegerArray::TDataStd_IntegerArray()
-     :myIsDelta(Standard_False) {}
+  :myIsDelta(Standard_False)
+{}
 
 //=======================================================================
 //function : Init
@@ -54,6 +80,7 @@ TDataStd_IntegerArray::TDataStd_IntegerArray()
 void TDataStd_IntegerArray::Init(const Standard_Integer lower,
                                  const Standard_Integer upper)
 {
+  Standard_RangeError_Raise_if(upper < lower,"TDataStd_IntegerArray::Init");  
   Backup();
   myValue = new TColStd_HArray1OfInteger(lower, upper, 0);
 }
@@ -67,24 +94,28 @@ Handle(TDataStd_IntegerArray) TDataStd_IntegerArray::Set
                                                 (const TDF_Label&       label,
                                                  const Standard_Integer lower,
                                                  const Standard_Integer upper,
-                                                const Standard_Boolean isDelta) 
+                                                 const Standard_Boolean isDelta) 
 
 {
-  Handle(TDataStd_IntegerArray) A;
-  if (!label.FindAttribute (TDataStd_IntegerArray::GetID(), A)) {
-    A = new TDataStd_IntegerArray;
-    A->Init (lower, upper);
-    A->SetDelta(isDelta);
-    label.AddAttribute(A);
-  }
-  else if (lower != A->Lower() || upper != A->Upper())
-  {
-    A->Init (lower, upper); 
-  }
-  return A;
+  return SetAttr(label, lower, upper, isDelta, GetID());
 }
 
 //=======================================================================
+//function : Set
+//purpose  : Set user defined attribute with specific ID
+//=======================================================================
+
+Handle(TDataStd_IntegerArray) TDataStd_IntegerArray::Set
+                                                (const TDF_Label&       label,
+                                                 const Standard_GUID&   theGuid,
+                                                 const Standard_Integer lower,
+                                                 const Standard_Integer upper,
+                                                 const Standard_Boolean isDelta) 
+
+{
+  return SetAttr(label, lower, upper, isDelta, theGuid);
+}
+//=======================================================================
 //function : SetValue
 //purpose  : 
 //=======================================================================
@@ -153,7 +184,7 @@ Standard_Integer TDataStd_IntegerArray::Length (void) const
 //=======================================================================
 
 void TDataStd_IntegerArray::ChangeArray(const Handle(TColStd_HArray1OfInteger)& newArray,
-                                       const Standard_Boolean isCheckItems) 
+                                        const Standard_Boolean isCheckItems) 
 {
   Standard_Integer aLower    = newArray->Lower();
   Standard_Integer anUpper   = newArray->Upper();
@@ -165,16 +196,16 @@ void TDataStd_IntegerArray::ChangeArray(const Handle(TColStd_HArray1OfInteger)&
     if(isCheckItems) {
       Standard_Boolean isEqual = Standard_True;
       for(i = aLower; i <= anUpper; i++) {
-       if(myValue->Value(i) != newArray->Value(i)) {
-         isEqual = Standard_False;
-         break;
-       }
+        if(myValue->Value(i) != newArray->Value(i)) {
+          isEqual = Standard_False;
+          break;
+        }
       }
       if(isEqual)
-       return;
+        return;
     }
   }
-  
+
   Backup();
 // Handles of myValue of current and backuped attributes will be different!
   if(myValue.IsNull() || !aDimEqual) 
@@ -190,8 +221,30 @@ void TDataStd_IntegerArray::ChangeArray(const Handle(TColStd_HArray1OfInteger)&
 //purpose  : 
 //=======================================================================
 
-const Standard_GUID& TDataStd_IntegerArray::ID () const { return GetID(); }
+const Standard_GUID& TDataStd_IntegerArray::ID () const { return myID; }
 
+//=======================================================================
+//function : SetID
+//purpose  :
+//=======================================================================
+
+void TDataStd_IntegerArray::SetID( const Standard_GUID&  theGuid)
+{  
+  if(myID == theGuid) return;
+  Backup();
+  myID = theGuid;
+}
+
+//=======================================================================
+//function : SetID
+//purpose  : sets default ID
+//=======================================================================
+
+void TDataStd_IntegerArray::SetID()
+{  
+  Backup();
+  myID = GetID();
+}
 
 //=======================================================================
 //function : NewEmpty
@@ -219,6 +272,7 @@ void TDataStd_IntegerArray::Restore(const Handle(TDF_Attribute)& With)
     for(i = lower; i<=upper; i++)
       myValue->SetValue(i, anArray->Value(i));
     myIsDelta = anArray->myIsDelta;
+    myID = anArray->ID();
   }
   else
     myValue.Nullify();
@@ -238,6 +292,7 @@ void TDataStd_IntegerArray::Paste (const Handle(TDF_Attribute)& Into,
     if(!anAtt.IsNull()) {
       anAtt->ChangeArray( myValue, Standard_False );
       anAtt->SetDelta(myIsDelta);
+      anAtt->SetID(myID);
     }
   }
 }
@@ -258,6 +313,9 @@ Standard_OStream& TDataStd_IntegerArray::Dump (Standard_OStream& anOS) const
       anOS << " " <<myValue->Value(i);
   }
   anOS << " Delta is " << (myIsDelta ? "ON":"OFF");
+  Standard_Character sguid[Standard_GUID_SIZE_ALLOC];
+  myID.ToCString(sguid);
+  anOS << sguid;
   anOS << endl;
 
   // anOS <<"\nAttribute fields: ";
@@ -278,5 +336,3 @@ Handle(TDF_DeltaOnModification) TDataStd_IntegerArray::DeltaOnModification
     return new TDataStd_DeltaOnModificationOfIntArray(Handle(TDataStd_IntegerArray)::DownCast (OldAttribute));
   else return new TDF_DefaultDeltaOnModification(OldAttribute);
 }
-
-
index da40804..0732322 100644 (file)
@@ -25,6 +25,8 @@
 #include <TDF_Attribute.hxx>
 #include <Standard_Integer.hxx>
 #include <Standard_OStream.hxx>
+#include <Standard_GUID.hxx>
+
 class TDataStd_DeltaOnModificationOfIntArray;
 class Standard_GUID;
 class TDF_Label;
@@ -54,8 +56,16 @@ public:
   //! If <isDelta> == True, DeltaOnModification of the current attribute is used.
   //! If attribute is already set, all input parameters are refused and the found
   //! attribute is returned.
-  Standard_EXPORT static Handle(TDataStd_IntegerArray) Set (const TDF_Label& label, const Standard_Integer lower, const Standard_Integer upper, const Standard_Boolean isDelta = Standard_False);
+  Standard_EXPORT static Handle(TDataStd_IntegerArray) Set (const TDF_Label& label, const Standard_Integer lower, 
+                                                            const Standard_Integer upper, 
+                                                            const Standard_Boolean isDelta = Standard_False);
   
+  //! Finds, or creates, an IntegerArray attribute with explicit user defined <guid>.
+  //! The IntegerArray attribute  is  returned.
+  Standard_EXPORT static Handle(TDataStd_IntegerArray) Set (const TDF_Label& label, const Standard_GUID&   theGuid,
+                                                            const Standard_Integer lower, const Standard_Integer upper, 
+                                                            const Standard_Boolean isDelta = Standard_False);
+
   //! Initialize the inner array with bounds from <lower> to <upper>
   Standard_EXPORT void Init (const Standard_Integer lower, const Standard_Integer upper);
   
@@ -63,12 +73,19 @@ public:
   //! OutOfRange exception is raised if <Index> doesn't respect Lower and Upper bounds of the internal  array.
   Standard_EXPORT void SetValue (const Standard_Integer Index, const Standard_Integer Value);
   
+  //! Sets the explicit GUID (user defined) for the attribute.
+  Standard_EXPORT void SetID( const Standard_GUID&  theGuid) Standard_OVERRIDE;
+
+  //! Sets default GUID for the attribute.
+  Standard_EXPORT void SetID() Standard_OVERRIDE;
+
   //! Return the value of  the  <Index>th element of the array
   Standard_EXPORT Standard_Integer Value (const Standard_Integer Index) const;
-Standard_Integer operator () (const Standard_Integer Index) const
-{
-  return Value(Index);
-}
+
+  Standard_Integer operator () (const Standard_Integer Index) const 
+  {
+    return Value(Index);
+  }
   
   //! Returns the lower boundary of this array of integers.
   Standard_EXPORT Standard_Integer Lower() const;
@@ -121,6 +138,8 @@ private:
 
   Handle(TColStd_HArray1OfInteger) myValue;
   Standard_Boolean myIsDelta;
+  Standard_GUID myID;
+
 
 };
 
index 82bf36e..b6cebb2 100644 (file)
@@ -35,6 +35,23 @@ const Standard_GUID& TDataStd_IntegerList::GetID()
 }
 
 //=======================================================================
+//function : SetAttr
+//purpose  : Implements Set functionality
+//=======================================================================
+static Handle(TDataStd_IntegerList) SetAttr(const TDF_Label&       label,
+                                            const Standard_GUID&   theGuid) 
+{
+  Handle(TDataStd_IntegerList) A;
+  if (!label.FindAttribute (theGuid, A)) 
+  {
+    A = new TDataStd_IntegerList;
+    A->SetID(theGuid);
+    label.AddAttribute(A);
+  }
+  return A;
+}
+
+//=======================================================================
 //function : TDataStd_IntegerList
 //purpose  : Empty Constructor
 //=======================================================================
@@ -49,13 +66,17 @@ TDataStd_IntegerList::TDataStd_IntegerList()
 //=======================================================================
 Handle(TDataStd_IntegerList) TDataStd_IntegerList::Set(const TDF_Label& label) 
 {
-  Handle(TDataStd_IntegerList) A;
-  if (!label.FindAttribute (TDataStd_IntegerList::GetID(), A)) 
-  {
-    A = new TDataStd_IntegerList;
-    label.AddAttribute(A);
-  }
-  return A;
+  return SetAttr(label, GetID());
+}
+
+//=======================================================================
+//function : Set
+//purpose  : Set user defined attribute with specific ID
+//=======================================================================
+Handle(TDataStd_IntegerList) TDataStd_IntegerList::Set(const TDF_Label& label,
+                                                       const Standard_GUID& theGuid) 
+{
+  return SetAttr(label, theGuid);
 }
 
 //=======================================================================
@@ -101,7 +122,7 @@ void TDataStd_IntegerList::Append(const Standard_Integer value)
 //purpose  : 
 //=======================================================================
 Standard_Boolean TDataStd_IntegerList::InsertBefore(const Standard_Integer value,
-                                                   const Standard_Integer before_value)
+                                                    const Standard_Integer before_value)
 {
   TColStd_ListIteratorOfListOfInteger itr(myList);
   for (; itr.More(); itr.Next())
@@ -142,7 +163,7 @@ Standard_Boolean TDataStd_IntegerList::InsertBeforeByIndex (const Standard_Integ
 //purpose  : 
 //=======================================================================
 Standard_Boolean TDataStd_IntegerList::InsertAfter(const Standard_Integer value,
-                                                  const Standard_Integer after_value)
+                                                   const Standard_Integer after_value)
 {
   TColStd_ListIteratorOfListOfInteger itr(myList);
   for (; itr.More(); itr.Next())
@@ -262,7 +283,30 @@ const TColStd_ListOfInteger& TDataStd_IntegerList::List() const
 //=======================================================================
 const Standard_GUID& TDataStd_IntegerList::ID () const 
 { 
-  return GetID(); 
+  return myID; 
+}
+
+//=======================================================================
+//function : SetID
+//purpose  :
+//=======================================================================
+
+void TDataStd_IntegerList::SetID( const Standard_GUID&  theGuid)
+{  
+  if(myID == theGuid) return;
+  Backup();
+  myID = theGuid;
+}
+
+//=======================================================================
+//function : SetID
+//purpose  : sets default ID
+//=======================================================================
+
+void TDataStd_IntegerList::SetID()
+{  
+  Backup();
+  myID = GetID();
 }
 
 //=======================================================================
@@ -287,6 +331,7 @@ void TDataStd_IntegerList::Restore(const Handle(TDF_Attribute)& With)
   {
     myList.Append(itr.Value());
   }
+  myID = aList->ID();
 }
 
 //=======================================================================
@@ -294,7 +339,7 @@ void TDataStd_IntegerList::Restore(const Handle(TDF_Attribute)& With)
 //purpose  : 
 //=======================================================================
 void TDataStd_IntegerList::Paste (const Handle(TDF_Attribute)& Into,
-                                 const Handle(TDF_RelocationTable)& ) const
+                                  const Handle(TDF_RelocationTable)& ) const
 {
   Handle(TDataStd_IntegerList) aList = Handle(TDataStd_IntegerList)::DownCast(Into);
   aList->Clear();
@@ -303,6 +348,7 @@ void TDataStd_IntegerList::Paste (const Handle(TDF_Attribute)& Into,
   {
     aList->Append(itr.Value());
   }
+  aList->SetID(myID);
 }
 
 //=======================================================================
@@ -311,6 +357,10 @@ void TDataStd_IntegerList::Paste (const Handle(TDF_Attribute)& Into,
 //=======================================================================
 Standard_OStream& TDataStd_IntegerList::Dump (Standard_OStream& anOS) const
 {  
-  anOS << "IntegerList";
+  anOS << "\nIntegerList: ";
+  Standard_Character sguid[Standard_GUID_SIZE_ALLOC];
+  myID.ToCString(sguid);
+  anOS << sguid;
+  anOS << endl;
   return anOS;
 }
index f8b9306..67ff0f4 100644 (file)
@@ -24,6 +24,8 @@
 #include <Standard_Boolean.hxx>
 #include <Standard_Integer.hxx>
 #include <Standard_OStream.hxx>
+#include <Standard_GUID.hxx>
+
 class Standard_GUID;
 class TDF_Label;
 class TDF_Attribute;
@@ -47,7 +49,10 @@ public:
   
   //! Finds or creates a list of integer values attribute.
   Standard_EXPORT static Handle(TDataStd_IntegerList) Set (const TDF_Label& label);
-  
+
+ //! Finds or creates a list of integer values attribute with explicit user defined <guid>.
+  Standard_EXPORT static Handle(TDataStd_IntegerList) Set (const TDF_Label& label, const Standard_GUID&   theGuid);
+
   Standard_EXPORT TDataStd_IntegerList();
   
   Standard_EXPORT Standard_Boolean IsEmpty() const;
@@ -57,7 +62,13 @@ public:
   Standard_EXPORT void Prepend (const Standard_Integer value);
   
   Standard_EXPORT void Append (const Standard_Integer value);
-  
+
+  //! Sets the explicit GUID (user defined) for the attribute.
+  Standard_EXPORT void SetID( const Standard_GUID&  theGuid) Standard_OVERRIDE;
+
+  //! Sets default GUID for the attribute.
+  Standard_EXPORT void SetID() Standard_OVERRIDE;
+
   //! Inserts the <value> before the first meet of <before_value>.
   Standard_EXPORT Standard_Boolean InsertBefore (const Standard_Integer value, const Standard_Integer before_value);
   
@@ -110,7 +121,7 @@ private:
 
 
   TColStd_ListOfInteger myList;
-
+  Standard_GUID myID;
 
 };
 
index 6c2e8dd..c8b6e65 100644 (file)
@@ -119,6 +119,16 @@ void TDataStd_Name::SetID( const Standard_GUID&  theGuid)
   myID = theGuid;
 }
 
+//=======================================================================
+//function : SetID
+//purpose  : sets default ID
+//=======================================================================
+void TDataStd_Name::SetID()
+{
+  Backup();
+  myID = GetID();
+}
+
 // TDF_Attribute methods
 //=======================================================================
 //function : ID
index 82c6f34..9e56827 100644 (file)
@@ -81,7 +81,10 @@ public:
   Standard_EXPORT void Set (const TCollection_ExtendedString& S);
   
   //! Sets the explicit user defined GUID  to the attribute.
-  Standard_EXPORT void SetID (const Standard_GUID& guid);
+  Standard_EXPORT void SetID (const Standard_GUID& guid) Standard_OVERRIDE;
+
+  //! Sets default GUID for the attribute.
+  Standard_EXPORT void SetID() Standard_OVERRIDE;
 
   //! Returns the name contained in this name attribute.
   Standard_EXPORT const TCollection_ExtendedString& Get() const;
index 3a7affe..f8266fc 100644 (file)
@@ -172,6 +172,16 @@ void TDataStd_Real::SetID( const Standard_GUID&  theGuid)
   Backup();
   myID = theGuid;
 }
+
+//=======================================================================
+//function : SetID
+//purpose  : sets default ID
+//=======================================================================
+void TDataStd_Real::SetID()
+{
+  Backup();
+  myID = GetID();
+}
 //=======================================================================
 //function : NewEmpty
 //purpose  : 
index ff92996..049be3a 100644 (file)
@@ -72,7 +72,10 @@ public:
   Standard_EXPORT void Set (const Standard_Real V);
   
   //! Sets the explicit GUID for the attribute.
-  Standard_EXPORT void SetID (const Standard_GUID& guid);
+  Standard_EXPORT void SetID (const Standard_GUID& guid) Standard_OVERRIDE;
+
+  //! Sets default GUID for the attribute.
+  Standard_EXPORT void SetID() Standard_OVERRIDE;
 
   //! Returns the real number value contained in the attribute.
   Standard_EXPORT Standard_Real Get() const;
index 752e081..77723ce 100644 (file)
@@ -37,13 +37,39 @@ const Standard_GUID& TDataStd_RealArray::GetID()
   return TDataStd_RealArrayID; 
 }
 
+//=======================================================================
+//function : SetAttr
+//purpose  : Implements Set functionality
+//=======================================================================
+static Handle(TDataStd_RealArray) SetAttr(const TDF_Label&       label,
+                                          const Standard_Integer lower,
+                                          const Standard_Integer upper,
+                                          const Standard_Boolean isDelta,
+                                          const Standard_GUID&   theGuid) 
+{
+  Handle(TDataStd_RealArray) A;
+  if (!label.FindAttribute (theGuid, A)) 
+  {
+    A = new TDataStd_RealArray;
+    A->Init (lower, upper);
+    A->SetDelta(isDelta); 
+    A->SetID(theGuid);
+    label.AddAttribute(A);
+  }
+  else if (lower != A->Lower() || upper != A->Upper())
+  {
+    A->Init(lower, upper);
+  }
+  return A;
+}
 
 //=======================================================================
 //function : TDataStd_RealArray
 //purpose  : Empty Constructor
 //=======================================================================
 
-TDataStd_RealArray::TDataStd_RealArray() : myIsDelta(Standard_False){}
+TDataStd_RealArray::TDataStd_RealArray() : myIsDelta(Standard_False)
+{}
 
 //=======================================================================
 //function : Init
@@ -53,8 +79,8 @@ TDataStd_RealArray::TDataStd_RealArray() : myIsDelta(Standard_False){}
 void TDataStd_RealArray::Init(const Standard_Integer lower,
                               const Standard_Integer upper)
 {
+  Standard_RangeError_Raise_if(upper < lower,"TDataStd_RealArray::Init");  
   Backup(); // jfa 15.01.2003 for LH3D1378
-
   myValue = new TColStd_HArray1OfReal(lower, upper, 0.);
 }
 
@@ -67,23 +93,25 @@ Handle(TDataStd_RealArray) TDataStd_RealArray::Set
                                           (const TDF_Label&       label,
                                            const Standard_Integer lower,
                                            const Standard_Integer upper,
-                                          const Standard_Boolean isDelta) 
+                                           const Standard_Boolean isDelta) 
 {
-  Handle(TDataStd_RealArray) A;
-  if (!label.FindAttribute (TDataStd_RealArray::GetID(), A)) {
-    A = new TDataStd_RealArray;
-    A->Init (lower, upper);
-    A->SetDelta(isDelta); 
-    label.AddAttribute(A);
-  }
-  else if (lower != A->Lower() || upper != A->Upper())
-  {
-    A->Init (lower, upper); 
-  }
-  return A;
+  return SetAttr(label, lower, upper, isDelta, GetID());
 }
 
+//=======================================================================
+//function : Set
+//purpose  : Set user defined attribute with specific ID
+//=======================================================================
 
+Handle(TDataStd_RealArray) TDataStd_RealArray::Set
+                                          (const TDF_Label&       label,
+                                           const Standard_GUID&   theGuid,
+                                           const Standard_Integer lower,
+                                           const Standard_Integer upper,
+                                           const Standard_Boolean isDelta) 
+{
+  return SetAttr(label, lower, upper, isDelta, theGuid);
+}
 //=======================================================================
 //function : SetValue
 //purpose  : 
@@ -95,7 +123,7 @@ void TDataStd_RealArray::SetValue (const Standard_Integer index,
   // OCC2932 correction
   if(myValue.IsNull()) return;
   if(myValue->Value(index) == value)
-    return;  
+    return;
   Backup();
   myValue->SetValue(index, value);
 }
@@ -155,7 +183,7 @@ Standard_Integer TDataStd_RealArray::Length (void) const
 //=======================================================================
 
 void TDataStd_RealArray::ChangeArray(const Handle(TColStd_HArray1OfReal)& newArray,
-                                       const Standard_Boolean isCheckItems) 
+                                     const Standard_Boolean isCheckItems) 
 {
   Standard_Integer aLower    = newArray->Lower();
   Standard_Integer anUpper   = newArray->Upper();
@@ -167,13 +195,13 @@ void TDataStd_RealArray::ChangeArray(const Handle(TColStd_HArray1OfReal)& newArr
     Standard_Boolean isEqual = Standard_True;
     if(isCheckItems) {
       for(i = aLower; i <= anUpper; i++) {
-       if(myValue->Value(i) != newArray->Value(i)) {
-         isEqual = Standard_False;
-         break;
-       }
+        if(myValue->Value(i) != newArray->Value(i)) {
+          isEqual = Standard_False;
+          break;
+        }
       }
       if(isEqual)
-       return;
+        return;
     }
   }
 
@@ -191,8 +219,30 @@ void TDataStd_RealArray::ChangeArray(const Handle(TColStd_HArray1OfReal)& newArr
 //purpose  : 
 //=======================================================================
 
-const Standard_GUID& TDataStd_RealArray::ID () const { return GetID(); }
+const Standard_GUID& TDataStd_RealArray::ID () const { return myID; }
+
+//=======================================================================
+//function : SetID
+//purpose  :
+//=======================================================================
+
+void TDataStd_RealArray::SetID( const Standard_GUID&  theGuid)
+{  
+  if(myID == theGuid) return;
+  Backup();
+  myID = theGuid;
+}
+
+//=======================================================================
+//function : SetID
+//purpose  : sets default ID
+//=======================================================================
 
+void TDataStd_RealArray::SetID()
+{
+  Backup();
+  myID = GetID();
+}
 
 //=======================================================================
 //function : NewEmpty
@@ -220,6 +270,7 @@ void TDataStd_RealArray::Restore(const Handle(TDF_Attribute)& With)
     myValue = new TColStd_HArray1OfReal(lower, upper);
     for(i = lower; i<=upper; i++)
       myValue->SetValue(i, anArray->Value(i)); 
+    myID = anArray->ID();
   }
   else
     myValue.Nullify();
@@ -238,6 +289,7 @@ void TDataStd_RealArray::Paste (const Handle(TDF_Attribute)& Into,
     if(!anAtt.IsNull()) {
       anAtt->ChangeArray( myValue, Standard_False );
       anAtt->SetDelta(myIsDelta);
+      anAtt->SetID(myID);
     }
   }
 }
@@ -258,6 +310,9 @@ Standard_OStream& TDataStd_RealArray::Dump (Standard_OStream& anOS) const
       anOS << " " <<myValue->Value(i);
   }
   anOS << " Delta is " << (myIsDelta ? "ON":"OFF");
+  Standard_Character sguid[Standard_GUID_SIZE_ALLOC];
+  myID.ToCString(sguid);
+  anOS << sguid;
   anOS << endl;
   return anOS;
 }
index 86a020c..86f2364 100644 (file)
@@ -26,6 +26,8 @@
 #include <Standard_Integer.hxx>
 #include <Standard_Real.hxx>
 #include <Standard_OStream.hxx>
+#include <Standard_GUID.hxx>
+
 class TDataStd_DeltaOnModificationOfRealArray;
 class Standard_GUID;
 class TDF_Label;
@@ -56,20 +58,33 @@ public:
   //! If attribute is already set, input parameter <isDelta> is refused and the found
   //! attribute returned.
   Standard_EXPORT static Handle(TDataStd_RealArray) Set (const TDF_Label& label, const Standard_Integer lower, const Standard_Integer upper, const Standard_Boolean isDelta = Standard_False);
-  
+  //! Finds, or creates, an RealArray attribute with explicit user defined <guid>.
+  //! The RealArray attribute  is  returned.
+  Standard_EXPORT static Handle(TDataStd_RealArray) Set (const TDF_Label& label, const Standard_GUID&   theGuid,
+                                                         const Standard_Integer lower, const Standard_Integer upper, 
+                                                         const Standard_Boolean isDelta = Standard_False);
+
   //! Initialize the inner array with bounds from <lower> to <upper>
   Standard_EXPORT void Init (const Standard_Integer lower, const Standard_Integer upper);
-  
+  //! Sets the explicit GUID (user defined) for the attribute.
+  Standard_EXPORT void SetID( const Standard_GUID&  theGuid) Standard_OVERRIDE;
+
+  //! Sets default GUID for the attribute.
+  Standard_EXPORT void SetID() Standard_OVERRIDE;
+
   //! Sets  the   <Index>th  element  of   the  array to <Value>
   //! OutOfRange exception is raised if <Index> doesn't respect Lower and Upper bounds of the internal  array.
   Standard_EXPORT void SetValue (const Standard_Integer Index, const Standard_Real Value);
   
   //! Return the value of  the  <Index>th element of the array
   Standard_EXPORT Standard_Real Value (const Standard_Integer Index) const;
-Standard_Real operator () (const Standard_Integer Index) const
-{
-  return Value(Index);
-}
+
+  Standard_Real operator () (const Standard_Integer Index) const
+  {
+    return Value(Index);
+  }
   
   //! Returns the lower boundary of the array.
   Standard_EXPORT Standard_Integer Lower() const;
@@ -122,6 +137,7 @@ private:
 
   Handle(TColStd_HArray1OfReal) myValue;
   Standard_Boolean myIsDelta;
+  Standard_GUID myID;
 
 };
 
index 70c7952..ee81d64 100644 (file)
@@ -35,6 +35,23 @@ const Standard_GUID& TDataStd_RealList::GetID()
 }
 
 //=======================================================================
+//function : SetAttr
+//purpose  : Implements Set functionality
+//=======================================================================
+static Handle(TDataStd_RealList) SetAttr(const TDF_Label&       label,
+                                         const Standard_GUID&   theGuid) 
+{
+  Handle(TDataStd_RealList) A;
+  if (!label.FindAttribute (theGuid, A)) 
+  {
+    A = new TDataStd_RealList;
+    A->SetID(theGuid);
+    label.AddAttribute(A);
+  }
+  return A;
+}
+
+//=======================================================================
 //function : TDataStd_RealList
 //purpose  : Empty Constructor
 //=======================================================================
@@ -49,13 +66,17 @@ TDataStd_RealList::TDataStd_RealList()
 //=======================================================================
 Handle(TDataStd_RealList) TDataStd_RealList::Set(const TDF_Label& label) 
 {
-  Handle(TDataStd_RealList) A;
-  if (!label.FindAttribute (TDataStd_RealList::GetID(), A)) 
-  {
-    A = new TDataStd_RealList;
-    label.AddAttribute(A);
-  }
-  return A;
+  return SetAttr(label, GetID());
+}
+
+//=======================================================================
+//function : Set
+//purpose  : Set user defined attribute with specific ID
+//=======================================================================
+Handle(TDataStd_RealList) TDataStd_RealList::Set(const TDF_Label& label,
+                                                 const Standard_GUID&   theGuid) 
+{
+  return SetAttr(label, theGuid);
 }
 
 //=======================================================================
@@ -101,7 +122,7 @@ void TDataStd_RealList::Append(const Standard_Real value)
 //purpose  : 
 //=======================================================================
 Standard_Boolean TDataStd_RealList::InsertBefore(const Standard_Real value,
-                                                const Standard_Real before_value)
+                                                 const Standard_Real before_value)
 {
   TColStd_ListIteratorOfListOfReal itr(myList);
   for (; itr.More(); itr.Next())
@@ -142,7 +163,7 @@ Standard_Boolean TDataStd_RealList::InsertBeforeByIndex (const Standard_Integer
 //purpose  : 
 //=======================================================================
 Standard_Boolean TDataStd_RealList::InsertAfter(const Standard_Real value,
-                                               const Standard_Real after_value)
+                                                const Standard_Real after_value)
 {
   TColStd_ListIteratorOfListOfReal itr(myList);
   for (; itr.More(); itr.Next())
@@ -262,7 +283,28 @@ const TColStd_ListOfReal& TDataStd_RealList::List() const
 //=======================================================================
 const Standard_GUID& TDataStd_RealList::ID () const 
 { 
-  return GetID(); 
+  return myID; 
+}
+
+//=======================================================================
+//function : SetID
+//purpose  :
+//=======================================================================
+void TDataStd_RealList::SetID( const Standard_GUID&  theGuid)
+{  
+  if(myID == theGuid) return;
+  Backup();
+  myID = theGuid;
+}
+
+//=======================================================================
+//function : SetID
+//purpose  : sets default ID
+//=======================================================================
+void TDataStd_RealList::SetID()
+{  
+  Backup();
+  myID = GetID();
 }
 
 //=======================================================================
@@ -287,6 +329,7 @@ void TDataStd_RealList::Restore(const Handle(TDF_Attribute)& With)
   {
     myList.Append(itr.Value());
   }
+  myID = aList->ID();
 }
 
 //=======================================================================
@@ -294,7 +337,7 @@ void TDataStd_RealList::Restore(const Handle(TDF_Attribute)& With)
 //purpose  : 
 //=======================================================================
 void TDataStd_RealList::Paste (const Handle(TDF_Attribute)& Into,
-                                 const Handle(TDF_RelocationTable)& ) const
+                               const Handle(TDF_RelocationTable)& ) const
 {
   Handle(TDataStd_RealList) aList = Handle(TDataStd_RealList)::DownCast(Into);
   aList->Clear();
@@ -303,6 +346,7 @@ void TDataStd_RealList::Paste (const Handle(TDF_Attribute)& Into,
   {
     aList->Append(itr.Value());
   }
+  aList->SetID(myID);
 }
 
 //=======================================================================
@@ -311,6 +355,10 @@ void TDataStd_RealList::Paste (const Handle(TDF_Attribute)& Into,
 //=======================================================================
 Standard_OStream& TDataStd_RealList::Dump (Standard_OStream& anOS) const
 {  
-  anOS << "RealList";
+  anOS << "\nRealList: ";
+  Standard_Character sguid[Standard_GUID_SIZE_ALLOC];
+  myID.ToCString(sguid);
+  anOS << sguid;
+  anOS << endl;
   return anOS;
 }
index 17c693e..06c9276 100644 (file)
@@ -25,6 +25,8 @@
 #include <Standard_Integer.hxx>
 #include <Standard_Real.hxx>
 #include <Standard_OStream.hxx>
+#include <Standard_GUID.hxx>
+
 class Standard_GUID;
 class TDF_Label;
 class TDF_Attribute;
@@ -48,7 +50,10 @@ public:
   
   //! Finds or creates a list of double values attribute.
   Standard_EXPORT static Handle(TDataStd_RealList) Set (const TDF_Label& label);
-  
+
+  //! Finds or creates a list of double values attribute with explicit user defined <guid>.
+  Standard_EXPORT static Handle(TDataStd_RealList) Set (const TDF_Label& label, const Standard_GUID& theGuid);
+
   Standard_EXPORT TDataStd_RealList();
   
   Standard_EXPORT Standard_Boolean IsEmpty() const;
@@ -58,7 +63,13 @@ public:
   Standard_EXPORT void Prepend (const Standard_Real value);
   
   Standard_EXPORT void Append (const Standard_Real value);
-  
+  //! Sets the explicit GUID (user defined) for the attribute.
+  Standard_EXPORT void SetID( const Standard_GUID&  theGuid) Standard_OVERRIDE;
+
+  //! Sets default GUID for the attribute.
+  Standard_EXPORT void SetID() Standard_OVERRIDE;
+
   //! Inserts the <value> before the first meet of <before_value>.
   Standard_EXPORT Standard_Boolean InsertBefore (const Standard_Real value, const Standard_Real before_value);
   
@@ -111,7 +122,7 @@ private:
 
 
   TColStd_ListOfReal myList;
-
+  Standard_GUID myID;
 
 };
 
index 3825ca4..19dd652 100644 (file)
@@ -35,6 +35,30 @@ const Standard_GUID& TDataStd_ReferenceArray::GetID()
 }
 
 //=======================================================================
+//function : SetAttr
+//purpose  : Implements Set functionality
+//=======================================================================
+static Handle(TDataStd_ReferenceArray) SetAttr(const TDF_Label&     label,
+                                               const Standard_Integer lower,
+                                               const Standard_Integer upper,
+                                               const Standard_GUID&   theGuid) 
+{
+  Handle(TDataStd_ReferenceArray) A;
+  if (!label.FindAttribute (theGuid, A)) 
+  {
+    A = new TDataStd_ReferenceArray;
+    A->Init (lower, upper);
+    A->SetID(theGuid);
+    label.AddAttribute(A);
+  }
+  else if (lower != A->Lower() || upper != A->Upper())
+  {
+    A->Init(lower, upper);
+  }
+  return A;
+}
+
+//=======================================================================
 //function : TDataStd_ReferenceArray
 //purpose  : Empty Constructor
 //=======================================================================
@@ -48,7 +72,7 @@ TDataStd_ReferenceArray::TDataStd_ReferenceArray()
 //purpose  : 
 //=======================================================================
 void TDataStd_ReferenceArray::Init(const Standard_Integer lower,
-                                  const Standard_Integer upper)
+                                   const Standard_Integer upper)
 {
   Standard_RangeError_Raise_if(upper < lower,"TDataStd_ReferenceArray::Init");
   Backup();
@@ -60,29 +84,30 @@ void TDataStd_ReferenceArray::Init(const Standard_Integer lower,
 //purpose  : 
 //=======================================================================
 Handle(TDataStd_ReferenceArray) TDataStd_ReferenceArray::Set(const TDF_Label&       label,
-                                                            const Standard_Integer lower,
-                                                            const Standard_Integer upper) 
+                                                             const Standard_Integer lower,
+                                                             const Standard_Integer upper)
 {
-  Handle(TDataStd_ReferenceArray) A;
-  if (!label.FindAttribute (TDataStd_ReferenceArray::GetID(), A)) 
-  {
-    A = new TDataStd_ReferenceArray;
-    A->Init (lower, upper); 
-    label.AddAttribute(A);
-  }
-  else if (lower != A->Lower() || upper != A->Upper())
-  {
-    A->Init(lower, upper);
-  }
-  return A;
+  return SetAttr(label, lower, upper, GetID());
 }
 
+
+//=======================================================================
+//function : Set
+//purpose  : Set user defined attribute with specific ID
+//=======================================================================
+Handle(TDataStd_ReferenceArray) TDataStd_ReferenceArray::Set(const TDF_Label&       label,
+                                                             const Standard_GUID&   theGuid,
+                                                             const Standard_Integer lower,
+                                                             const Standard_Integer upper) 
+{
+  return SetAttr(label, lower, upper, theGuid);
+}
 //=======================================================================
 //function : SetValue
 //purpose  : 
 //=======================================================================
 void TDataStd_ReferenceArray::SetValue (const Standard_Integer index,
-                                       const TDF_Label&       value) 
+                                        const TDF_Label&       value) 
 {
   if(myArray.IsNull()) return;
   if (value == myArray->Value(index))
@@ -162,13 +187,13 @@ void TDataStd_ReferenceArray::SetInternalArray (const Handle(TDataStd_HLabelArra
     Standard_Boolean isEqual = Standard_True;
     if(isCheckItems) {
       for(i = aLower; i <= anUpper; i++) {
-       if(myArray->Value(i) != values->Value(i)) {
-         isEqual = Standard_False;
-         break;
-       }
+        if(myArray->Value(i) != values->Value(i)) {
+          isEqual = Standard_False;
+          break;
+        }
       }
       if(isEqual)
-       return;
+        return;
     }
   }
 #endif
@@ -188,7 +213,30 @@ void TDataStd_ReferenceArray::SetInternalArray (const Handle(TDataStd_HLabelArra
 //=======================================================================
 const Standard_GUID& TDataStd_ReferenceArray::ID () const 
 { 
-  return GetID();
+  return myID;
+}
+
+//=======================================================================
+//function : SetID
+//purpose  :
+//=======================================================================
+
+void TDataStd_ReferenceArray::SetID( const Standard_GUID&  theGuid)
+{  
+  if(myID == theGuid) return;
+  Backup();
+  myID = theGuid;
+}
+
+//=======================================================================
+//function : SetID
+//purpose  : sets default ID
+//=======================================================================
+
+void TDataStd_ReferenceArray::SetID()
+{  
+  Backup();
+  myID = GetID();
 }
 
 //=======================================================================
@@ -216,6 +264,7 @@ void TDataStd_ReferenceArray::Restore(const Handle(TDF_Attribute)& With)
     {
       myArray->SetValue(i, arr.Value(i));
     }
+    myID = anArray->ID();
   }
   else
   {
@@ -228,7 +277,7 @@ void TDataStd_ReferenceArray::Restore(const Handle(TDF_Attribute)& With)
 //purpose  : 
 //=======================================================================
 void TDataStd_ReferenceArray::Paste (const Handle(TDF_Attribute)& Into,
-                                    const Handle(TDF_RelocationTable)& RT) const
+                                     const Handle(TDF_RelocationTable)& RT) const
 {
   Handle(TDataStd_ReferenceArray) anArray = Handle(TDataStd_ReferenceArray)::DownCast(Into);
   if (myArray.IsNull())
@@ -246,10 +295,11 @@ void TDataStd_ReferenceArray::Paste (const Handle(TDF_Attribute)& Into,
     if (!L.IsNull())
     {
       if (!RT->HasRelocation(L, rL))
-       rL = L;
+        rL = L;
       anArray->myArray->SetValue(i, rL);
     }
   }
+  anArray->SetID(myID);
 }
 
 //=======================================================================
@@ -265,7 +315,7 @@ void TDataStd_ReferenceArray::References(const Handle(TDF_DataSet)& aDataSet) co
     for (; i <= upper; i++)
     {
       if (!arr.Value(i).IsNull())
-       aDataSet->AddLabel(arr.Value(i));
+        aDataSet->AddLabel(arr.Value(i));
     }
   }
 }
@@ -276,6 +326,9 @@ void TDataStd_ReferenceArray::References(const Handle(TDF_DataSet)& aDataSet) co
 //=======================================================================
 Standard_OStream& TDataStd_ReferenceArray::Dump (Standard_OStream& anOS) const
 {  
-  anOS << "ReferenceArray";
+  anOS << "\nReferenceArray: ";
+  Standard_Character sguid[Standard_GUID_SIZE_ALLOC];
+  myID.ToCString(sguid);
+  anOS << sguid << endl;
   return anOS;
 }
index 5cd655a..8d35620 100644 (file)
@@ -25,6 +25,8 @@
 #include <TDF_Label.hxx>
 #include <Standard_Boolean.hxx>
 #include <Standard_OStream.hxx>
+#include <Standard_GUID.hxx>
+
 class Standard_GUID;
 class TDF_Label;
 class TDF_Attribute;
@@ -49,6 +51,10 @@ public:
   
   //! Finds or creates an array of reference values (labels) attribute.
   Standard_EXPORT static Handle(TDataStd_ReferenceArray) Set (const TDF_Label& label, const Standard_Integer lower, const Standard_Integer upper);
+
+  //! Finds or creates an array of reference values (labels) attribute with explicit user defined <guid>.
+  Standard_EXPORT static Handle(TDataStd_ReferenceArray) Set (const TDF_Label& label,  const Standard_GUID&   theGuid,
+                                                              const Standard_Integer lower, const Standard_Integer upper);
   
   //! Initialize the inner array with bounds from <lower> to <upper>
   Standard_EXPORT void Init (const Standard_Integer lower, const Standard_Integer upper);
@@ -56,13 +62,20 @@ public:
   //! Sets the <Index>th element of the array to <Value>
   //! OutOfRange exception is raised if <Index> doesn't respect Lower and Upper bounds of the internal  array.
   Standard_EXPORT void SetValue (const Standard_Integer index, const TDF_Label& value);
-  
+
+  //! Sets the explicit GUID (user defined) for the attribute.
+  Standard_EXPORT void SetID( const Standard_GUID&  theGuid) Standard_OVERRIDE;
+
+  //! Sets default GUID for the attribute.
+  Standard_EXPORT void SetID() Standard_OVERRIDE;
+
   //! Returns the value of the <Index>th element of the array.
   Standard_EXPORT TDF_Label Value (const Standard_Integer Index) const;
-TDF_Label operator () (const Standard_Integer Index) const
-{
-  return Value(Index);
-}
+
+  TDF_Label operator () (const Standard_Integer Index) const
+  {
+    return Value(Index);
+  }
   
   //! Returns the lower boundary of the array.
   Standard_EXPORT Standard_Integer Lower() const;
@@ -105,7 +118,7 @@ private:
 
 
   Handle(TDataStd_HLabelArray1) myArray;
-
+  Standard_GUID myID;
 
 };
 
index 8dd2f34..98b4413 100644 (file)
@@ -36,6 +36,23 @@ const Standard_GUID& TDataStd_ReferenceList::GetID()
 }
 
 //=======================================================================
+//function : SetAttr
+//purpose  : Implements Set functionality
+//=======================================================================
+static Handle(TDataStd_ReferenceList) SetAttr(const TDF_Label&       label,
+                                              const Standard_GUID&   theGuid) 
+{
+  Handle(TDataStd_ReferenceList) A;
+  if (!label.FindAttribute (theGuid, A)) 
+  {
+    A = new TDataStd_ReferenceList;
+    A->SetID(theGuid);
+    label.AddAttribute(A);
+  }
+  return A;
+}
+
+//=======================================================================
 //function : TDataStd_ReferenceList
 //purpose  : Empty Constructor
 //=======================================================================
@@ -50,13 +67,17 @@ TDataStd_ReferenceList::TDataStd_ReferenceList()
 //=======================================================================
 Handle(TDataStd_ReferenceList) TDataStd_ReferenceList::Set(const TDF_Label& label) 
 {
-  Handle(TDataStd_ReferenceList) A;
-  if (!label.FindAttribute (TDataStd_ReferenceList::GetID(), A)) 
-  {
-    A = new TDataStd_ReferenceList;
-    label.AddAttribute(A);
-  }
-  return A;
+  return SetAttr(label, GetID());
+}
+
+//=======================================================================
+//function : Set
+//purpose  : Set user defined attribute with specific ID
+//=======================================================================
+Handle(TDataStd_ReferenceList) TDataStd_ReferenceList::Set(const TDF_Label& label,
+                                                           const Standard_GUID&   theGuid) 
+{
+  return SetAttr(label, theGuid);
 }
 
 //=======================================================================
@@ -102,7 +123,7 @@ void TDataStd_ReferenceList::Append(const TDF_Label& value)
 //purpose  : 
 //=======================================================================
 Standard_Boolean TDataStd_ReferenceList::InsertBefore(const TDF_Label& value,
-                                                     const TDF_Label& before_value)
+                                                      const TDF_Label& before_value)
 {
   TDF_ListIteratorOfLabelList itr(myList);
   for (; itr.More(); itr.Next())
@@ -143,7 +164,7 @@ Standard_Boolean TDataStd_ReferenceList::InsertBefore (const Standard_Integer in
 //purpose  : 
 //=======================================================================
 Standard_Boolean TDataStd_ReferenceList::InsertAfter(const TDF_Label& value,
-                                                    const TDF_Label& after_value)
+                                                     const TDF_Label& after_value)
 {
   TDF_ListIteratorOfLabelList itr(myList);
   for (; itr.More(); itr.Next())
@@ -263,7 +284,28 @@ const TDF_LabelList& TDataStd_ReferenceList::List() const
 //=======================================================================
 const Standard_GUID& TDataStd_ReferenceList::ID () const 
 { 
-  return GetID(); 
+  return myID; 
+}
+
+//=======================================================================
+//function : SetID
+//purpose  :
+//=======================================================================
+void TDataStd_ReferenceList::SetID( const Standard_GUID&  theGuid)
+{  
+  if(myID == theGuid) return;
+  Backup();
+  myID = theGuid;
+}
+
+//=======================================================================
+//function : SetID
+//purpose  : sets default ID
+//=======================================================================
+void TDataStd_ReferenceList::SetID()
+{  
+  Backup();
+  myID = GetID();
 }
 
 //=======================================================================
@@ -271,7 +313,7 @@ const Standard_GUID& TDataStd_ReferenceList::ID () const
 //purpose  : 
 //=======================================================================
 Handle(TDF_Attribute) TDataStd_ReferenceList::NewEmpty () const
-{  
+{
   return new TDataStd_ReferenceList(); 
 }
 
@@ -288,6 +330,7 @@ void TDataStd_ReferenceList::Restore(const Handle(TDF_Attribute)& With)
   {
     myList.Append(itr.Value());
   }
+  myID = aList->ID();
 }
 
 //=======================================================================
@@ -295,7 +338,7 @@ void TDataStd_ReferenceList::Restore(const Handle(TDF_Attribute)& With)
 //purpose  : 
 //=======================================================================
 void TDataStd_ReferenceList::Paste (const Handle(TDF_Attribute)& Into,
-                                   const Handle(TDF_RelocationTable)& RT) const
+                                    const Handle(TDF_RelocationTable)& RT) const
 {
   Handle(TDataStd_ReferenceList) aList = Handle(TDataStd_ReferenceList)::DownCast(Into);
   aList->Clear();
@@ -306,10 +349,11 @@ void TDataStd_ReferenceList::Paste (const Handle(TDF_Attribute)& Into,
     if (!L.IsNull())
     {
       if (!RT->HasRelocation(L, rL))
-       rL = L;
+        rL = L;
       aList->Append(rL);
     }
   }
+  aList->SetID(myID);
 }
 
 //=======================================================================
@@ -334,6 +378,10 @@ void TDataStd_ReferenceList::References(const Handle(TDF_DataSet)& aDataSet) con
 //=======================================================================
 Standard_OStream& TDataStd_ReferenceList::Dump (Standard_OStream& anOS) const
 {  
-  anOS << "ReferenceList";
+  anOS << "\nReferenceList: ";
+  Standard_Character sguid[Standard_GUID_SIZE_ALLOC];
+  myID.ToCString(sguid);
+  anOS << sguid;
+  anOS << endl;
   return anOS;
 }
index c65cd07..5de5ddb 100644 (file)
@@ -24,6 +24,8 @@
 #include <Standard_Boolean.hxx>
 #include <Standard_Integer.hxx>
 #include <Standard_OStream.hxx>
+#include <Standard_GUID.hxx>
+
 class Standard_GUID;
 class TDF_Label;
 class TDF_Attribute;
@@ -48,6 +50,9 @@ public:
   
   //! Finds or creates a list of reference values (labels) attribute.
   Standard_EXPORT static Handle(TDataStd_ReferenceList) Set (const TDF_Label& label);
+
+  //! Finds or creates a list of reference values (labels) attribute with explicit user defined <guid>.
+  Standard_EXPORT static Handle(TDataStd_ReferenceList) Set (const TDF_Label& label, const Standard_GUID& theGuid);
   
   Standard_EXPORT TDataStd_ReferenceList();
   
@@ -58,7 +63,13 @@ public:
   Standard_EXPORT void Prepend (const TDF_Label& value);
   
   Standard_EXPORT void Append (const TDF_Label& value);
-  
+
+  //! Sets the explicit GUID (user defined) for the attribute.
+  Standard_EXPORT void SetID( const Standard_GUID&  theGuid) Standard_OVERRIDE;
+
+  //! Sets default GUID for the attribute.
+  Standard_EXPORT void SetID() Standard_OVERRIDE;
+
   //! Inserts the <value> before the first meet of <before_value>.
   Standard_EXPORT Standard_Boolean InsertBefore (const TDF_Label& value, const TDF_Label& before_value);
   
@@ -113,7 +124,7 @@ private:
 
 
   TDF_LabelList myList;
-
+  Standard_GUID myID;
 
 };
 
index 79f98fb..f9253ed 100644 (file)
@@ -50,7 +50,7 @@ public:
   
   Standard_EXPORT TDataStd_UAttribute();
   
-  Standard_EXPORT void SetID (const Standard_GUID& LocalID);
+  Standard_EXPORT void SetID (const Standard_GUID& LocalID) Standard_OVERRIDE;
   
   Standard_EXPORT const Standard_GUID& ID() const Standard_OVERRIDE;
   
index 2e4538a..141c805 100644 (file)
@@ -178,24 +178,21 @@ void XCAFDoc_Datum::SetObject(const Handle(XCAFDimTolObjects_DatumObject)& theOb
     anIter.Value().ForgetAllAttributes();
   }
   if (!theObject->GetName().IsNull() && !theObject->GetName()->IsEmpty())
-       Handle(TDataStd_AsciiString) anAttName = TDataStd_AsciiString::Set(Label().FindChild(ChildLab_Name),
-                                                    theObject->GetName()->String());
+    Handle(TDataStd_AsciiString) anAttName = TDataStd_AsciiString::Set(Label().FindChild(ChildLab_Name),
+                                             theObject->GetName()->String());
 
   Handle(TDataStd_Integer) aPosition = TDataStd_Integer::Set(Label().FindChild(ChildLab_Position),
-                                          theObject->GetPosition());
+                                       theObject->GetPosition());
 
   if(theObject->GetModifiers().Length() > 0)
-  {
-    Handle(TDataStd_IntegerArray) aModifiers;
-    if(!Label().FindChild(ChildLab_Modifiers).FindAttribute(TDataStd_IntegerArray::GetID(), aModifiers))
-    {
-      aModifiers = new TDataStd_IntegerArray();
-      Label().FindChild(ChildLab_Modifiers).AddAttribute(aModifiers);
-    }
+  {   
     Handle(TColStd_HArray1OfInteger) anArr = new TColStd_HArray1OfInteger(1,theObject->GetModifiers().Length());
     for(Standard_Integer i = 1; i <= theObject->GetModifiers().Length(); i++)
       anArr->SetValue(i,theObject->GetModifiers().Value(i));
-    aModifiers->ChangeArray(anArr);
+    Handle(TDataStd_IntegerArray) aModifiers = TDataStd_IntegerArray::Set(Label().FindChild(ChildLab_Modifiers), 
+                                               1, theObject->GetModifiers().Length());
+    if(!aModifiers.IsNull())
+      aModifiers->ChangeArray(anArr);
   }
 
   XCAFDimTolObjects_DatumModifWithValue aM;
@@ -204,19 +201,19 @@ void XCAFDoc_Datum::SetObject(const Handle(XCAFDimTolObjects_DatumObject)& theOb
   if(aM != XCAFDimTolObjects_DatumModifWithValue_None)
   {
     Handle(TDataStd_Integer) aModifierWithValueM = 
-                                               TDataStd_Integer::Set(Label().FindChild(ChildLab_ModifierWithValue), aM);
+      TDataStd_Integer::Set(Label().FindChild(ChildLab_ModifierWithValue), aM);
 
     Handle(TDataStd_Real) aModifierWithValueV = 
-                                                  TDataStd_Real::Set(Label().FindChild(ChildLab_ModifierWithValue), aV);
+      TDataStd_Real::Set(Label().FindChild(ChildLab_ModifierWithValue), aV);
   }
 
   Handle(TDataStd_Integer) aIsTarget = TDataStd_Integer::Set(Label().FindChild(ChildLab_IsDTarget), 
-                                          theObject->IsDatumTarget());
+                                       theObject->IsDatumTarget());
 
   if(theObject->IsDatumTarget())
   {
     Handle(TDataStd_Integer) aType = TDataStd_Integer::Set(Label().FindChild(ChildLab_DTargetType), 
-                                            theObject->GetDatumTargetType());
+                                     theObject->GetDatumTargetType());
 
     if(theObject->GetDatumTargetType() == XCAFDimTolObjects_DatumTargetType_Area)
     {
@@ -228,94 +225,90 @@ void XCAFDoc_Datum::SetObject(const Handle(XCAFDimTolObjects_DatumObject)& theOb
     }
     else if (theObject->HasDatumTargetParams())
     {
-      Handle(TDataStd_RealArray) aLoc = new TDataStd_RealArray();
-      Handle(TDataStd_RealArray) aN = new TDataStd_RealArray();
-      Handle(TDataStd_RealArray) aR = new TDataStd_RealArray();
       gp_Ax2 anAx = theObject->GetDatumTargetAxis();
 
       Handle(TColStd_HArray1OfReal) aLocArr = new TColStd_HArray1OfReal(1, 3);
       for (Standard_Integer i = 1; i <= 3; i++)
         aLocArr->SetValue(i, anAx.Location().Coord(i));
-      aLoc->ChangeArray(aLocArr);
+      Handle(TDataStd_RealArray) aLoc = TDataStd_RealArray::Set(Label().FindChild(ChildLab_AxisLoc), 1, 3);
+      if(!aLoc.IsNull())
+        aLoc->ChangeArray(aLocArr);
 
       Handle(TColStd_HArray1OfReal) aNArr = new TColStd_HArray1OfReal(1, 3);
       for (Standard_Integer i = 1; i <= 3; i++)
         aNArr->SetValue(i, anAx.Direction().Coord(i));
-      aN->ChangeArray(aNArr);
+      Handle(TDataStd_RealArray) aN = TDataStd_RealArray::Set(Label().FindChild(ChildLab_AxisN), 1, 3);
+      if(!aN.IsNull())
+        aN->ChangeArray(aNArr);
 
       Handle(TColStd_HArray1OfReal) aRArr = new TColStd_HArray1OfReal(1, 3);
       for (Standard_Integer i = 1; i <= 3; i++)
         aRArr->SetValue(i, anAx.XDirection().Coord(i));
-      aR->ChangeArray(aRArr);
-
-      Label().FindChild(ChildLab_AxisLoc).AddAttribute(aLoc);
-      Label().FindChild(ChildLab_AxisN).AddAttribute(aN);
-      Label().FindChild(ChildLab_AxisRef).AddAttribute(aR);
+      Handle(TDataStd_RealArray) aR = TDataStd_RealArray::Set(Label().FindChild(ChildLab_AxisRef), 1, 3);
+      if(!aR.IsNull())
+        aR->ChangeArray(aRArr);
 
       if(theObject->GetDatumTargetType() != XCAFDimTolObjects_DatumTargetType_Point)
       {
         Handle(TDataStd_Real) aLen = TDataStd_Real::Set(Label().FindChild(ChildLab_DTargetLength),
-                                                theObject->GetDatumTargetLength());
+                                     theObject->GetDatumTargetLength());
         if(theObject->GetDatumTargetType() == XCAFDimTolObjects_DatumTargetType_Rectangle)
           Handle(TDataStd_Real) aWidth = TDataStd_Real::Set(Label().FindChild(ChildLab_DTargetWidth),
-                                                    theObject->GetDatumTargetWidth());
+                                         theObject->GetDatumTargetWidth());
       }
     }
     Handle(TDataStd_Integer) aNum = TDataStd_Integer::Set(Label().FindChild(ChildLab_DTargetNumber), 
-                                           theObject->GetDatumTargetNumber());
+                                    theObject->GetDatumTargetNumber());
   }
 
   if (theObject->HasPlane())
   {
-    Handle(TDataStd_RealArray) aLoc = new TDataStd_RealArray();
-    Handle(TDataStd_RealArray) aN = new TDataStd_RealArray();
-    Handle(TDataStd_RealArray) aR = new TDataStd_RealArray();
     gp_Ax2 anAx = theObject->GetPlane();
 
     Handle(TColStd_HArray1OfReal) aLocArr = new TColStd_HArray1OfReal(1, 3);
     for (Standard_Integer i = 1; i <= 3; i++)
       aLocArr->SetValue(i, anAx.Location().Coord(i));
-    aLoc->ChangeArray(aLocArr);
+    Handle(TDataStd_RealArray) aLoc = TDataStd_RealArray::Set(Label().FindChild(ChildLab_PlaneLoc), 1, 3);
+    if(!aLoc.IsNull())
+      aLoc->ChangeArray(aLocArr);
 
     Handle(TColStd_HArray1OfReal) aNArr = new TColStd_HArray1OfReal(1, 3);
     for (Standard_Integer i = 1; i <= 3; i++)
       aNArr->SetValue(i, anAx.Direction().Coord(i));
-    aN->ChangeArray(aNArr);
+    Handle(TDataStd_RealArray) aN = TDataStd_RealArray::Set(Label().FindChild(ChildLab_PlaneN), 1, 3);
+    if(!aN.IsNull())
+      aN->ChangeArray(aNArr);
 
     Handle(TColStd_HArray1OfReal) aRArr = new TColStd_HArray1OfReal(1, 3);
     for (Standard_Integer i = 1; i <= 3; i++)
       aRArr->SetValue(i, anAx.XDirection().Coord(i));
-    aR->ChangeArray(aRArr);
-
-    Label().FindChild(ChildLab_PlaneLoc).AddAttribute(aLoc);
-    Label().FindChild(ChildLab_PlaneN).AddAttribute(aN);
-    Label().FindChild(ChildLab_PlaneRef).AddAttribute(aR);
+    Handle(TDataStd_RealArray) aR = TDataStd_RealArray::Set(Label().FindChild(ChildLab_PlaneRef), 1, 3);
+    if(!aR.IsNull())
+      aR->ChangeArray(aRArr);
   }
 
   if (theObject->HasPoint())
   {
-    Handle(TDataStd_RealArray) aLoc = new TDataStd_RealArray();
     gp_Pnt aPnt = theObject->GetPoint();
 
     Handle(TColStd_HArray1OfReal) aLocArr = new TColStd_HArray1OfReal(1, 3);
     for (Standard_Integer i = 1; i <= 3; i++)
       aLocArr->SetValue(i, aPnt.Coord(i));
-    aLoc->ChangeArray(aLocArr);
-
-    Label().FindChild(ChildLab_Pnt).AddAttribute(aLoc);
+    Handle(TDataStd_RealArray) aLoc = TDataStd_RealArray::Set(Label().FindChild(ChildLab_Pnt), 1, 3);
+    if(!aLoc.IsNull())
+      aLoc->ChangeArray(aLocArr);
   }
 
   if (theObject->HasPointText())
   {
-    Handle(TDataStd_RealArray) aLoc = new TDataStd_RealArray();
     gp_Pnt aPntText = theObject->GetPointTextAttach();
 
     Handle(TColStd_HArray1OfReal) aLocArr = new TColStd_HArray1OfReal(1, 3);
     for (Standard_Integer i = 1; i <= 3; i++)
       aLocArr->SetValue(i, aPntText.Coord(i));
-    aLoc->ChangeArray(aLocArr);
-
-    Label().FindChild(ChildLab_PntText).AddAttribute(aLoc);
+    Handle(TDataStd_RealArray) aLoc = TDataStd_RealArray::Set(Label().FindChild(ChildLab_PntText), 1, 3);
+    if(!aLoc.IsNull())
+      aLoc->ChangeArray(aLocArr);
   }
   TopoDS_Shape aPresentation = theObject->GetPresentation();
   if( !aPresentation.IsNull())
index a210dac..5fccb04 100644 (file)
@@ -110,9 +110,10 @@ void XCAFDoc_Dimension::SetObject (const Handle(XCAFDimTolObjects_DimensionObjec
 
   if(!theObject->GetValues().IsNull())
   {
-    Handle(TDataStd_RealArray) aVal = new TDataStd_RealArray();
-    Label().FindChild(ChildLab_Value).AddAttribute(aVal);
-    aVal->ChangeArray(theObject->GetValues());
+    Handle(TDataStd_RealArray) aVal = TDataStd_RealArray::Set(Label().FindChild(ChildLab_Value), theObject->GetValues()->Lower(), 
+                                      theObject->GetValues()->Lower() + theObject->GetValues()->Length() - 1);
+    if(!aVal.IsNull())
+      aVal->ChangeArray(theObject->GetValues());
   }
 
   Handle(TDataStd_Integer) aQualifier = TDataStd_Integer::Set(Label().FindChild(ChildLab_Qualifier), theObject->GetQualifier());
@@ -124,35 +125,36 @@ void XCAFDoc_Dimension::SetObject (const Handle(XCAFDimTolObjects_DimensionObjec
   Handle(TColStd_HArray1OfInteger) anArrI;
   if(aF != XCAFDimTolObjects_DimensionFormVariance_None)
   {
-    Handle(TDataStd_IntegerArray) aClass = new TDataStd_IntegerArray();
-    Label().FindChild(ChildLab_Class).AddAttribute(aClass);
     anArrI = new TColStd_HArray1OfInteger(1,3);
     anArrI->SetValue(1,aH);
     anArrI->SetValue(2,aF);
     anArrI->SetValue(3,aG);
-    aClass->ChangeArray(anArrI);
+    Handle(TDataStd_IntegerArray) aClass = TDataStd_IntegerArray::Set(Label().FindChild(ChildLab_Class), 1, 3);
+    if(!aClass.IsNull())
+      aClass->ChangeArray(anArrI);
   }
 
   Standard_Integer aL, aR;
   theObject->GetNbOfDecimalPlaces(aL, aR);
   if (aL > 0 || aR > 0)
   {
-    Handle(TDataStd_IntegerArray) aDec = new TDataStd_IntegerArray();
-    Label().FindChild(ChildLab_Dec).AddAttribute(aDec);
     anArrI = new TColStd_HArray1OfInteger(1,2);
     anArrI->SetValue(1,aL);
     anArrI->SetValue(2,aR);
-    aDec->ChangeArray(anArrI);
+    Handle(TDataStd_IntegerArray) aDec = TDataStd_IntegerArray::Set(Label().FindChild(ChildLab_Dec), 1, 2);
+    if(!aDec.IsNull())
+      aDec->ChangeArray(anArrI);
   }
 
   if(theObject->GetModifiers().Length() > 0)
   {
-    Handle(TDataStd_IntegerArray) aModifiers = new TDataStd_IntegerArray();
-    Label().FindChild(ChildLab_Modifiers).AddAttribute(aModifiers);
     anArrI = new TColStd_HArray1OfInteger(1,theObject->GetModifiers().Length());
     for(Standard_Integer i = 1; i <= theObject->GetModifiers().Length(); i++)
       anArrI->SetValue(i,theObject->GetModifiers().Value(i));
-    aModifiers->ChangeArray(anArrI);
+    Handle(TDataStd_IntegerArray) aModifiers = TDataStd_IntegerArray::Set(Label().FindChild(ChildLab_Modifiers), 
+                                               1, theObject->GetModifiers().Length());
+    if(!aModifiers.IsNull())
+      aModifiers->ChangeArray(anArrI);
   }
 
   if(!theObject->GetPath().IsNull())
@@ -166,79 +168,75 @@ void XCAFDoc_Dimension::SetObject (const Handle(XCAFDimTolObjects_DimensionObjec
   {
     gp_Dir aD;
     theObject->GetDirection(aD);
-    Handle(TDataStd_RealArray) aDir = new TDataStd_RealArray();
-    Label().FindChild(ChildLab_Dir).AddAttribute(aDir);
     anArrR = new TColStd_HArray1OfReal(1,3);
     anArrR->SetValue(1,aD.X());
     anArrR->SetValue(2,aD.Y());
     anArrR->SetValue(3,aD.Z());
-    aDir->ChangeArray(anArrR);
+    Handle(TDataStd_RealArray) aDir = TDataStd_RealArray::Set(Label().FindChild(ChildLab_Dir), 1, 3);
+    if(!aDir.IsNull())
+      aDir->ChangeArray(anArrR);
   }
 
   if (theObject->HasPoint())
   {
-    Handle(TDataStd_RealArray) aPnt = new TDataStd_RealArray();
     gp_Pnt aPnt1 = theObject->GetPoint();
 
     Handle(TColStd_HArray1OfReal) aPntArr = new TColStd_HArray1OfReal(1, 3);
     for (Standard_Integer i = 1; i <= 3; i++)
       aPntArr->SetValue(i, aPnt1.Coord(i));
-    aPnt->ChangeArray(aPntArr);
-
-    Label().FindChild(ChildLab_Pnt1).AddAttribute(aPnt);
+    Handle(TDataStd_RealArray) aPnt = TDataStd_RealArray::Set(Label().FindChild(ChildLab_Pnt1), 1, 3);
+    if(!aPnt.IsNull())
+      aPnt->ChangeArray(aPntArr);
   }
 
   if (theObject->HasPoint2())
   {
-    Handle(TDataStd_RealArray) aPnt = new TDataStd_RealArray();
     gp_Pnt aPnt2 = theObject->GetPoint2();
 
     Handle(TColStd_HArray1OfReal) aPntArr = new TColStd_HArray1OfReal(1, 3);
     for (Standard_Integer i = 1; i <= 3; i++)
       aPntArr->SetValue(i, aPnt2.Coord(i));
-    aPnt->ChangeArray(aPntArr);
-
-    Label().FindChild(ChildLab_Pnt2).AddAttribute(aPnt);
+    Handle(TDataStd_RealArray) aPnt = TDataStd_RealArray::Set(Label().FindChild(ChildLab_Pnt2), 1, 3);
+    if(!aPnt.IsNull())
+      aPnt->ChangeArray(aPntArr);
   }
 
   if (theObject->HasPlane())
   {
-    Handle(TDataStd_RealArray) aLoc = new TDataStd_RealArray();
-    Handle(TDataStd_RealArray) aN = new TDataStd_RealArray();
-    Handle(TDataStd_RealArray) aRAtt = new TDataStd_RealArray();
     gp_Ax2 anAx = theObject->GetPlane();
 
     Handle(TColStd_HArray1OfReal) aLocArr = new TColStd_HArray1OfReal(1, 3);
     for (Standard_Integer i = 1; i <= 3; i++)
       aLocArr->SetValue(i, anAx.Location().Coord(i));
-    aLoc->ChangeArray(aLocArr);
+    Handle(TDataStd_RealArray) aLoc = TDataStd_RealArray::Set(Label().FindChild(ChildLab_PlaneLoc), 1, 3);
+    if(!aLoc.IsNull())
+      aLoc->ChangeArray(aLocArr);
 
     Handle(TColStd_HArray1OfReal) aNArr = new TColStd_HArray1OfReal(1, 3);
     for (Standard_Integer i = 1; i <= 3; i++)
       aNArr->SetValue(i, anAx.Direction().Coord(i));
-    aN->ChangeArray(aNArr);
+    Handle(TDataStd_RealArray) aN = TDataStd_RealArray::Set(Label().FindChild(ChildLab_PlaneN), 1, 3);
+    if(!aN.IsNull())
+      aN->ChangeArray(aNArr);
 
     Handle(TColStd_HArray1OfReal) aRArr = new TColStd_HArray1OfReal(1, 3);
     for (Standard_Integer i = 1; i <= 3; i++)
       aRArr->SetValue(i, anAx.XDirection().Coord(i));
-    aRAtt->ChangeArray(aRArr);
-
-    Label().FindChild(ChildLab_PlaneLoc).AddAttribute(aLoc);
-    Label().FindChild(ChildLab_PlaneN).AddAttribute(aN);
-    Label().FindChild(ChildLab_PlaneRef).AddAttribute(aRAtt);
+    Handle(TDataStd_RealArray) aRAtt = TDataStd_RealArray::Set(Label().FindChild(ChildLab_PlaneRef), 1, 3);
+    if(!aRAtt.IsNull())
+      aRAtt->ChangeArray(aRArr);
   }
 
   if (theObject->HasTextPoint())
   {
-    Handle(TDataStd_RealArray) aLoc = new TDataStd_RealArray();
     gp_Pnt aPntText = theObject->GetPointTextAttach();
 
     Handle(TColStd_HArray1OfReal) aLocArr = new TColStd_HArray1OfReal(1, 3);
     for (Standard_Integer i = 1; i <= 3; i++)
       aLocArr->SetValue(i, aPntText.Coord(i));
-    aLoc->ChangeArray(aLocArr);
-
-    Label().FindChild(ChildLab_PntText).AddAttribute(aLoc);
+    Handle(TDataStd_RealArray) aLoc = TDataStd_RealArray::Set(Label().FindChild(ChildLab_PntText), 1, 3);
+    if(!aLoc.IsNull())
+      aLoc->ChangeArray(aLocArr);
   }
 
   TopoDS_Shape aPresentation = theObject->GetPresentation();
@@ -257,8 +255,6 @@ void XCAFDoc_Dimension::SetObject (const Handle(XCAFDimTolObjects_DimensionObjec
 
   if (theObject->HasDescriptions())
   {
-    Handle(TDataStd_ExtStringArray) aDescriptions = new TDataStd_ExtStringArray();
-    Handle(TDataStd_ExtStringArray) aDescriptionNames = new TDataStd_ExtStringArray();
     Handle(TColStd_HArray1OfExtendedString) aDescrArr = new TColStd_HArray1OfExtendedString(1, theObject->NbDescriptions());
     Handle(TColStd_HArray1OfExtendedString) aDescrNameArr = new TColStd_HArray1OfExtendedString(1, theObject->NbDescriptions());
     for (Standard_Integer i = 0; i < theObject->NbDescriptions(); i++) {
@@ -267,10 +263,14 @@ void XCAFDoc_Dimension::SetObject (const Handle(XCAFDimTolObjects_DimensionObjec
       TCollection_ExtendedString aDescrName(theObject->GetDescriptionName(i)->String());
       aDescrNameArr->SetValue(i + 1, aDescrName);
     }
-    aDescriptions->ChangeArray(aDescrArr);
-    aDescriptionNames->ChangeArray(aDescrNameArr);
-    Label().FindChild(ChildLab_Descriptions).AddAttribute(aDescriptions);
-    Label().FindChild(ChildLab_DescriptionNames).AddAttribute(aDescriptionNames);
+    Handle(TDataStd_ExtStringArray) aDescriptions = TDataStd_ExtStringArray::Set(Label().FindChild(ChildLab_Descriptions),
+                                                    1, theObject->NbDescriptions());
+    Handle(TDataStd_ExtStringArray) aDescriptionNames = TDataStd_ExtStringArray::Set(Label().FindChild(ChildLab_DescriptionNames),
+                                                        1, theObject->NbDescriptions());
+    if(!aDescriptions.IsNull())
+      aDescriptions->ChangeArray(aDescrArr);
+    if(!aDescriptionNames.IsNull())
+      aDescriptionNames->ChangeArray(aDescrNameArr);
   }
 }
 
index 0ef458f..0caa73b 100644 (file)
@@ -108,115 +108,112 @@ void XCAFDoc_GeomTolerance::SetObject (const Handle(XCAFDimTolObjects_GeomTolera
 
   if(theObject->GetTypeOfValue() != XCAFDimTolObjects_GeomToleranceTypeValue_None)
     Handle(TDataStd_Integer) aTypeOfValue = TDataStd_Integer::Set(Label().FindChild(ChildLab_TypeOfValue), 
-                                               theObject->GetTypeOfValue());
+                                            theObject->GetTypeOfValue());
 
   Handle(TDataStd_Real) aValue = TDataStd_Real::Set(Label().FindChild(ChildLab_Value), theObject->GetValue());
 
   Handle(TDataStd_Integer) aMatReqModif;
   if(theObject->GetMaterialRequirementModifier() != XCAFDimTolObjects_GeomToleranceMatReqModif_None)
-       aMatReqModif = TDataStd_Integer::Set(Label().FindChild(ChildLab_MatReqModif), 
-                      theObject->GetMaterialRequirementModifier());
+    aMatReqModif = TDataStd_Integer::Set(Label().FindChild(ChildLab_MatReqModif), 
+                   theObject->GetMaterialRequirementModifier());
 
   if(theObject->GetZoneModifier() != XCAFDimTolObjects_GeomToleranceZoneModif_None)
     Handle(TDataStd_Integer) aZoneModif = TDataStd_Integer::Set(Label().FindChild(ChildLab_ZoneModif), 
-                                             theObject->GetZoneModifier());
+                                          theObject->GetZoneModifier());
   
   if(theObject->GetValueOfZoneModifier() > 0)
     Handle(TDataStd_Real) aValueOfZoneModif = TDataStd_Real::Set(Label().FindChild(ChildLab_ValueOfZoneModif),
-                                                     theObject->GetValueOfZoneModifier());
+                                              theObject->GetValueOfZoneModifier());
 
   if(theObject->GetModifiers().Length() > 0)
   {
-    Handle(TDataStd_IntegerArray) aModifiers = new TDataStd_IntegerArray();
     Handle(TColStd_HArray1OfInteger) anArr = new TColStd_HArray1OfInteger(1,theObject->GetModifiers().Length());
     for(Standard_Integer i = 1; i <= theObject->GetModifiers().Length(); i++)
       anArr->SetValue(i,theObject->GetModifiers().Value(i));
-    aModifiers->ChangeArray(anArr);
-    Label().FindChild(ChildLab_Modifiers).AddAttribute(aModifiers);
+    Handle(TDataStd_IntegerArray) aModifiers = TDataStd_IntegerArray::Set(Label().FindChild(ChildLab_Modifiers), 
+                                               1, theObject->GetModifiers().Length());
+    if(!aModifiers.IsNull())
+      aModifiers->ChangeArray(anArr);
   }
 
   if(theObject->GetMaxValueModifier() > 0)
     Handle(TDataStd_Real) aMaxValueModif = TDataStd_Real::Set(Label().FindChild(ChildLab_aMaxValueModif),
-                                                  theObject->GetMaxValueModifier());
+                                           theObject->GetMaxValueModifier());
 
   if(theObject->HasAxis())
   {
-    Handle(TDataStd_RealArray) aLoc = new TDataStd_RealArray();
-    Handle(TDataStd_RealArray) aN = new TDataStd_RealArray();
-    Handle(TDataStd_RealArray) aR = new TDataStd_RealArray();
     gp_Ax2 anAx = theObject->GetAxis();
 
     Handle(TColStd_HArray1OfReal) aLocArr = new TColStd_HArray1OfReal(1, 3);
     for (Standard_Integer i = 1; i <= 3; i++)
       aLocArr->SetValue(i, anAx.Location().Coord(i));
-    aLoc->ChangeArray(aLocArr);
+    Handle(TDataStd_RealArray) aLoc = TDataStd_RealArray::Set(Label().FindChild(ChildLab_AxisLoc), 1, 3);
+    if(!aLoc.IsNull())
+      aLoc->ChangeArray(aLocArr);
 
     Handle(TColStd_HArray1OfReal) aNArr = new TColStd_HArray1OfReal(1, 3);
     for (Standard_Integer i = 1; i <= 3; i++)
       aNArr->SetValue(i, anAx.Direction().Coord(i));
-    aN->ChangeArray(aNArr);
+    Handle(TDataStd_RealArray) aN = TDataStd_RealArray::Set(Label().FindChild(ChildLab_AxisN), 1, 3);
+    if(!aN.IsNull())
+      aN->ChangeArray(aNArr);
 
     Handle(TColStd_HArray1OfReal) aRArr = new TColStd_HArray1OfReal(1, 3);
     for (Standard_Integer i = 1; i <= 3; i++)
       aRArr->SetValue(i, anAx.XDirection().Coord(i));
-    aR->ChangeArray(aRArr);
-
-    Label().FindChild(ChildLab_AxisLoc).AddAttribute(aLoc);
-    Label().FindChild(ChildLab_AxisN).AddAttribute(aN);
-    Label().FindChild(ChildLab_AxisRef).AddAttribute(aR);
+    Handle(TDataStd_RealArray) aR = TDataStd_RealArray::Set(Label().FindChild(ChildLab_AxisRef), 1, 3);
+    if(!aR.IsNull())
+      aR->ChangeArray(aRArr);
   }
 
   if (theObject->HasPlane())
   {
-    Handle(TDataStd_RealArray) aLoc = new TDataStd_RealArray();
-    Handle(TDataStd_RealArray) aN = new TDataStd_RealArray();
-    Handle(TDataStd_RealArray) aR = new TDataStd_RealArray();
     gp_Ax2 anAx = theObject->GetPlane();
 
     Handle(TColStd_HArray1OfReal) aLocArr = new TColStd_HArray1OfReal(1, 3);
     for (Standard_Integer i = 1; i <= 3; i++)
       aLocArr->SetValue(i, anAx.Location().Coord(i));
-    aLoc->ChangeArray(aLocArr);
+    Handle(TDataStd_RealArray) aLoc = TDataStd_RealArray::Set(Label().FindChild(ChildLab_PlaneLoc), 1, 3);
+    if(!aLoc.IsNull())
+      aLoc->ChangeArray(aLocArr);
 
     Handle(TColStd_HArray1OfReal) aNArr = new TColStd_HArray1OfReal(1, 3);
     for (Standard_Integer i = 1; i <= 3; i++)
       aNArr->SetValue(i, anAx.Direction().Coord(i));
-    aN->ChangeArray(aNArr);
+    Handle(TDataStd_RealArray) aN = TDataStd_RealArray::Set(Label().FindChild(ChildLab_PlaneN), 1, 3);
+    if(!aN.IsNull())
+      aN->ChangeArray(aNArr);
 
     Handle(TColStd_HArray1OfReal) aRArr = new TColStd_HArray1OfReal(1, 3);
     for (Standard_Integer i = 1; i <= 3; i++)
       aRArr->SetValue(i, anAx.XDirection().Coord(i));
-    aR->ChangeArray(aRArr);
-
-    Label().FindChild(ChildLab_PlaneLoc).AddAttribute(aLoc);
-    Label().FindChild(ChildLab_PlaneN).AddAttribute(aN);
-    Label().FindChild(ChildLab_PlaneRef).AddAttribute(aR);
+    Handle(TDataStd_RealArray) aR = TDataStd_RealArray::Set(Label().FindChild(ChildLab_PlaneRef), 1, 3);
+    if(!aR.IsNull())
+      aR->ChangeArray(aRArr);
   }
 
   if (theObject->HasPoint())
   {
-    Handle(TDataStd_RealArray) aLoc = new TDataStd_RealArray();
     gp_Pnt aPnt = theObject->GetPoint();
 
     Handle(TColStd_HArray1OfReal) aLocArr = new TColStd_HArray1OfReal(1, 3);
     for (Standard_Integer i = 1; i <= 3; i++)
       aLocArr->SetValue(i, aPnt.Coord(i));
-    aLoc->ChangeArray(aLocArr);
-
-    Label().FindChild(ChildLab_Pnt).AddAttribute(aLoc);
+    Handle(TDataStd_RealArray) aLoc = TDataStd_RealArray::Set(Label().FindChild(ChildLab_Pnt), 1, 3);
+    if(!aLoc.IsNull())
+      aLoc->ChangeArray(aLocArr);
   }
 
   if (theObject->HasPointText())
   {
-    Handle(TDataStd_RealArray) aLoc = new TDataStd_RealArray();
     gp_Pnt aPntText = theObject->GetPointTextAttach();
 
     Handle(TColStd_HArray1OfReal) aLocArr = new TColStd_HArray1OfReal(1, 3);
     for (Standard_Integer i = 1; i <= 3; i++)
       aLocArr->SetValue(i, aPntText.Coord(i));
-    aLoc->ChangeArray(aLocArr);
-
-    Label().FindChild(ChildLab_PntText).AddAttribute(aLoc);
+    Handle(TDataStd_RealArray) aLoc = TDataStd_RealArray::Set(Label().FindChild(ChildLab_PntText), 1, 3);
+    if(!aLoc.IsNull())
+      aLoc->ChangeArray(aLocArr);
   }
 
   TopoDS_Shape aPresentation = theObject->GetPresentation();
index 7c7b3ca..6fa2c1b 100644 (file)
@@ -27,7 +27,7 @@
 IMPLEMENT_STANDARD_RTTIEXT(XmlMDataStd_BooleanArrayDriver,XmlMDF_ADriver)
 IMPLEMENT_DOMSTRING (FirstIndexString, "first")
 IMPLEMENT_DOMSTRING (LastIndexString,  "last")
-
+IMPLEMENT_DOMSTRING (AttributeIDString, "boolarrattguid")
 //=======================================================================
 //function : XmlMDataStd_BooleanArrayDriver
 //purpose  : Constructor
@@ -52,8 +52,8 @@ Handle(TDF_Attribute) XmlMDataStd_BooleanArrayDriver::NewEmpty() const
 //purpose  : persistent -> transient (retrieve)
 //=======================================================================
 Standard_Boolean XmlMDataStd_BooleanArrayDriver::Paste(const XmlObjMgt_Persistent&  theSource,
-                                                      const Handle(TDF_Attribute)& theTarget,
-                                                      XmlObjMgt_RRelocationTable&  ) const
+                                                       const Handle(TDF_Attribute)& theTarget,
+                                                       XmlObjMgt_RRelocationTable&  ) const
 {
   Standard_Integer aFirstInd, aLastInd, aValue;
   const XmlObjMgt_Element& anElement = theSource;
@@ -105,16 +105,24 @@ Standard_Boolean XmlMDataStd_BooleanArrayDriver::Paste(const XmlObjMgt_Persisten
     if (!XmlObjMgt::GetInteger(aValueStr, aValue)) 
     {
       TCollection_ExtendedString aMessageString =
-       TCollection_ExtendedString("Cannot retrieve integer member"
-                                  " for BooleanArray attribute as \"")
-         + aValueStr + "\"";
+        TCollection_ExtendedString("Cannot retrieve integer member"
+        " for BooleanArray attribute as \"")
+        + aValueStr + "\"";
       WriteMessage (aMessageString);
       return Standard_False;
     }
     arr.SetValue(i, (Standard_Byte) aValue);
   }
   aBooleanArray->SetInternalArray(hArr);
-  
+
+  // attribute id
+  Standard_GUID aGUID;
+  XmlObjMgt_DOMString aGUIDStr = anElement.getAttribute(::AttributeIDString());
+  if (aGUIDStr.Type() == XmlObjMgt_DOMString::LDOM_NULL)
+    aGUID = TDataStd_BooleanArray::GetID(); //default case
+  else
+    aGUID = Standard_GUID(Standard_CString(aGUIDStr.GetString())); // user defined case
+  aBooleanArray->SetID(aGUID);
   return Standard_True;
 }
 
@@ -123,8 +131,8 @@ Standard_Boolean XmlMDataStd_BooleanArrayDriver::Paste(const XmlObjMgt_Persisten
 //purpose  : transient -> persistent (store)
 //=======================================================================
 void XmlMDataStd_BooleanArrayDriver::Paste(const Handle(TDF_Attribute)& theSource,
-                                          XmlObjMgt_Persistent&        theTarget,
-                                          XmlObjMgt_SRelocationTable&  ) const
+                                           XmlObjMgt_Persistent&        theTarget,
+                                           XmlObjMgt_SRelocationTable&  ) const
 {
   Handle(TDataStd_BooleanArray) aBooleanArray = Handle(TDataStd_BooleanArray)::DownCast(theSource);
 
@@ -153,4 +161,11 @@ void XmlMDataStd_BooleanArrayDriver::Paste(const Handle(TDF_Attribute)& theSourc
 
   if (arr.Length())
     XmlObjMgt::SetStringValue (theTarget, (Standard_Character*)str, Standard_True);
+    if(aBooleanArray->ID() != TDataStd_BooleanArray::GetID()) {
+    //convert GUID
+    Standard_Character aGuidStr [Standard_GUID_SIZE_ALLOC];
+    Standard_PCharacter pGuidStr = aGuidStr;
+    aBooleanArray->ID().ToCString (pGuidStr);
+    theTarget.Element().setAttribute (::AttributeIDString(), aGuidStr);
+  }
 }
index e07c52f..e78a52d 100644 (file)
@@ -27,6 +27,7 @@
 IMPLEMENT_STANDARD_RTTIEXT(XmlMDataStd_BooleanListDriver,XmlMDF_ADriver)
 IMPLEMENT_DOMSTRING (FirstIndexString, "first")
 IMPLEMENT_DOMSTRING (LastIndexString,  "last")
+IMPLEMENT_DOMSTRING (AttributeIDString, "boollistattguid")
 
 //=======================================================================
 //function : XmlMDataStd_BooleanListDriver
@@ -52,8 +53,8 @@ Handle(TDF_Attribute) XmlMDataStd_BooleanListDriver::NewEmpty() const
 //purpose  : persistent -> transient (retrieve)
 //=======================================================================
 Standard_Boolean XmlMDataStd_BooleanListDriver::Paste(const XmlObjMgt_Persistent&  theSource,
-                                                     const Handle(TDF_Attribute)& theTarget,
-                                                     XmlObjMgt_RRelocationTable&  ) const
+                                                      const Handle(TDF_Attribute)& theTarget,
+                                                      XmlObjMgt_RRelocationTable&  ) const
 {
   Standard_Integer aFirstInd, aLastInd, aValue, ind;
   const XmlObjMgt_Element& anElement = theSource;
@@ -115,7 +116,17 @@ Standard_Boolean XmlMDataStd_BooleanListDriver::Paste(const XmlObjMgt_Persistent
       aBooleanList->Append(aValue ? Standard_True : Standard_False);
     }
   }
-  
+
+  // attribute id
+  Standard_GUID aGUID;
+  XmlObjMgt_DOMString aGUIDStr = anElement.getAttribute(::AttributeIDString());
+  if (aGUIDStr.Type() == XmlObjMgt_DOMString::LDOM_NULL)
+    aGUID = TDataStd_BooleanList::GetID(); //default case
+  else
+    aGUID = Standard_GUID(Standard_CString(aGUIDStr.GetString())); // user defined case
+
+  aBooleanList->SetID(aGUID);
+
   return Standard_True;
 }
 
@@ -124,8 +135,8 @@ Standard_Boolean XmlMDataStd_BooleanListDriver::Paste(const XmlObjMgt_Persistent
 //purpose  : transient -> persistent (store)
 //=======================================================================
 void XmlMDataStd_BooleanListDriver::Paste(const Handle(TDF_Attribute)& theSource,
-                                         XmlObjMgt_Persistent&        theTarget,
-                                         XmlObjMgt_SRelocationTable&  ) const
+                                          XmlObjMgt_Persistent&        theTarget,
+                                          XmlObjMgt_SRelocationTable&  ) const
 {
   const Handle(TDataStd_BooleanList) aBooleanList = Handle(TDataStd_BooleanList)::DownCast(theSource);
 
@@ -145,4 +156,12 @@ void XmlMDataStd_BooleanListDriver::Paste(const Handle(TDF_Attribute)& theSource
     }
   }
   XmlObjMgt::SetStringValue (theTarget, (Standard_Character*)str, Standard_True);
+
+  if(aBooleanList->ID() != TDataStd_BooleanList::GetID()) {
+    //convert GUID
+    Standard_Character aGuidStr [Standard_GUID_SIZE_ALLOC];
+    Standard_PCharacter pGuidStr = aGuidStr;
+    aBooleanList->ID().ToCString (pGuidStr);
+    theTarget.Element().setAttribute (::AttributeIDString(), aGuidStr);
+  }
 }
index 6d5ce67..988ad28 100644 (file)
@@ -24,6 +24,7 @@
 #include <XmlMDataStd_ByteArrayDriver.hxx>
 #include <XmlObjMgt.hxx>
 #include <XmlObjMgt_Persistent.hxx>
+IMPLEMENT_DOMSTRING (AttributeIDString, "bytearrattguid")
 
 IMPLEMENT_STANDARD_RTTIEXT(XmlMDataStd_ByteArrayDriver,XmlMDF_ADriver)
 IMPLEMENT_DOMSTRING (FirstIndexString, "first")
@@ -53,8 +54,8 @@ Handle(TDF_Attribute) XmlMDataStd_ByteArrayDriver::NewEmpty() const
 //purpose  : persistent -> transient (retrieve)
 //=======================================================================
 Standard_Boolean XmlMDataStd_ByteArrayDriver::Paste(const XmlObjMgt_Persistent&  theSource,
-                                                   const Handle(TDF_Attribute)& theTarget,
-                                                   XmlObjMgt_RRelocationTable&  ) const
+                                                    const Handle(TDF_Attribute)& theTarget,
+                                                    XmlObjMgt_RRelocationTable&  ) const
 {
   Standard_Integer aFirstInd, aLastInd, aValue;
   const XmlObjMgt_Element& anElement = theSource;
@@ -105,9 +106,9 @@ Standard_Boolean XmlMDataStd_ByteArrayDriver::Paste(const XmlObjMgt_Persistent&
     if (!XmlObjMgt::GetInteger(aValueStr, aValue)) 
     {
       TCollection_ExtendedString aMessageString =
-       TCollection_ExtendedString("Cannot retrieve integer member"
-                                  " for ByteArray attribute as \"")
-         + aValueStr + "\"";
+        TCollection_ExtendedString("Cannot retrieve integer member"
+                                   " for ByteArray attribute as \"")
+                                   + aValueStr + "\"";
       WriteMessage (aMessageString);
       return Standard_False;
     }
@@ -120,14 +121,14 @@ Standard_Boolean XmlMDataStd_ByteArrayDriver::Paste(const XmlObjMgt_Persistent&
   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;
-      } 
+    {
+      TCollection_ExtendedString aMessageString =
+        TCollection_ExtendedString("Cannot retrieve the isDelta value"
+                                   " for ByteArray attribute as \"")
+                                   + aDeltaValue + "\"";
+      WriteMessage (aMessageString);
+      return Standard_False;
+    } 
     else
       aDelta = aDeltaValue != 0;
   }
@@ -137,6 +138,16 @@ Standard_Boolean XmlMDataStd_ByteArrayDriver::Paste(const XmlObjMgt_Persistent&
 #endif
   aByteArray->SetDelta(aDelta);
 
+  // attribute id
+  Standard_GUID aGUID;
+  XmlObjMgt_DOMString aGUIDStr = anElement.getAttribute(::AttributeIDString());
+  if (aGUIDStr.Type() == XmlObjMgt_DOMString::LDOM_NULL)
+    aGUID = TDataStd_ByteArray::GetID(); //default case
+  else
+    aGUID = Standard_GUID(Standard_CString(aGUIDStr.GetString())); // user defined case
+
+  aByteArray->SetID(aGUID);
+
   return Standard_True;
 }
 
@@ -145,8 +156,8 @@ Standard_Boolean XmlMDataStd_ByteArrayDriver::Paste(const XmlObjMgt_Persistent&
 //purpose  : transient -> persistent (store)
 //=======================================================================
 void XmlMDataStd_ByteArrayDriver::Paste(const Handle(TDF_Attribute)& theSource,
-                                       XmlObjMgt_Persistent&        theTarget,
-                                       XmlObjMgt_SRelocationTable&  ) const
+                                        XmlObjMgt_Persistent&        theTarget,
+                                        XmlObjMgt_SRelocationTable&  ) const
 {
   Handle(TDataStd_ByteArray) aByteArray = Handle(TDataStd_ByteArray)::DownCast(theSource);
 
@@ -180,4 +191,11 @@ void XmlMDataStd_ByteArrayDriver::Paste(const Handle(TDF_Attribute)& theSource,
     // Transfer the string (array of chars) to XML.
     XmlObjMgt::SetStringValue (theTarget, (Standard_Character*)str, Standard_True);
   }
+  if(aByteArray->ID() != TDataStd_ByteArray::GetID()) {
+    //convert GUID
+    Standard_Character aGuidStr [Standard_GUID_SIZE_ALLOC];
+    Standard_PCharacter pGuidStr = aGuidStr;
+    aByteArray->ID().ToCString (pGuidStr);
+    theTarget.Element().setAttribute (::AttributeIDString(), aGuidStr);
+  }
 }
index 0c3599b..2e0c966 100644 (file)
@@ -24,7 +24,6 @@
 #include <XmlObjMgt.hxx>
 #include <XmlObjMgt_Document.hxx>
 #include <XmlObjMgt_Persistent.hxx>
-#include <XmlLDrivers.hxx>
 
 IMPLEMENT_STANDARD_RTTIEXT(XmlMDataStd_ExtStringArrayDriver,XmlMDF_ADriver)
 IMPLEMENT_DOMSTRING (FirstIndexString, "first")
@@ -32,6 +31,7 @@ IMPLEMENT_DOMSTRING (LastIndexString, "last")
 IMPLEMENT_DOMSTRING (ExtString,       "string")
 IMPLEMENT_DOMSTRING (IsDeltaOn,       "delta")
 IMPLEMENT_DOMSTRING (Separator,       "separator")
+IMPLEMENT_DOMSTRING (AttributeIDString, "extstrarrattguid")
 
 // Searches for a symbol within an array of strings.
 // Returns TRUE if the symbol is found.
@@ -73,9 +73,9 @@ Handle(TDF_Attribute) XmlMDataStd_ExtStringArrayDriver::NewEmpty() const
 //purpose  : persistent -> transient (retrieve)
 //=======================================================================
 Standard_Boolean XmlMDataStd_ExtStringArrayDriver::Paste
-                                        ( const XmlObjMgt_Persistent&  theSource,
-                                          const Handle(TDF_Attribute)& theTarget,
-                                          XmlObjMgt_RRelocationTable& ) const
+                                        (const XmlObjMgt_Persistent&  theSource,
+                                         const Handle(TDF_Attribute)& theTarget,
+                                         XmlObjMgt_RRelocationTable& ) const
 {
   Standard_Integer aFirstInd, aLastInd, ind;
   TCollection_ExtendedString aValue;
@@ -188,12 +188,12 @@ Standard_Boolean XmlMDataStd_ExtStringArrayDriver::Paste
     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;
+        TCollection_ExtendedString aMessageString =
+          TCollection_ExtendedString("Cannot retrieve the isDelta value"
+                                     " for IntegerArray attribute as \"")
+                                     + aDeltaValue + "\"";
+        WriteMessage (aMessageString);
+        return Standard_False;
       } 
     else
       aDelta = aDeltaValue != 0;
@@ -204,6 +204,16 @@ Standard_Boolean XmlMDataStd_ExtStringArrayDriver::Paste
 #endif
   aExtStringArray->SetDelta(aDelta);
 
+  // attribute id
+  Standard_GUID aGUID;
+  XmlObjMgt_DOMString aGUIDStr = anElement.getAttribute(::AttributeIDString());
+  if (aGUIDStr.Type() == XmlObjMgt_DOMString::LDOM_NULL)
+    aGUID = TDataStd_ExtStringArray::GetID(); //default case
+  else
+    aGUID = Standard_GUID(Standard_CString(aGUIDStr.GetString())); // user defined case
+
+  aExtStringArray->SetID(aGUID);
+
   return Standard_True;
 }
 
@@ -228,44 +238,39 @@ void XmlMDataStd_ExtStringArrayDriver::Paste (const Handle(TDF_Attribute)& theSo
 
   // Find a separator.
   Standard_Boolean found(Standard_True);
-  // Optimization of storage of string array elements.
-  // It is applied since the storage version 8 and newer.
+  // Preferrable symbols for the separator: - _ . : ^ ~
+  // Don't use a space as a separator: XML low-level parser sometimes "eats" it.
   Standard_Character c = '-';
-  if (XmlLDrivers::StorageVersion() > 7)
+  static Standard_Character aPreferable[] = "-_.:^~";
+  for (i = 0; found && aPreferable[i]; i++)
   {
-    // Preferrable symbols for the separator: - _ . : ^ ~
-    // Don't use a space as a separator: XML low-level parser sometimes "eats" it.
-    static Standard_Character aPreferable[] = "-_.:^~";
-    for (i = 0; found && aPreferable[i]; i++)
-    {
-      c = aPreferable[i];
-      found = Contains(aExtStringArray, TCollection_ExtendedString(c));
-    }
-    // If all prefferable symbols exist in the array, 
-    // try to use any other simple symbols.
-    if (found)
+    c = aPreferable[i];
+    found = Contains(aExtStringArray, TCollection_ExtendedString(c));
+  }
+  // If all prefferable symbols exist in the array, 
+  // try to use any other simple symbols.
+  if (found)
+  {
+    c = '!';
+    while (found && c < '~')
     {
-      c = '!';
-      while (found && c < '~')
-      {
-        found = Standard_False;
+      found = Standard_False;
 #ifdef _DEBUG
-        TCollection_AsciiString cseparator(c); // deb
+      TCollection_AsciiString cseparator(c); // deb
 #endif
-        TCollection_ExtendedString separator(c);
-        found = Contains(aExtStringArray, separator);
-        if (found)
+      TCollection_ExtendedString separator(c);
+      found = Contains(aExtStringArray, separator);
+      if (found)
+      {
+        c++;
+        // Skip forbidden symbols for XML.
+        while (c < '~' && (c == '&' || c == '<'))
         {
           c++;
-          // Skip forbidden symbols for XML.
-          while (c < '~' && (c == '&' || c == '<'))
-          {
-            c++;
-          }
         }
       }
     }
-  }// check doc version
+  }
   
   if (found)
   {
@@ -320,4 +325,11 @@ void XmlMDataStd_ExtStringArrayDriver::Paste (const Handle(TDF_Attribute)& theSo
       // Set UNICODE value.
       XmlObjMgt::SetExtendedString(theTarget, xstr);
   }
+  if(aExtStringArray->ID() != TDataStd_ExtStringArray::GetID()) {
+    //convert GUID
+    Standard_Character aGuidStr [Standard_GUID_SIZE_ALLOC];
+    Standard_PCharacter pGuidStr = aGuidStr;
+    aExtStringArray->ID().ToCString (pGuidStr);
+    theTarget.Element().setAttribute (::AttributeIDString(), aGuidStr);
+  }
 }
index c2351db..6eeb9b1 100644 (file)
@@ -29,6 +29,7 @@ IMPLEMENT_STANDARD_RTTIEXT(XmlMDataStd_ExtStringListDriver,XmlMDF_ADriver)
 IMPLEMENT_DOMSTRING (FirstIndexString, "first")
 IMPLEMENT_DOMSTRING (LastIndexString,  "last")
 IMPLEMENT_DOMSTRING (ExtString,        "string")
+IMPLEMENT_DOMSTRING (AttributeIDString, "extstrlistattguid")
 
 //=======================================================================
 //function : XmlMDataStd_ExtStringListDriver
@@ -54,8 +55,8 @@ Handle(TDF_Attribute) XmlMDataStd_ExtStringListDriver::NewEmpty() const
 //purpose  : persistent -> transient (retrieve)
 //=======================================================================
 Standard_Boolean XmlMDataStd_ExtStringListDriver::Paste(const XmlObjMgt_Persistent&  theSource,
-                                                       const Handle(TDF_Attribute)& theTarget,
-                                                       XmlObjMgt_RRelocationTable&  ) const
+                                                        const Handle(TDF_Attribute)& theTarget,
+                                                        XmlObjMgt_RRelocationTable&  ) const
 {
   Standard_Integer aFirstInd, aLastInd;
   const XmlObjMgt_Element& anElement = theSource;
@@ -85,30 +86,39 @@ Standard_Boolean XmlMDataStd_ExtStringListDriver::Paste(const XmlObjMgt_Persiste
     return Standard_False;
   }
 
-  if(aLastInd == 0) return Standard_True;
   const 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;
-  }
+  if(aLastInd > 0) {
+    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;
+    }
 
-  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;
   }
+  // attribute id
+  Standard_GUID aGUID;
+  XmlObjMgt_DOMString aGUIDStr = anElement.getAttribute(::AttributeIDString());
+  if (aGUIDStr.Type() == XmlObjMgt_DOMString::LDOM_NULL)
+    aGUID = TDataStd_ExtStringList::GetID(); //default case
+  else
+    aGUID = Standard_GUID(Standard_CString(aGUIDStr.GetString())); // user defined case
 
-  XmlObjMgt::GetExtendedString( *aCurElement, aValueStr );
-  anExtStringList->Append(aValueStr);
+  anExtStringList->SetID(aGUID);
 
   return Standard_True;
 }
@@ -118,8 +128,8 @@ Standard_Boolean XmlMDataStd_ExtStringListDriver::Paste(const XmlObjMgt_Persiste
 //purpose  : transient -> persistent (store)
 //=======================================================================
 void XmlMDataStd_ExtStringListDriver::Paste(const Handle(TDF_Attribute)& theSource,
-                                      XmlObjMgt_Persistent&        theTarget,
-                                      XmlObjMgt_SRelocationTable&  ) const
+                                            XmlObjMgt_Persistent&        theTarget,
+                                            XmlObjMgt_SRelocationTable&  ) const
 {
   const Handle(TDataStd_ExtStringList) anExtStringList = Handle(TDataStd_ExtStringList)::DownCast(theSource);
 
@@ -137,4 +147,12 @@ void XmlMDataStd_ExtStringListDriver::Paste(const Handle(TDF_Attribute)& theSour
     XmlObjMgt::SetExtendedString( aCurTarget, aValueStr );
     anElement.appendChild( aCurTarget );
   }
+
+  if(anExtStringList->ID() != TDataStd_ExtStringList::GetID()) {
+    //convert GUID
+    Standard_Character aGuidStr [Standard_GUID_SIZE_ALLOC];
+    Standard_PCharacter pGuidStr = aGuidStr;
+    anExtStringList->ID().ToCString (pGuidStr);
+    theTarget.Element().setAttribute (::AttributeIDString(), aGuidStr);
+  }
 }
index 09aa5f4..4920b69 100644 (file)
@@ -29,6 +29,8 @@ IMPLEMENT_STANDARD_RTTIEXT(XmlMDataStd_IntegerArrayDriver,XmlMDF_ADriver)
 IMPLEMENT_DOMSTRING (FirstIndexString, "first")
 IMPLEMENT_DOMSTRING (LastIndexString,  "last")
 IMPLEMENT_DOMSTRING (IsDeltaOn,        "delta")
+IMPLEMENT_DOMSTRING (AttributeIDString, "intarrattguid")
+
 //=======================================================================
 //function : XmlMDataStd_IntegerArrayDriver
 //purpose  : Constructor
@@ -123,12 +125,12 @@ Standard_Boolean XmlMDataStd_IntegerArrayDriver::Paste
     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;
+        TCollection_ExtendedString aMessageString =
+          TCollection_ExtendedString("Cannot retrieve the isDelta value"
+                                     " for IntegerArray attribute as \"")
+                                     + aDeltaValue + "\"";
+        WriteMessage (aMessageString);
+        return Standard_False;
       } 
     else
       aDelta = aDeltaValue != 0;
@@ -138,7 +140,17 @@ Standard_Boolean XmlMDataStd_IntegerArrayDriver::Paste
     cout << "Current DocVersion field is not initialized. "  <<endl;
 #endif
   anIntArray->SetDelta(aDelta);
-  
+
+  // attribute id
+  Standard_GUID aGUID;
+  XmlObjMgt_DOMString aGUIDStr = anElement.getAttribute(::AttributeIDString());
+  if (aGUIDStr.Type() == XmlObjMgt_DOMString::LDOM_NULL)
+    aGUID = TDataStd_IntegerArray::GetID(); //default case
+  else
+    aGUID = Standard_GUID(Standard_CString(aGUIDStr.GetString())); // user defined case
+
+  anIntArray->SetID(aGUID);
+
   return Standard_True;
 }
 
@@ -184,4 +196,11 @@ void XmlMDataStd_IntegerArrayDriver::Paste
     str[iChar - 1] = '\0';
     XmlObjMgt::SetStringValue (theTarget, (Standard_Character*)str, Standard_True);
   }
+  if(anIntArray->ID() != TDataStd_IntegerArray::GetID()) {
+    //convert GUID
+    Standard_Character aGuidStr [Standard_GUID_SIZE_ALLOC];
+    Standard_PCharacter pGuidStr = aGuidStr;
+    anIntArray->ID().ToCString (pGuidStr);
+    theTarget.Element().setAttribute (::AttributeIDString(), aGuidStr);
+  }
 }
index c777e14..e71f856 100644 (file)
 IMPLEMENT_STANDARD_RTTIEXT(XmlMDataStd_IntegerListDriver,XmlMDF_ADriver)
 IMPLEMENT_DOMSTRING (FirstIndexString, "first")
 IMPLEMENT_DOMSTRING (LastIndexString,  "last")
+IMPLEMENT_DOMSTRING (AttributeIDString, "intlistattguid")
 
 //=======================================================================
 //function : XmlMDataStd_IntegerListDriver
 //purpose  : Constructor
 //=======================================================================
 XmlMDataStd_IntegerListDriver::XmlMDataStd_IntegerListDriver(const Handle(CDM_MessageDriver)& theMsgDriver)
-     : XmlMDF_ADriver (theMsgDriver, NULL)
+: XmlMDF_ADriver (theMsgDriver, NULL)
 {
 
 }
@@ -52,8 +53,8 @@ Handle(TDF_Attribute) XmlMDataStd_IntegerListDriver::NewEmpty() const
 //purpose  : persistent -> transient (retrieve)
 //=======================================================================
 Standard_Boolean XmlMDataStd_IntegerListDriver::Paste(const XmlObjMgt_Persistent&  theSource,
-                                                     const Handle(TDF_Attribute)& theTarget,
-                                                     XmlObjMgt_RRelocationTable&  ) const
+                                                      const Handle(TDF_Attribute)& theTarget,
+                                                      XmlObjMgt_RRelocationTable&  ) const
 {
   Standard_Integer aFirstInd, aLastInd, aValue, ind;
   const XmlObjMgt_Element& anElement = theSource;
@@ -115,7 +116,17 @@ Standard_Boolean XmlMDataStd_IntegerListDriver::Paste(const XmlObjMgt_Persistent
       anIntList->Append(aValue);
     }
   }
-  
+
+  // attribute id
+  Standard_GUID aGUID;
+  XmlObjMgt_DOMString aGUIDStr = anElement.getAttribute(::AttributeIDString());
+  if (aGUIDStr.Type() == XmlObjMgt_DOMString::LDOM_NULL)
+    aGUID = TDataStd_IntegerList::GetID(); //default case
+  else
+    aGUID = Standard_GUID(Standard_CString(aGUIDStr.GetString())); // user defined case
+
+  anIntList->SetID(aGUID);
+
   return Standard_True;
 }
 
@@ -124,8 +135,8 @@ Standard_Boolean XmlMDataStd_IntegerListDriver::Paste(const XmlObjMgt_Persistent
 //purpose  : transient -> persistent (store)
 //=======================================================================
 void XmlMDataStd_IntegerListDriver::Paste(const Handle(TDF_Attribute)& theSource,
-                                         XmlObjMgt_Persistent&        theTarget,
-                                         XmlObjMgt_SRelocationTable&  ) const
+                                          XmlObjMgt_Persistent&        theTarget,
+                                          XmlObjMgt_SRelocationTable&  ) const
 {
   const Handle(TDataStd_IntegerList) anIntList = Handle(TDataStd_IntegerList)::DownCast(theSource);
 
@@ -148,4 +159,12 @@ void XmlMDataStd_IntegerListDriver::Paste(const Handle(TDF_Attribute)& theSource
   }
   // No occurrence of '&', '<' and other irregular XML characters
   XmlObjMgt::SetStringValue (theTarget, (Standard_Character*)str, Standard_True);
+
+  if(anIntList->ID() != TDataStd_IntegerList::GetID()) {
+    //convert GUID
+    Standard_Character aGuidStr [Standard_GUID_SIZE_ALLOC];
+    Standard_PCharacter pGuidStr = aGuidStr;
+    anIntList->ID().ToCString (pGuidStr);
+    theTarget.Element().setAttribute (::AttributeIDString(), aGuidStr);
+  }
 }
index 8efe032..8fca3db 100644 (file)
@@ -33,7 +33,7 @@ IMPLEMENT_STANDARD_RTTIEXT(XmlMDataStd_RealArrayDriver,XmlMDF_ADriver)
 IMPLEMENT_DOMSTRING (FirstIndexString, "first")
 IMPLEMENT_DOMSTRING (LastIndexString, "last")
 IMPLEMENT_DOMSTRING (IsDeltaOn,       "delta")
-
+IMPLEMENT_DOMSTRING (AttributeIDString, "realarrattguid")
 //=======================================================================
 //function : XmlMDataStd_RealArrayDriver
 //purpose  : Constructor
@@ -129,12 +129,12 @@ Standard_Boolean XmlMDataStd_RealArrayDriver::Paste
     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;
+        TCollection_ExtendedString aMessageString =
+          TCollection_ExtendedString("Cannot retrieve the isDelta value"
+                                     " for RealArray attribute as \"")
+                                     + aDeltaValue + "\"";
+        WriteMessage (aMessageString);
+        return Standard_False;
       } 
     else
       aDelta = aDeltaValue != 0;
@@ -145,6 +145,15 @@ Standard_Boolean XmlMDataStd_RealArrayDriver::Paste
 #endif
   aRealArray->SetDelta(aDelta);
 
+  // attribute id
+  Standard_GUID aGUID;
+  XmlObjMgt_DOMString aGUIDStr = anElement.getAttribute(::AttributeIDString());
+  if (aGUIDStr.Type() == XmlObjMgt_DOMString::LDOM_NULL)
+    aGUID = TDataStd_RealArray::GetID(); //default case
+  else
+    aGUID = Standard_GUID(Standard_CString(aGUIDStr.GetString())); // user defined case
+
+  aRealArray->SetID(aGUID);
   return Standard_True;
 }
 
@@ -209,4 +218,11 @@ void XmlMDataStd_RealArrayDriver::Paste (const Handle(TDF_Attribute)& theSource,
     str[iChar - 1] = '\0';
     XmlObjMgt::SetStringValue (theTarget, (Standard_Character*)str, Standard_True);
   }
+  if(aRealArray->ID() != TDataStd_RealArray::GetID()) {
+    //convert GUID
+    Standard_Character aGuidStr [Standard_GUID_SIZE_ALLOC];
+    Standard_PCharacter pGuidStr = aGuidStr;
+    aRealArray->ID().ToCString (pGuidStr);
+    theTarget.Element().setAttribute (::AttributeIDString(), aGuidStr);
+  }
 }
index 0f59a3d..4c04da7 100644 (file)
@@ -27,7 +27,7 @@
 IMPLEMENT_STANDARD_RTTIEXT(XmlMDataStd_RealListDriver,XmlMDF_ADriver)
 IMPLEMENT_DOMSTRING (FirstIndexString, "first")
 IMPLEMENT_DOMSTRING (LastIndexString,  "last")
-
+IMPLEMENT_DOMSTRING (AttributeIDString, "reallistattguid")
 //=======================================================================
 //function : XmlMDataStd_RealListDriver
 //purpose  : Constructor
@@ -52,8 +52,8 @@ Handle(TDF_Attribute) XmlMDataStd_RealListDriver::NewEmpty() const
 //purpose  : persistent -> transient (retrieve)
 //=======================================================================
 Standard_Boolean XmlMDataStd_RealListDriver::Paste(const XmlObjMgt_Persistent&  theSource,
-                                                  const Handle(TDF_Attribute)& theTarget,
-                                                  XmlObjMgt_RRelocationTable&  ) const
+                                                   const Handle(TDF_Attribute)& theTarget,
+                                                   XmlObjMgt_RRelocationTable&  ) const
 {
   Standard_Real aValue;
   Standard_Integer aFirstInd, aLastInd, ind;
@@ -123,6 +123,16 @@ Standard_Boolean XmlMDataStd_RealListDriver::Paste(const XmlObjMgt_Persistent&
     }
   }
 
+  // attribute id
+  Standard_GUID aGUID;
+  XmlObjMgt_DOMString aGUIDStr = anElement.getAttribute(::AttributeIDString());
+  if (aGUIDStr.Type() == XmlObjMgt_DOMString::LDOM_NULL)
+    aGUID = TDataStd_RealList::GetID(); //default case
+  else
+    aGUID = Standard_GUID(Standard_CString(aGUIDStr.GetString())); // user defined case
+
+  aRealList->SetID(aGUID);
+
   return Standard_True;
 }
 
@@ -131,8 +141,8 @@ Standard_Boolean XmlMDataStd_RealListDriver::Paste(const XmlObjMgt_Persistent&
 //purpose  : transient -> persistent (store)
 //=======================================================================
 void XmlMDataStd_RealListDriver::Paste(const Handle(TDF_Attribute)& theSource,
-                                      XmlObjMgt_Persistent&        theTarget,
-                                      XmlObjMgt_SRelocationTable&  ) const
+                                       XmlObjMgt_Persistent&        theTarget,
+                                       XmlObjMgt_SRelocationTable&  ) const
 {
   const Handle(TDataStd_RealList) aRealList = Handle(TDataStd_RealList)::DownCast(theSource);
 
@@ -153,4 +163,12 @@ void XmlMDataStd_RealListDriver::Paste(const Handle(TDF_Attribute)& theSource,
     }
   }
   XmlObjMgt::SetStringValue (theTarget, (Standard_Character*)str, Standard_True);
+
+  if(aRealList->ID() != TDataStd_RealList::GetID()) {
+    //convert GUID
+    Standard_Character aGuidStr [Standard_GUID_SIZE_ALLOC];
+    Standard_PCharacter pGuidStr = aGuidStr;
+    aRealList->ID().ToCString (pGuidStr);
+    theTarget.Element().setAttribute (::AttributeIDString(), aGuidStr);
+  }
 }
index efaa14d..3593e44 100644 (file)
@@ -30,7 +30,7 @@ IMPLEMENT_STANDARD_RTTIEXT(XmlMDataStd_ReferenceArrayDriver,XmlMDF_ADriver)
 IMPLEMENT_DOMSTRING (FirstIndexString, "first")
 IMPLEMENT_DOMSTRING (LastIndexString,  "last")
 IMPLEMENT_DOMSTRING (ExtString,        "string")
-
+IMPLEMENT_DOMSTRING (AttributeIDString, "refarrattguid")
 //=======================================================================
 //function : XmlMDataStd_ReferenceArrayDriver
 //purpose  : Constructor
@@ -55,8 +55,8 @@ Handle(TDF_Attribute) XmlMDataStd_ReferenceArrayDriver::NewEmpty() const
 //purpose  : persistent -> transient (retrieve)
 //=======================================================================
 Standard_Boolean XmlMDataStd_ReferenceArrayDriver::Paste(const XmlObjMgt_Persistent&  theSource,
-                                                        const Handle(TDF_Attribute)& theTarget,
-                                                        XmlObjMgt_RRelocationTable&  ) const
+                                                         const Handle(TDF_Attribute)& theTarget,
+                                                         XmlObjMgt_RRelocationTable&  ) const
 {
   Standard_Integer aFirstInd, aLastInd;
   const XmlObjMgt_Element& anElement = theSource;
@@ -113,8 +113,8 @@ Standard_Boolean XmlMDataStd_ReferenceArrayDriver::Paste(const XmlObjMgt_Persist
     if (XmlObjMgt::GetTagEntryString (aValueStr, anEntry) == Standard_False)
     {
       TCollection_ExtendedString aMessage =
-       TCollection_ExtendedString ("Cannot retrieve reference from \"")
-         + aValueStr + '\"';
+        TCollection_ExtendedString ("Cannot retrieve reference from \"")
+        + aValueStr + '\"';
       WriteMessage (aMessage);
       return Standard_False;
     }
@@ -141,7 +141,7 @@ Standard_Boolean XmlMDataStd_ReferenceArrayDriver::Paste(const XmlObjMgt_Persist
   {
     TCollection_ExtendedString aMessage =
       TCollection_ExtendedString ("Cannot retrieve reference from \"")
-       + aValueStr + '\"';
+      + aValueStr + '\"';
     WriteMessage (aMessage);
     return Standard_False;
   }
@@ -153,6 +153,16 @@ Standard_Boolean XmlMDataStd_ReferenceArrayDriver::Paste(const XmlObjMgt_Persist
   }
   aReferenceArray->SetValue(i, tLab);
 
+  // attribute id
+  Standard_GUID aGUID;
+  XmlObjMgt_DOMString aGUIDStr = anElement.getAttribute(::AttributeIDString());
+  if (aGUIDStr.Type() == XmlObjMgt_DOMString::LDOM_NULL)
+    aGUID = TDataStd_ReferenceArray::GetID(); //default case
+  else
+    aGUID = Standard_GUID(Standard_CString(aGUIDStr.GetString())); // user defined case
+
+  aReferenceArray->SetID(aGUID);
+
   return Standard_True;
 }
 
@@ -161,8 +171,8 @@ Standard_Boolean XmlMDataStd_ReferenceArrayDriver::Paste(const XmlObjMgt_Persist
 //purpose  : transient -> persistent (store)
 //=======================================================================
 void XmlMDataStd_ReferenceArrayDriver::Paste(const Handle(TDF_Attribute)& theSource,
-                                            XmlObjMgt_Persistent&        theTarget,
-                                            XmlObjMgt_SRelocationTable&  ) const
+                                             XmlObjMgt_Persistent&        theTarget,
+                                             XmlObjMgt_SRelocationTable&  ) const
 {
   Handle(TDataStd_ReferenceArray) aReferenceArray = Handle(TDataStd_ReferenceArray)::DownCast(theSource);
   TDF_Label L = aReferenceArray->Label();
@@ -195,4 +205,11 @@ void XmlMDataStd_ReferenceArrayDriver::Paste(const Handle(TDF_Attribute)& theSou
       anElement.appendChild( aCurTarget );
     }
   }
+  if(aReferenceArray->ID() != TDataStd_ReferenceArray::GetID()) {
+    //convert GUID
+    Standard_Character aGuidStr [Standard_GUID_SIZE_ALLOC];
+    Standard_PCharacter pGuidStr = aGuidStr;
+    aReferenceArray->ID().ToCString (pGuidStr);
+    theTarget.Element().setAttribute (::AttributeIDString(), aGuidStr);
+  }
 }
index 8c9e5c0..2eabdec 100644 (file)
@@ -31,7 +31,7 @@ IMPLEMENT_STANDARD_RTTIEXT(XmlMDataStd_ReferenceListDriver,XmlMDF_ADriver)
 IMPLEMENT_DOMSTRING (FirstIndexString, "first")
 IMPLEMENT_DOMSTRING (LastIndexString,  "last")
 IMPLEMENT_DOMSTRING (ExtString,        "string")
-
+IMPLEMENT_DOMSTRING (AttributeIDString, "reflistattguid")
 //=======================================================================
 //function : XmlMDataStd_ReferenceListDriver
 //purpose  : Constructor
@@ -56,8 +56,8 @@ Handle(TDF_Attribute) XmlMDataStd_ReferenceListDriver::NewEmpty() const
 //purpose  : persistent -> transient (retrieve)
 //=======================================================================
 Standard_Boolean XmlMDataStd_ReferenceListDriver::Paste(const XmlObjMgt_Persistent&  theSource,
-                                                       const Handle(TDF_Attribute)& theTarget,
-                                                       XmlObjMgt_RRelocationTable&  ) const
+                                                        const Handle(TDF_Attribute)& theTarget,
+                                                        XmlObjMgt_RRelocationTable&  ) const
 {
   Standard_Integer aFirstInd, aLastInd;
   const XmlObjMgt_Element& anElement = theSource;
@@ -87,47 +87,45 @@ Standard_Boolean XmlMDataStd_ReferenceListDriver::Paste(const XmlObjMgt_Persiste
     return Standard_False;
   }
 
-  if(aLastInd == 0) return Standard_True;
   const 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)
+  if(aLastInd > 0) {
+    if (!anElement.hasChildNodes())
     {
-      TCollection_ExtendedString aMessage =
-      TCollection_ExtendedString ("Cannot retrieve reference from \"")
-      + aValueStr + '\"';
-      WriteMessage (aMessage);
+      TCollection_ExtendedString aMessageString = 
+        TCollection_ExtendedString("Cannot retrieve a list of reference");
+      WriteMessage (aMessageString);
       return Standard_False;
     }
-    // Find label by entry
-    TDF_Label tLab; // Null label.
-    if (anEntry.Length() > 0)
+
+    LDOM_Node aCurNode = anElement.getFirstChild();
+    LDOM_Element* aCurElement = (LDOM_Element*)&aCurNode;
+    XmlObjMgt_DOMString aValueStr;
+    while (*aCurElement != anElement.getLastChild())
     {
-      TDF_Tool::Label(aReferenceList->Label().Data(), anEntry, tLab, Standard_True);
+      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 re