0028564: Support of applications using old persistence (ShapeSchema)
authorsnn <snn@opencascade.com>
Tue, 28 Mar 2017 14:13:04 +0000 (17:13 +0300)
committerbugmaster <bugmaster@opencascade.com>
Fri, 28 Apr 2017 09:44:50 +0000 (12:44 +0300)
1. Bug fix in reading old persistent data using FSD_File storage driver
2. Persistence compatible with legacy format was restored for shapes
   a. Implemented a storage read / write wrapper for legacy persistence
   b. Added DRAW commands to read / write files in legacy format
   c. Added test cases for reading / writing operations with checking number of sub-shapes and physical properties
   d. Updated related sections of the development guide

124 files changed:
adm/UDLIST
dox/dev_guides/upgrade/upgrade.md
src/DDocStd/DDocStd.cxx
src/DDocStd/DDocStd.hxx
src/DDocStd/DDocStd_ShapeSchemaCommands.cxx [new file with mode: 0644]
src/DDocStd/FILES
src/ShapePersistent/FILES
src/ShapePersistent/ShapePersistent_BRep.cxx
src/ShapePersistent/ShapePersistent_BRep.hxx
src/ShapePersistent/ShapePersistent_Geom.cxx
src/ShapePersistent/ShapePersistent_Geom.hxx
src/ShapePersistent/ShapePersistent_Geom2d.cxx [new file with mode: 0644]
src/ShapePersistent/ShapePersistent_Geom2d.hxx
src/ShapePersistent/ShapePersistent_Geom2d_Curve.cxx
src/ShapePersistent/ShapePersistent_Geom2d_Curve.hxx
src/ShapePersistent/ShapePersistent_Geom_Curve.cxx
src/ShapePersistent/ShapePersistent_Geom_Curve.hxx
src/ShapePersistent/ShapePersistent_Geom_Surface.cxx
src/ShapePersistent/ShapePersistent_Geom_Surface.hxx
src/ShapePersistent/ShapePersistent_HArray1.hxx
src/ShapePersistent/ShapePersistent_HSequence.cxx
src/ShapePersistent/ShapePersistent_HSequence.hxx
src/ShapePersistent/ShapePersistent_Poly.cxx
src/ShapePersistent/ShapePersistent_Poly.hxx
src/ShapePersistent/ShapePersistent_TopoDS.cxx
src/ShapePersistent/ShapePersistent_TopoDS.hxx
src/ShapePersistent/ShapePersistent_TriangleMode.hxx [new file with mode: 0644]
src/StdLDrivers/StdLDrivers_DocumentRetrievalDriver.cxx
src/StdLPersistent/StdLPersistent_Data.cxx
src/StdLPersistent/StdLPersistent_Data.hxx
src/StdLPersistent/StdLPersistent_Dependency.hxx
src/StdLPersistent/StdLPersistent_Document.cxx
src/StdLPersistent/StdLPersistent_Document.hxx
src/StdLPersistent/StdLPersistent_Function.hxx
src/StdLPersistent/StdLPersistent_HArray1.cxx
src/StdLPersistent/StdLPersistent_HArray1.hxx
src/StdLPersistent/StdLPersistent_HArray2.cxx
src/StdLPersistent/StdLPersistent_HArray2.hxx
src/StdLPersistent/StdLPersistent_HString.cxx
src/StdLPersistent/StdLPersistent_HString.hxx
src/StdLPersistent/StdLPersistent_NamedData.hxx
src/StdLPersistent/StdLPersistent_Real.hxx
src/StdLPersistent/StdLPersistent_TreeNode.cxx
src/StdLPersistent/StdLPersistent_TreeNode.hxx
src/StdLPersistent/StdLPersistent_Value.hxx
src/StdLPersistent/StdLPersistent_Variable.hxx
src/StdLPersistent/StdLPersistent_Void.hxx
src/StdLPersistent/StdLPersistent_XLink.hxx
src/StdObjMgt/FILES
src/StdObjMgt/StdObjMgt_Attribute.hxx
src/StdObjMgt/StdObjMgt_Persistent.cxx
src/StdObjMgt/StdObjMgt_Persistent.hxx
src/StdObjMgt/StdObjMgt_ReadData.hxx
src/StdObjMgt/StdObjMgt_SharedObject.hxx
src/StdObjMgt/StdObjMgt_TransientPersistentMap.hxx [new file with mode: 0644]
src/StdObjMgt/StdObjMgt_WriteData.cxx [new file with mode: 0644]
src/StdObjMgt/StdObjMgt_WriteData.hxx [new file with mode: 0644]
src/StdObject/StdObject_Location.cxx
src/StdObject/StdObject_Location.hxx
src/StdObject/StdObject_Shape.cxx
src/StdObject/StdObject_Shape.hxx
src/StdObject/StdObject_gp_Axes.hxx
src/StdObject/StdObject_gp_Curves.hxx
src/StdObject/StdObject_gp_Surfaces.hxx
src/StdObject/StdObject_gp_Trsfs.hxx
src/StdObject/StdObject_gp_Vectors.hxx
src/StdPersistent/StdPersistent.hxx
src/StdPersistent/StdPersistent_DataXtd.hxx
src/StdPersistent/StdPersistent_DataXtd_Constraint.hxx
src/StdPersistent/StdPersistent_DataXtd_PatternStd.hxx
src/StdPersistent/StdPersistent_Naming.cxx
src/StdPersistent/StdPersistent_Naming.hxx
src/StdPersistent/StdPersistent_PPrsStd.hxx
src/StdPersistent/StdPersistent_TopLoc.cxx
src/StdPersistent/StdPersistent_TopLoc.hxx
src/StdPersistent/StdPersistent_TopoDS.hxx
src/StdStorage/FILES [new file with mode: 0644]
src/StdStorage/StdStorage.cxx [new file with mode: 0644]
src/StdStorage/StdStorage.hxx [new file with mode: 0644]
src/StdStorage/StdStorage_BacketOfPersistent.cxx [new file with mode: 0644]
src/StdStorage/StdStorage_BacketOfPersistent.hxx [new file with mode: 0644]
src/StdStorage/StdStorage_Data.cxx [moved from src/StdObjMgt/StdObjMgt_MapOfInstantiators.cxx with 58% similarity]
src/StdStorage/StdStorage_Data.hxx [new file with mode: 0644]
src/StdStorage/StdStorage_HSequenceOfRoots.hxx [new file with mode: 0644]
src/StdStorage/StdStorage_HeaderData.cxx [new file with mode: 0644]
src/StdStorage/StdStorage_HeaderData.hxx [new file with mode: 0644]
src/StdStorage/StdStorage_MapOfRoots.hxx [new file with mode: 0644]
src/StdStorage/StdStorage_MapOfTypes.hxx [new file with mode: 0644]
src/StdStorage/StdStorage_Root.cxx [new file with mode: 0644]
src/StdStorage/StdStorage_Root.hxx [new file with mode: 0644]
src/StdStorage/StdStorage_RootData.cxx [new file with mode: 0644]
src/StdStorage/StdStorage_RootData.hxx [new file with mode: 0644]
src/StdStorage/StdStorage_SequenceOfRoots.hxx [new file with mode: 0644]
src/StdStorage/StdStorage_TypeData.cxx [new file with mode: 0644]
src/StdStorage/StdStorage_TypeData.hxx [new file with mode: 0644]
src/TKStd/PACKAGES
tests/persist/end [new file with mode: 0644]
tests/persist/fsd/A1 [new file with mode: 0644]
tests/persist/fsd/A2 [new file with mode: 0644]
tests/persist/fsd/A3 [new file with mode: 0644]
tests/persist/fsd/A4 [new file with mode: 0644]
tests/persist/fsd/A5 [new file with mode: 0644]
tests/persist/fsd/A6 [new file with mode: 0644]
tests/persist/fsd/A7 [new file with mode: 0644]
tests/persist/fsd/A8 [new file with mode: 0644]
tests/persist/fsd/C1 [new file with mode: 0644]
tests/persist/fsd/C2 [new file with mode: 0644]
tests/persist/fsd/S1 [new file with mode: 0644]
tests/persist/fsd/S10 [new file with mode: 0644]
tests/persist/fsd/S11 [new file with mode: 0644]
tests/persist/fsd/S12 [new file with mode: 0644]
tests/persist/fsd/S13 [new file with mode: 0644]
tests/persist/fsd/S14 [new file with mode: 0644]
tests/persist/fsd/S15 [new file with mode: 0644]
tests/persist/fsd/S2 [new file with mode: 0644]
tests/persist/fsd/S3 [new file with mode: 0644]
tests/persist/fsd/S4 [new file with mode: 0644]
tests/persist/fsd/S5 [new file with mode: 0644]
tests/persist/fsd/S6 [new file with mode: 0644]
tests/persist/fsd/S7 [new file with mode: 0644]
tests/persist/fsd/S8 [new file with mode: 0644]
tests/persist/fsd/S9 [new file with mode: 0644]
tests/persist/fsd/begin [new file with mode: 0644]
tests/persist/grids.list [new file with mode: 0644]

index 7d23aee..279ecd3 100644 (file)
@@ -247,6 +247,7 @@ n StdObjMgt
 n StdDrivers
 n StdObject
 n StdPersistent
+n StdStorage
 n ShapePersistent
 n TDF
 n TDataStd
index ec36abe..3b2aa27 100644 (file)
@@ -333,6 +333,8 @@ The applications that used these data persistence tools need to be updated to us
 
 The existing data files in standard formats can be converted using OCCT 6.9.1 or a previous version, as follows.
 
+@note Reading / writing custom files capability from OCCT 6.9.1 is restored in OCCT 7.2.0. See details in @ref upgrade_720_persistence section.
+
 #### CSFDB files
 
 Files in *CSFDB* format (usually with extension .csfdb) contain OCCT shape data that can be converted to BRep format. 
@@ -1248,3 +1250,101 @@ The following Grid management methods within class V3d_Viewer do not implicitly
   - *IntTools_Curve::Tolerance()* - returns the valid tolerance for the curve;
   - *IntTools_Curve::TangentialTolerance()* - returns the tangential tolerance, which reflects the size of the common between faces.
 * 2d tolerance (*IntTools_FaceFace::TolReached2d()*) has been completely removed from the algorithm as unused.
+@subsection upgrade_720_persistence Restore OCCT 6.9.1 persistence
+  
+Capability of reading / writing files in old format using *Storage_ShapeSchema* functionality from OCCT 6.9.1 has been restored in OCCT 7.2.0. 
+
+One can use this functionality in two ways:
+- invoke DRAW Test Harness commands fsdread / fsdwrite for shapes
+- call *StdStorage* class Read / Write functions in custom code
+
+Code example below demonstrates how to read shapes from a storage driver using *StdStorage* class. 
+
+~~~~
+// aDriver should be created and opened for reading
+Handle(StdStorage_Data) aData;
+
+// Read data from the driver
+// StdStorage::Read creates aData instance automatically if it is null
+Storage_Error anError = StdStorage::Read(*aDriver, aData);
+if (anError != Storage_VSOk)
+{
+  // Error processing
+}
+
+// Get root objects
+Handle(StdStorage_RootData) aRootData = aData->RootData();
+Handle(StdStorage_HSequenceOfRoots) aRoots = aRootData->Roots();
+if (!aRoots.IsNull())
+{
+  // Iterator over the sequence of root objects
+  for (StdStorage_HSequenceOfRoots::Iterator anIt(*aRoots); anIt.More(); anIt.Next())
+  {
+    Handle(StdStorage_Root)& aRoot = anIt.ChangeValue();
+       // Get a persistent root's object
+    Handle(StdObjMgt_Persistent) aPObject = aRoot->Object();
+    if (!aPObject.IsNull())
+    {
+      Handle(ShapePersistent_TopoDS::HShape) aHShape = Handle(ShapePersistent_TopoDS::HShape)::DownCast(aPObject);
+      if (aHShape) // Downcast to an expected type to import transient data
+      {
+        TopoDS_Shape aShape = aHShape->Import();
+        shapes.Append(aShape);
+      }
+    }
+  }
+}
+~~~~
+
+The following code demonstrates how to write shapes in OCCT 7.2.0 using *StdStorage* class.
+
+~~~~
+// Create a file driver
+NCollection_Handle<Storage_BaseDriver> aFileDriver(new FSD_File());
+
+// Try to open the file driver for writing
+try
+{
+  OCC_CATCH_SIGNALS
+  PCDM_ReadWriter::Open(*aFileDriver, TCollection_ExtendedString(CStringA(filename).GetBuffer()), Storage_VSWrite);
+}
+catch (Standard_Failure& e)
+{
+  // Error processing
+}
+
+// Create a storage data instance
+Handle(StdStorage_Data) aData = new StdStorage_Data;
+// Set an axiliary application name (optional)
+aData->HeaderData()->SetApplicationName(TCollection_ExtendedString("Application"));
+
+// Provide a map to track sharing
+StdObjMgt_TransientPersistentMap aMap;
+// Iterator over a collection of shapes
+for (Standard_Integer i = 1; i <= shapes.Length(); ++i)
+{
+  TopoDS_Shape aShape = shapes.Value(i);
+  // Translate a shape to a persistent object
+  Handle(ShapePersistent_TopoDS::HShape) aPShape =
+    ShapePersistent_TopoDS::Translate(aShape, aMap, ShapePersistent_WithTriangle);
+  if (aPShape.IsNull())
+  {
+    // Error processing
+  }
+
+  // Construct a root name
+  TCollection_AsciiString aName = "Shape_";
+  aName += i;
+
+  // Add a root to storage data
+  Handle(StdStorage_Root) aRoot = new StdStorage_Root(aName, aPShape);
+  aData->RootData()->AddRoot(aRoot);
+}
+
+// Write storage data to the driver
+Storage_Error anError = StdStorage::Write(*aFileDriver, aData);
+if (anError != Storage_VSOk)
+{
+  // Error processing
+}
+~~~~
index a71b307..7153c74 100644 (file)
@@ -154,4 +154,5 @@ void DDocStd::AllCommands(Draw_Interpretor& theCommands)
   DDocStd::DocumentCommands(theCommands);
   DDocStd::ToolsCommands(theCommands);
   DDocStd::MTMCommands(theCommands);
+  DDocStd::ShapeSchemaCommands(theCommands);
 }
index c239165..f560384 100644 (file)
@@ -83,7 +83,8 @@ public:
   //! Create, Add, Remove, Open, Commit, Undo, Redo, SetNestedMode
   Standard_EXPORT static void MTMCommands (Draw_Interpretor& theCommands);
 
-
+  //! ShapeSchema_Read
+  Standard_EXPORT static void ShapeSchemaCommands(Draw_Interpretor& theCommands);
 
 
 protected:
diff --git a/src/DDocStd/DDocStd_ShapeSchemaCommands.cxx b/src/DDocStd/DDocStd_ShapeSchemaCommands.cxx
new file mode 100644 (file)
index 0000000..649f82f
--- /dev/null
@@ -0,0 +1,221 @@
+
+#include <DDocStd.hxx>
+#include <DBRep.hxx>
+#include <FSD_File.hxx>
+#include <FSD_CmpFile.hxx>
+#include <FSD_BinaryFile.hxx>
+#include <BRep_Builder.hxx>
+#include <NCollection_Handle.hxx>
+#include <TCollection_AsciiString.hxx>
+#include <TopTools_SequenceOfShape.hxx>
+#include <Storage_BaseDriver.hxx>
+#include <StdStorage.hxx>
+#include <StdStorage_Data.hxx>
+#include <StdStorage_HeaderData.hxx>
+#include <StdStorage_RootData.hxx>
+#include <StdStorage_TypeData.hxx>
+#include <ShapePersistent_TopoDS.hxx>
+
+//=======================================================================
+//function : DDocStd_ShapeSchema_Write 
+//=======================================================================
+
+static Standard_Integer DDocStd_fsdwrite(Draw_Interpretor& theDI,
+                                         Standard_Integer theArgNb,
+                                         const char** theArgs)
+{
+  if (theArgNb < 3)
+  {
+    theDI << "Usage : fsdwrite shapes filename [gen | cmp | bin]\n";
+    theDI << "        Arguments:\n";
+    theDI << "        shapes   : list os shape names\n";
+    theDI << "        filename : output file name\n";
+    theDI << "        Storage driver:\n";
+    theDI << "          gen : FSD_File driver (default)\n";
+    theDI << "          cmp : FSD_CmpFile driver\n";
+    theDI << "          bin : FSD_BinaryFile driver\n";
+    return 1;
+  }
+
+  NCollection_Handle<Storage_BaseDriver> aFileDriver(new FSD_File);
+
+  Standard_Boolean hasStorageDriver = Standard_False;
+  Standard_Integer iArgN = theArgNb - 1;
+
+  if (strncmp(theArgs[iArgN], "gen", 3) == 0)
+  {
+    aFileDriver = new FSD_File;
+    hasStorageDriver = Standard_True;
+  }
+  else if (strncmp(theArgs[iArgN], "cmp", 3) == 0)
+  {
+    aFileDriver = new FSD_CmpFile;
+    hasStorageDriver = Standard_True;
+  }
+  else if (strncmp(theArgs[iArgN], "bin", 3) == 0)
+  {
+    aFileDriver = new FSD_BinaryFile;
+    hasStorageDriver = Standard_True;
+  }
+
+  if (hasStorageDriver) --iArgN;
+
+  Storage_Error aStatus = aFileDriver->Open(theArgs[iArgN], Storage_VSWrite);
+  if (aStatus != Storage_VSOk) {
+    theDI << "Error : couldn't open file '" << "' for writing (" << aStatus << ")\n";
+    return 1;
+  }
+
+  TopTools_SequenceOfShape aShapes;
+  NCollection_DataMap<TCollection_AsciiString, Standard_Integer> aShapeNames;
+  for (Standard_Integer i = 1; i < iArgN; ++i)
+  {
+    TopoDS_Shape aShape = DBRep::Get(theArgs[i]);
+    if (aShape.IsNull())
+    {
+      theDI << "Error : null shape " << theArgs[i] << "\n";
+      return 1;
+    }
+    aShapes.Append(aShape);
+    if (aShapeNames.IsBound(theArgs[i]))
+      aShapeNames.ChangeFind(theArgs[i]) += 1;
+    else
+      aShapeNames.Bind(theArgs[i], 1);
+  }
+
+  Handle(StdStorage_Data) aData = new StdStorage_Data;
+
+  aData->HeaderData()->SetApplicationName(TCollection_ExtendedString("DDocStd_ShapeSchema_Write"));
+
+  StdObjMgt_TransientPersistentMap aMap;
+  for (Standard_Integer i = 1; i <= aShapes.Length(); ++i)
+  {
+    TopoDS_Shape aShape = aShapes.Value(i);
+
+    Handle(ShapePersistent_TopoDS::HShape) aPShape =
+      ShapePersistent_TopoDS::Translate(aShape, aMap, ShapePersistent_WithTriangle);
+    if (aPShape.IsNull())
+    {
+      theDI << "Error : couldn't translate shape " << theArgs[i] << "\n";
+      return 1;
+    }
+    
+    TCollection_AsciiString aName = theArgs[i];
+    if (aShapeNames.IsBound(aName))
+    {
+      Standard_Integer n = aShapeNames.Find(theArgs[i]);
+      if (n > 1)
+      {
+        aName += "_";
+        aName += n;
+      }
+    }
+
+    Handle(StdStorage_Root) aRoot = new StdStorage_Root(aName, aPShape);
+    aData->RootData()->AddRoot(aRoot);
+  }
+
+  Storage_Error anError = StdStorage::Write(*aFileDriver, aData);
+
+  aFileDriver->Close();
+
+  if (anError != Storage_VSOk)
+  {
+    theDI << "Error : " << anError << "\n";
+    return 1;
+  }
+
+  return 0;
+}
+
+//=======================================================================
+//function : DDocStd_ShapeSchema_Read 
+//=======================================================================
+
+static Standard_Integer DDocStd_fsdread(Draw_Interpretor& theDI, 
+                                        Standard_Integer theArgNb, 
+                                        const char** theArgs)
+{
+  if (theArgNb < 3)
+  {
+    theDI << "Usage : fsdread filename shape\n";
+    theDI << "        Arguments:\n";
+    theDI << "        filename : input file name\n";
+    theDI << "        shape    : name of an output shape,\n";
+    theDI << "                   root shapes will be put into a compound\n";
+    theDI << "                   in case of multiple roots in the file\n";
+    return 1;
+  }
+
+  Handle(StdStorage_Data) aData;
+  Storage_Error anError = StdStorage::Read(TCollection_AsciiString(theArgs[1]), aData);
+  if (anError != Storage_VSOk)
+  {
+    theDI << "Error : " << anError << "\n";
+    return 1;
+  }
+
+  TopTools_SequenceOfShape aShapes;
+
+  Handle(StdStorage_TypeData) aTypeData = aData->TypeData();
+  Handle(StdStorage_RootData) aRootData = aData->RootData();
+  Handle(StdStorage_HSequenceOfRoots) aRoots = aRootData->Roots();
+  if (!aRoots.IsNull())
+  {
+    for (StdStorage_HSequenceOfRoots::Iterator anIt(*aRoots); anIt.More(); anIt.Next())
+    {
+      Handle(StdStorage_Root)& aRoot = anIt.ChangeValue();
+      Handle(StdObjMgt_Persistent) aPObject = aRoot->Object();
+      if (!aPObject.IsNull())
+      {
+        Handle(ShapePersistent_TopoDS::HShape) aHShape = Handle(ShapePersistent_TopoDS::HShape)::DownCast(aPObject);
+        if (aHShape) // shapes are expected
+        {
+          TopoDS_Shape aShape = aHShape->Import();
+          aShapes.Append(aShape);
+        }
+      }
+    }
+  }
+
+  theDI << "Info : " << aTypeData->NumberOfTypes() << " type(s)\n";
+  theDI << "       " << aRoots->Length() << " root(s)\n";
+  theDI << "       " << aShapes.Length() << " shape(s) translated\n";
+
+  if (aShapes.Length() > 1)
+  {
+    BRep_Builder aB;
+    TopoDS_Compound aC;
+    aB.MakeCompound(aC);
+    for (Standard_Integer i = 1; i <= aShapes.Length(); ++i)
+      aB.Add(aC, aShapes.Value(i));
+    DBRep::Set(theArgs[2], aC);
+  }
+  else
+    DBRep::Set(theArgs[2], aShapes.First());
+
+  return 0;
+}
+
+//=======================================================================
+//function : ShapeSchemaCommands
+//purpose  : registers shape schema related commands in Draw interpreter
+//=======================================================================
+
+void DDocStd::ShapeSchemaCommands(Draw_Interpretor& theCommands)
+{
+  static Standard_Boolean done = Standard_False;
+  if (done) return;
+  done = Standard_True;
+
+  const char* g = "Shape persistence commands";
+
+  theCommands.Add("fsdwrite",
+    "fsdrite shape filename [driver]",
+    __FILE__, DDocStd_fsdwrite, g);
+
+  theCommands.Add("fsdread",
+    "fsdread filename shape",
+    __FILE__, DDocStd_fsdread, g);
+
+}
index 938b558..e4ff821 100755 (executable)
@@ -6,4 +6,5 @@ DDocStd_DrawDocument.cxx
 DDocStd_DrawDocument.hxx
 DDocStd_MTMCommands.cxx
 DDocStd_ToolsCommands.cxx
+DDocStd_ShapeSchemaCommands.cxx
 IDNames.tcl
index 4042c5f..6b8c97e 100644 (file)
@@ -9,6 +9,7 @@ ShapePersistent_Geom_Curve.hxx
 ShapePersistent_Geom_Surface.cxx
 ShapePersistent_Geom_Surface.hxx
 ShapePersistent_Geom2d.hxx
+ShapePersistent_Geom2d.cxx
 ShapePersistent_Geom2d_Curve.cxx
 ShapePersistent_Geom2d_Curve.hxx
 ShapePersistent_HArray1.hxx
@@ -19,3 +20,4 @@ ShapePersistent_Poly.cxx
 ShapePersistent_Poly.hxx
 ShapePersistent_TopoDS.cxx
 ShapePersistent_TopoDS.hxx
+ShapePersistent_TriangleMode.hxx
index 055adbe..3ba3ac2 100644 (file)
@@ -11,6 +11,8 @@
 // Alternatively, this file may be used under the terms of Open CASCADE
 // commercial license or contractual agreement.
 
+#include <Standard_NullObject.hxx>
+
 #include <ShapePersistent_BRep.hxx>
 
 #include <BRep_PointOnCurve.hxx>
 #include <BRep_TEdge.hxx>
 #include <BRep_TFace.hxx>
 
+#include <Geom_Surface.hxx>
+
+#include <TopoDS_Vertex.hxx>
+#include <TopoDS_Edge.hxx>
+#include <TopoDS_Face.hxx>
+
+#include <Poly_Polygon2D.hxx>
+#include <Poly_Polygon3D.hxx>
+#include <Poly_PolygonOnTriangulation.hxx>
+#include <Poly_Triangulation.hxx>
 
 enum
 {
@@ -40,17 +52,23 @@ enum
 
 
 //=======================================================================
-//function : Read
-//purpose  : Read persistent data from a file
+// PointRepresentation
 //=======================================================================
 void ShapePersistent_BRep::PointRepresentation::Read
   (StdObjMgt_ReadData& theReadData)
     { theReadData >> myLocation >> myParameter >> myNext; }
 
-//=======================================================================
-//function : Import
-//purpose  : Import transient object from the persistent data
-//=======================================================================
+void ShapePersistent_BRep::PointRepresentation::Write
+  (StdObjMgt_WriteData& theWriteData) const
+    { theWriteData << myLocation << myParameter << myNext; }
+
+void ShapePersistent_BRep::PointRepresentation::PChildren
+  (StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
+{
+  myLocation.PChildren(theChildren);
+  theChildren.Append(myNext);
+}
+
 void ShapePersistent_BRep::PointRepresentation::Import
   (BRep_ListOfPointRepresentation& thePoints) const
 {
@@ -64,6 +82,9 @@ Handle(BRep_PointRepresentation)
   ShapePersistent_BRep::PointRepresentation::import() const
     { return NULL; }
 
+//=======================================================================
+// PointOnCurve
+//=======================================================================
 void ShapePersistent_BRep::PointOnCurve::Read
   (StdObjMgt_ReadData& theReadData)
 {
@@ -71,6 +92,20 @@ void ShapePersistent_BRep::PointOnCurve::Read
   theReadData >> myCurve;
 }
 
+void ShapePersistent_BRep::PointOnCurve::Write
+  (StdObjMgt_WriteData& theWriteData) const
+{
+  PointRepresentation::Write (theWriteData);
+  theWriteData << myCurve;
+}
+
+void ShapePersistent_BRep::PointOnCurve::PChildren
+  (StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
+{
+  PointRepresentation::PChildren(theChildren);
+  theChildren.Append(myCurve);
+}
+
 Handle(BRep_PointRepresentation)
   ShapePersistent_BRep::PointOnCurve::import() const
 {
@@ -82,6 +117,9 @@ Handle(BRep_PointRepresentation)
     (myParameter, aCurve, myLocation.Import());
 }
 
+//=======================================================================
+// PointsOnSurface
+//=======================================================================
 void ShapePersistent_BRep::PointsOnSurface::Read
   (StdObjMgt_ReadData& theReadData)
 {
@@ -89,6 +127,23 @@ void ShapePersistent_BRep::PointsOnSurface::Read
   theReadData >> mySurface;
 }
 
+void ShapePersistent_BRep::PointsOnSurface::Write
+  (StdObjMgt_WriteData& theWriteData) const
+{
+  PointRepresentation::Write (theWriteData);
+  theWriteData << mySurface;
+}
+
+void ShapePersistent_BRep::PointsOnSurface::PChildren
+  (StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
+{
+  PointRepresentation::PChildren(theChildren);
+  theChildren.Append(mySurface);
+}
+
+//=======================================================================
+// PointOnCurveOnSurface
+//=======================================================================
 void ShapePersistent_BRep::PointOnCurveOnSurface::Read
   (StdObjMgt_ReadData& theReadData)
 {
@@ -96,6 +151,20 @@ void ShapePersistent_BRep::PointOnCurveOnSurface::Read
   theReadData >> myPCurve;
 }
 
+void ShapePersistent_BRep::PointOnCurveOnSurface::Write
+  (StdObjMgt_WriteData& theWriteData) const
+{
+  PointsOnSurface::Write (theWriteData);
+  theWriteData << myPCurve;
+}
+
+void ShapePersistent_BRep::PointOnCurveOnSurface::PChildren
+  (StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
+{
+  PointRepresentation::PChildren(theChildren);
+  theChildren.Append(myPCurve);
+}
+
 Handle(BRep_PointRepresentation)
   ShapePersistent_BRep::PointOnCurveOnSurface::import() const
 {
@@ -111,6 +180,9 @@ Handle(BRep_PointRepresentation)
     (myParameter, aPCurve, aSurface, myLocation.Import());
 }
 
+//=======================================================================
+// PointOnSurface
+//=======================================================================
 void ShapePersistent_BRep::PointOnSurface::Read
   (StdObjMgt_ReadData& theReadData)
 {
@@ -118,6 +190,13 @@ void ShapePersistent_BRep::PointOnSurface::Read
   theReadData >> myParameter2;
 }
 
+void ShapePersistent_BRep::PointOnSurface::Write
+  (StdObjMgt_WriteData& theWriteData) const
+{
+  PointsOnSurface::Write(theWriteData);
+  theWriteData << myParameter2;
+}
+
 Handle(BRep_PointRepresentation)
   ShapePersistent_BRep::PointOnSurface::import() const
 {
@@ -130,17 +209,23 @@ Handle(BRep_PointRepresentation)
 }
 
 //=======================================================================
-//function : Read
-//purpose  : Read persistent data from a file
+// CurveRepresentation
 //=======================================================================
 void ShapePersistent_BRep::CurveRepresentation::Read
   (StdObjMgt_ReadData& theReadData)
     { theReadData >> myLocation >> myNext; }
 
-//=======================================================================
-//function : Import
-//purpose  : Import transient object from the persistent data
-//=======================================================================
+void ShapePersistent_BRep::CurveRepresentation::Write
+  (StdObjMgt_WriteData& theWriteData) const
+    { theWriteData << myLocation << myNext; }
+
+void ShapePersistent_BRep::CurveRepresentation::PChildren
+  (StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
+{
+  myLocation.PChildren(theChildren);
+  theChildren.Append(myNext);
+}
+
 void ShapePersistent_BRep::CurveRepresentation::Import
   (BRep_ListOfCurveRepresentation& theCurves) const
 {
@@ -154,6 +239,9 @@ Handle(BRep_CurveRepresentation)
   ShapePersistent_BRep::CurveRepresentation::import() const
     { return NULL; }
 
+//=======================================================================
+// GCurve
+//=======================================================================
 void ShapePersistent_BRep::GCurve::Read
   (StdObjMgt_ReadData& theReadData)
 {
@@ -161,6 +249,16 @@ void ShapePersistent_BRep::GCurve::Read
   theReadData >> myFirst >> myLast;
 }
 
+void ShapePersistent_BRep::GCurve::Write
+  (StdObjMgt_WriteData& theWriteData) const
+{
+  CurveRepresentation::Write(theWriteData);
+  theWriteData << myFirst << myLast;
+}
+
+//=======================================================================
+// Curve3D
+//=======================================================================
 void ShapePersistent_BRep::Curve3D::Read
   (StdObjMgt_ReadData& theReadData)
 {
@@ -168,6 +266,20 @@ void ShapePersistent_BRep::Curve3D::Read
   theReadData >> myCurve3D;
 }
 
+void ShapePersistent_BRep::Curve3D::Write
+  (StdObjMgt_WriteData& theWriteData) const
+{
+  GCurve::Write (theWriteData);
+  theWriteData << myCurve3D;
+}
+
+void ShapePersistent_BRep::Curve3D::PChildren
+  (StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
+{
+  GCurve::PChildren(theChildren);
+  theChildren.Append(myCurve3D);
+}
+
 Handle(BRep_CurveRepresentation)
   ShapePersistent_BRep::Curve3D::import() const
 {
@@ -182,6 +294,9 @@ Handle(BRep_CurveRepresentation)
   return aRepresentation;
 }
 
+//=======================================================================
+// CurveOnSurface
+//=======================================================================
 void ShapePersistent_BRep::CurveOnSurface::Read
   (StdObjMgt_ReadData& theReadData)
 {
@@ -189,6 +304,21 @@ void ShapePersistent_BRep::CurveOnSurface::Read
   theReadData >> myPCurve >> mySurface >> myUV1 >> myUV2;
 }
 
+void ShapePersistent_BRep::CurveOnSurface::Write
+  (StdObjMgt_WriteData& theWriteData) const
+{
+  GCurve::Write (theWriteData);
+  theWriteData << myPCurve << mySurface << myUV1 << myUV2;
+}
+
+void ShapePersistent_BRep::CurveOnSurface::PChildren
+  (StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
+{
+  GCurve::PChildren(theChildren);
+  theChildren.Append(myPCurve);
+  theChildren.Append(mySurface);
+}
+
 Handle(BRep_CurveRepresentation)
   ShapePersistent_BRep::CurveOnSurface::import() const
 {
@@ -209,6 +339,9 @@ Handle(BRep_CurveRepresentation)
   return aRepresentation;
 }
 
+//=======================================================================
+// CurveOnClosedSurface
+//=======================================================================
 void ShapePersistent_BRep::CurveOnClosedSurface::Read
   (StdObjMgt_ReadData& theReadData)
 {
@@ -216,6 +349,20 @@ void ShapePersistent_BRep::CurveOnClosedSurface::Read
   theReadData >> myPCurve2 >> myContinuity >> myUV21 >> myUV22;
 }
 
+void ShapePersistent_BRep::CurveOnClosedSurface::Write
+  (StdObjMgt_WriteData& theWriteData) const
+{
+  CurveOnSurface::Write (theWriteData);
+  theWriteData << myPCurve2 << myContinuity << myUV21 << myUV22;
+}
+
+void ShapePersistent_BRep::CurveOnClosedSurface::PChildren
+  (StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
+{
+  CurveOnSurface::PChildren(theChildren);
+  theChildren.Append(myPCurve2);
+}
+
 Handle(BRep_CurveRepresentation)
   ShapePersistent_BRep::CurveOnClosedSurface::import() const
 {
@@ -244,6 +391,9 @@ Handle(BRep_CurveRepresentation)
   return aRepresentation;
 }
 
+//=======================================================================
+// Polygon3D
+//=======================================================================
 void ShapePersistent_BRep::Polygon3D::Read
   (StdObjMgt_ReadData& theReadData)
 {
@@ -251,6 +401,20 @@ void ShapePersistent_BRep::Polygon3D::Read
   theReadData >> myPolygon3D;
 }
 
+void ShapePersistent_BRep::Polygon3D::Write
+  (StdObjMgt_WriteData& theWriteData) const
+{
+  CurveRepresentation::Write (theWriteData);
+  theWriteData << myPolygon3D;
+}
+
+void ShapePersistent_BRep::Polygon3D::PChildren
+  (StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
+{
+  CurveRepresentation::PChildren(theChildren);
+  theChildren.Append(myPolygon3D);
+}
+
 Handle(BRep_CurveRepresentation)
   ShapePersistent_BRep::Polygon3D::import() const
 {
@@ -261,6 +425,9 @@ Handle(BRep_CurveRepresentation)
   return new BRep_Polygon3D (aPolygon3D, myLocation.Import());
 }
 
+//=======================================================================
+// PolygonOnTriangulation
+//=======================================================================
 void ShapePersistent_BRep::PolygonOnTriangulation::Read
   (StdObjMgt_ReadData& theReadData)
 {
@@ -268,6 +435,21 @@ void ShapePersistent_BRep::PolygonOnTriangulation::Read
   theReadData >> myPolygon >> myTriangulation;
 }
 
+void ShapePersistent_BRep::PolygonOnTriangulation::Write
+  (StdObjMgt_WriteData& theWriteData) const
+{
+  CurveRepresentation::Write (theWriteData);
+  theWriteData << myPolygon << myTriangulation;
+}
+
+void ShapePersistent_BRep::PolygonOnTriangulation::PChildren
+  (StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
+{
+  CurveRepresentation::PChildren(theChildren);
+  theChildren.Append(myPolygon);
+  theChildren.Append(myTriangulation);
+}
+
 Handle(BRep_CurveRepresentation)
   ShapePersistent_BRep::PolygonOnTriangulation::import() const
 {
@@ -283,6 +465,9 @@ Handle(BRep_CurveRepresentation)
     (aPolygon, aTriangulation, myLocation.Import());
 }
 
+//=======================================================================
+// PolygonOnClosedTriangulation
+//=======================================================================
 void ShapePersistent_BRep::PolygonOnClosedTriangulation::Read
   (StdObjMgt_ReadData& theReadData)
 {
@@ -290,6 +475,20 @@ void ShapePersistent_BRep::PolygonOnClosedTriangulation::Read
   theReadData >> myPolygon2;
 }
 
+void ShapePersistent_BRep::PolygonOnClosedTriangulation::Write
+  (StdObjMgt_WriteData& theWriteData) const
+{
+  PolygonOnTriangulation::Write (theWriteData);
+  theWriteData << myPolygon2;
+}
+
+void ShapePersistent_BRep::PolygonOnClosedTriangulation::PChildren
+  (StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
+{
+  PolygonOnTriangulation::PChildren(theChildren);
+  theChildren.Append(myPolygon2);
+}
+
 Handle(BRep_CurveRepresentation)
   ShapePersistent_BRep::PolygonOnClosedTriangulation::import() const
 {
@@ -309,6 +508,9 @@ Handle(BRep_CurveRepresentation)
     (aPolygon, aPolygon2, aTriangulation, myLocation.Import());
 }
 
+//=======================================================================
+// PolygonOnSurface
+//=======================================================================
 void ShapePersistent_BRep::PolygonOnSurface::Read
   (StdObjMgt_ReadData& theReadData)
 {
@@ -316,6 +518,21 @@ void ShapePersistent_BRep::PolygonOnSurface::Read
   theReadData >> myPolygon2D >> mySurface;
 }
 
+void ShapePersistent_BRep::PolygonOnSurface::Write
+  (StdObjMgt_WriteData& theWriteData) const
+{
+  CurveRepresentation::Write (theWriteData);
+  theWriteData << myPolygon2D << mySurface;
+}
+
+void ShapePersistent_BRep::PolygonOnSurface::PChildren
+  (StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
+{
+  CurveRepresentation::PChildren(theChildren);
+  theChildren.Append(myPolygon2D);
+  theChildren.Append(mySurface);
+}
+
 Handle(BRep_CurveRepresentation)
   ShapePersistent_BRep::PolygonOnSurface::import() const
 {
@@ -330,6 +547,9 @@ Handle(BRep_CurveRepresentation)
   return new BRep_PolygonOnSurface (aPolygon2D, aSurface, myLocation.Import());
 }
 
+//=======================================================================
+// PolygonOnClosedSurface
+//=======================================================================
 void ShapePersistent_BRep::PolygonOnClosedSurface::Read
   (StdObjMgt_ReadData& theReadData)
 {
@@ -337,6 +557,20 @@ void ShapePersistent_BRep::PolygonOnClosedSurface::Read
   theReadData >> myPolygon2;
 }
 
+void ShapePersistent_BRep::PolygonOnClosedSurface::Write
+  (StdObjMgt_WriteData& theWriteData) const
+{
+  PolygonOnSurface::Write (theWriteData);
+  theWriteData << myPolygon2;
+}
+
+void ShapePersistent_BRep::PolygonOnClosedSurface::PChildren
+  (StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
+{
+  PolygonOnSurface::PChildren(theChildren);
+  theChildren.Append(myPolygon2);
+}
+
 Handle(BRep_CurveRepresentation)
   ShapePersistent_BRep::PolygonOnClosedSurface::import() const
 {
@@ -356,6 +590,9 @@ Handle(BRep_CurveRepresentation)
     (aPolygon2D, aPolygon2, aSurface, myLocation.Import());
 }
 
+//=======================================================================
+// CurveOn2Surfaces
+//=======================================================================
 void ShapePersistent_BRep::CurveOn2Surfaces::Read
   (StdObjMgt_ReadData& theReadData)
 {
@@ -363,6 +600,22 @@ void ShapePersistent_BRep::CurveOn2Surfaces::Read
   theReadData >> mySurface >> mySurface2 >> myLocation2 >> myContinuity;
 }
 
+void ShapePersistent_BRep::CurveOn2Surfaces::Write
+  (StdObjMgt_WriteData& theWriteData) const
+{
+  CurveRepresentation::Write (theWriteData);
+  theWriteData << mySurface << mySurface2 << myLocation2 << myContinuity;
+}
+
+void ShapePersistent_BRep::CurveOn2Surfaces::PChildren
+  (StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
+{
+  CurveRepresentation::PChildren(theChildren);
+  theChildren.Append(mySurface);
+  theChildren.Append(mySurface2);
+  myLocation2.PChildren(theChildren);
+}
+
 Handle(BRep_CurveRepresentation)
   ShapePersistent_BRep::CurveOn2Surfaces::import() const
 {
@@ -434,3 +687,464 @@ Handle(TopoDS_TShape) ShapePersistent_BRep::pTFace::createTShape() const
 
   return aTFace;
 }
+
+//=======================================================================
+//function : Translate
+//purpose  : Translates a shape to its persistent avatar
+//=======================================================================
+Handle(ShapePersistent_BRep::TVertex::pTObjectT)
+ShapePersistent_BRep::Translate (const TopoDS_Vertex& theVertex,
+                                 StdObjMgt_TransientPersistentMap& theMap)
+{
+  Handle(BRep_TVertex) TTV = Handle(BRep_TVertex)::DownCast (theVertex.TShape());
+
+  Handle(TVertex::pTObjectT) PTV = new TVertex::pTObjectT;
+
+  PTV->myPnt = TTV->Pnt();
+  PTV->myTolerance = TTV->Tolerance();
+
+  BRep_ListIteratorOfListOfPointRepresentation anItPR(TTV->Points());
+
+  Handle(PointRepresentation) PPR, CPPR;
+  while (anItPR.More())
+  {
+    const Handle(BRep_PointRepresentation)& PR = anItPR.Value();
+    if (PR->IsPointOnCurve()) {
+      Handle(PointOnCurve) POC = Translate(PR->Parameter(), 
+                                           PR->Curve(), 
+                                           PR->Location(), 
+                                           theMap);
+      CPPR = POC;
+    }
+    else if (PR->IsPointOnCurveOnSurface()) {
+      Handle(PointOnCurveOnSurface) POCS = Translate(PR->Parameter(), 
+                                                     PR->PCurve(), 
+                                                     PR->Surface(), 
+                                                     PR->Location(), 
+                                                     theMap);
+      CPPR = POCS;
+    }
+    else if (PR->IsPointOnSurface()) {
+      Handle(PointOnSurface) POS = Translate(PR->Parameter(), 
+                                             PR->Parameter2(), 
+                                             PR->Surface(), 
+                                             PR->Location(), 
+                                             theMap);
+      CPPR = POS;
+    }
+
+    CPPR->myNext = PPR;
+    PPR = CPPR;
+    anItPR.Next();
+  }
+
+  PTV->myPoints = PPR;
+
+  return PTV;
+}
+
+//=======================================================================
+//function : Translate
+//purpose  : Translates a shape to its persistent avatar
+//=======================================================================
+Handle(ShapePersistent_BRep::TEdge::pTObjectT)
+ShapePersistent_BRep::Translate (const TopoDS_Edge& theEdge,
+                                 StdObjMgt_TransientPersistentMap& theMap,
+                                 ShapePersistent_TriangleMode theTriangleMode)
+{
+  Handle(BRep_TEdge) TTE = Handle(BRep_TEdge)::DownCast (theEdge.TShape());
+
+  Handle(TEdge::pTObjectT) PTE = new TEdge::pTObjectT;
+
+  PTE->myTolerance = TTE->Tolerance();
+  if (TTE->SameParameter()) PTE->myFlags |= ParameterMask;
+  if (TTE->SameRange())     PTE->myFlags |= RangeMask;
+  if (TTE->Degenerated())   PTE->myFlags |= DegeneratedMask;
+
+  // Representations
+  BRep_ListIteratorOfListOfCurveRepresentation itcr(TTE->Curves());
+
+  Handle(CurveRepresentation) PCR, CPCR;
+  Handle(BRep_GCurve) GC;
+  Standard_Real f, l;
+
+  while (itcr.More()) 
+  {
+    const Handle(BRep_CurveRepresentation)& CR = itcr.Value();
+    GC = Handle(BRep_GCurve)::DownCast(CR);
+    if (!GC.IsNull()) 
+    {
+      GC->Range(f, l);
+      // CurveRepresentation is Curve3D
+      if (CR->IsCurve3D()) {
+        Handle(Curve3D) C3D = Translate(CR->Curve3D(), f, l, CR->Location(), theMap);
+        CPCR = C3D;
+      }
+      // CurveRepresentation is CurveOnSurface
+      else if (CR->IsCurveOnSurface()) 
+      {
+        Handle(BRep_CurveOnSurface)& theCOS = (Handle(BRep_CurveOnSurface)&) CR;
+        Handle(CurveOnSurface) COS;
+        // CurveRepresentation is CurveOnSurface
+        if (!CR->IsCurveOnClosedSurface()) 
+        {
+          COS = Translate(CR->PCurve(), f, l, CR->Surface(), CR->Location(), theMap);
+        }
+        // CurveRepresentation is CurveOnClosedSurface
+        else 
+        {
+          // get UVPoints for the CurveOnClosedSurface definition.
+          Handle(BRep_CurveOnClosedSurface)& theCOCS =
+            (Handle(BRep_CurveOnClosedSurface)&) CR;
+          gp_Pnt2d Pnt21, Pnt22;
+          theCOCS->UVPoints2(Pnt21, Pnt22);
+          Handle(CurveOnClosedSurface) COCS = Translate(CR->PCurve(), CR->PCurve2(), 
+                                                        f, l, CR->Surface(), 
+                                                        CR->Location(), CR->Continuity(), 
+                                                        theMap);
+          COCS->myUV21 = Pnt21;
+          COCS->myUV22 = Pnt22;
+          COS = COCS;
+        }
+
+        // get UVPoints for the CurveOnSurface definition.
+        gp_Pnt2d Pnt1, Pnt2;
+        theCOS->UVPoints(Pnt1, Pnt2);
+        COS->myUV1 = Pnt1;
+        COS->myUV2 = Pnt2;
+        CPCR = COS;
+      }
+    }
+    // CurveRepresentation is CurveOn2Surfaces
+    else if (CR->IsRegularity()) 
+    {
+      Handle(CurveOn2Surfaces) R = Translate(CR->Surface(), CR->Surface2(), 
+                                             CR->Location(), CR->Location2(), 
+                                             CR->Continuity(), 
+                                             theMap);
+      CPCR = R;
+    }
+    // CurveRepresentation is Polygon or Triangulation
+    else if (theTriangleMode == ShapePersistent_WithTriangle) {
+      // CurveRepresentation is Polygon3D
+      if (CR->IsPolygon3D()) {
+        Handle(Polygon3D) P3D = Translate(CR->Polygon3D(), CR->Location(), theMap);
+        CPCR = P3D;
+      }
+      // CurveRepresentation is PolygonOnSurface
+      else if (CR->IsPolygonOnSurface()) 
+      {
+        // CurveRepresentation is PolygonOnClosedSurface
+        if (CR->IsPolygonOnClosedSurface()) {
+          Handle(PolygonOnClosedSurface) PolOCS = Translate(CR->Polygon(), CR->Polygon2(), 
+                                                            CR->Surface(), CR->Location(), 
+                                                            theMap);
+          CPCR = PolOCS;
+        }
+        // CurveRepresentation is PolygonOnSurface
+        else 
+        {
+          Handle(PolygonOnSurface) PolOS = Translate(CR->Polygon(), CR->Surface(), 
+                                                     CR->Location(), theMap);
+          CPCR = PolOS;
+        }
+      }
+      // CurveRepresentation is PolygonOnTriangulation
+      else if (CR->IsPolygonOnTriangulation()) 
+      {
+        // CurveRepresentation is PolygonOnClosedTriangulation
+        if (CR->IsPolygonOnClosedTriangulation()) 
+        {
+          Handle(PolygonOnClosedTriangulation) PolOCT = Translate(CR->PolygonOnTriangulation(), 
+                                                                  CR->PolygonOnTriangulation2(), 
+                                                                  CR->Triangulation(), 
+                                                                  CR->Location(), 
+                                                                  theMap);
+          CPCR = PolOCT;
+        }
+        // CurveRepresentation is PolygonOnTriangulation
+        else 
+        {
+          Handle(PolygonOnTriangulation) PolOT = Translate(CR->PolygonOnTriangulation(), 
+                                                           CR->Triangulation(), 
+                                                           CR->Location(), 
+                                                           theMap);
+          CPCR = PolOT;
+        }
+      }
+    }
+    else 
+    {
+      // jumps the curve representation
+      itcr.Next();
+      continue;
+    }
+
+    Standard_NullObject_Raise_if(CPCR.IsNull(), "Null CurveRepresentation");
+
+    CPCR->myNext = PCR;
+    PCR = CPCR;
+    itcr.Next();
+  }
+
+  // set
+  PTE->myCurves = PCR;
+
+  return PTE;
+}
+
+//=======================================================================
+//function : Translate
+//purpose  : Translates a shape to its persistent avatar
+//=======================================================================
+Handle(ShapePersistent_BRep::TFace::pTObjectT)
+ShapePersistent_BRep::Translate (const TopoDS_Face& theFace,
+                                 StdObjMgt_TransientPersistentMap& theMap,
+                                 ShapePersistent_TriangleMode theTriangleMode)
+{
+  Handle(BRep_TFace) TTF = Handle(BRep_TFace)::DownCast (theFace.TShape());
+
+  Handle(TFace::pTObjectT) PTF = new TFace::pTObjectT;
+
+  PTF->myTolerance = TTF->Tolerance();
+  PTF->myLocation = StdObject_Location::Translate(TTF->Location(), theMap);
+  PTF->myNaturalRestriction = TTF->NaturalRestriction();
+
+  // Surface
+  PTF->mySurface = ShapePersistent_Geom::Translate(TTF->Surface(), theMap);
+
+  // Triangulation
+  if (theTriangleMode == ShapePersistent_WithTriangle) {
+    PTF->myTriangulation = ShapePersistent_Poly::Translate(TTF->Triangulation(), theMap);
+  }
+
+  return PTF;
+}
+
+//=======================================================================
+//function : Translate
+//purpose  : Translates a shape to its persistent avatar
+//=======================================================================
+Handle(ShapePersistent_BRep::PointOnCurve)
+ShapePersistent_BRep::Translate (Standard_Real theParam,
+                                 const Handle(Geom_Curve)& theCurve,
+                                 const TopLoc_Location& theLoc,
+                                 StdObjMgt_TransientPersistentMap& theMap)
+{
+  Handle(PointOnCurve) aPPonC = new PointOnCurve;
+  aPPonC->myParameter = theParam;
+  aPPonC->myCurve = ShapePersistent_Geom::Translate(theCurve, theMap);
+  aPPonC->myLocation = StdObject_Location::Translate(theLoc, theMap);
+  return aPPonC;
+}
+
+//=======================================================================
+//function : Translate
+//purpose  : Translates a shape to its persistent avatar
+//=======================================================================
+Handle(ShapePersistent_BRep::PointOnCurveOnSurface)
+ShapePersistent_BRep::Translate(Standard_Real theParam,
+                                const Handle(Geom2d_Curve)& theCurve,
+                                const Handle(Geom_Surface)& theSurf,
+                                const TopLoc_Location& theLoc,
+                                StdObjMgt_TransientPersistentMap& theMap)
+{
+  Handle(PointOnCurveOnSurface) aPPonConS = new PointOnCurveOnSurface;
+  aPPonConS->myParameter = theParam;
+  aPPonConS->myPCurve = ShapePersistent_Geom2d::Translate(theCurve, theMap);
+  aPPonConS->mySurface = ShapePersistent_Geom::Translate(theSurf, theMap);
+  aPPonConS->myLocation = StdObject_Location::Translate(theLoc, theMap);
+  return aPPonConS;
+}
+
+//=======================================================================
+//function : Translate
+//purpose  : Translates a shape to its persistent avatar
+//=======================================================================
+Handle(ShapePersistent_BRep::PointOnSurface)
+ShapePersistent_BRep::Translate(Standard_Real theParam,
+                                Standard_Real theParam2,
+                                const Handle(Geom_Surface)& theSurf,
+                                const TopLoc_Location& theLoc,
+                                StdObjMgt_TransientPersistentMap& theMap)
+{
+  Handle(PointOnSurface) aPonS = new PointOnSurface;
+  aPonS->myParameter = theParam;
+  aPonS->myParameter2 = theParam2;
+  aPonS->mySurface = ShapePersistent_Geom::Translate(theSurf, theMap);
+  aPonS->myLocation = StdObject_Location::Translate(theLoc, theMap);
+  return aPonS;
+}
+
+//=======================================================================
+//function : Translate
+//purpose  : Translates a shape to its persistent avatar
+//=======================================================================
+Handle(ShapePersistent_BRep::CurveOnSurface)
+ShapePersistent_BRep::Translate(const Handle(Geom2d_Curve)& theCurve,
+                                const Standard_Real theFirstParam,
+                                const Standard_Real theLastParam,
+                                const Handle(Geom_Surface)& theSurf,
+                                const TopLoc_Location& theLoc,
+                                StdObjMgt_TransientPersistentMap& theMap)
+{
+  Handle(CurveOnSurface) aPConS = new CurveOnSurface;
+  aPConS->myPCurve = ShapePersistent_Geom2d::Translate(theCurve, theMap);
+  aPConS->myFirst = theFirstParam;
+  aPConS->myLast = theLastParam;
+  aPConS->mySurface = ShapePersistent_Geom::Translate(theSurf, theMap);
+  aPConS->myLocation = StdObject_Location::Translate(theLoc, theMap);
+  return aPConS;
+}
+
+//=======================================================================
+//function : Translate
+//purpose  : Translates a shape to its persistent avatar
+//=======================================================================
+Handle(ShapePersistent_BRep::CurveOnClosedSurface)
+ShapePersistent_BRep::Translate(const Handle(Geom2d_Curve)& theCurve,
+                                const Handle(Geom2d_Curve)& theCurve2,
+                                const Standard_Real theFirstParam,
+                                const Standard_Real theLastParam,
+                                const Handle(Geom_Surface)& theSurf,
+                                const TopLoc_Location& theLoc,
+                                const GeomAbs_Shape theContinuity,
+                                StdObjMgt_TransientPersistentMap& theMap)
+{
+  Handle(CurveOnClosedSurface) aPConCS = new CurveOnClosedSurface;
+  aPConCS->myPCurve = ShapePersistent_Geom2d::Translate(theCurve, theMap);
+  aPConCS->myPCurve2 = ShapePersistent_Geom2d::Translate(theCurve2, theMap);
+  aPConCS->myFirst = theFirstParam;
+  aPConCS->myLast = theLastParam;
+  aPConCS->mySurface = ShapePersistent_Geom::Translate(theSurf, theMap);
+  aPConCS->myLocation = StdObject_Location::Translate(theLoc, theMap);
+  aPConCS->myContinuity = theContinuity;
+  return aPConCS;
+}
+
+//=======================================================================
+//function : Translate
+//purpose  : Translates a shape to its persistent avatar
+//=======================================================================
+Handle(ShapePersistent_BRep::CurveOn2Surfaces)
+ShapePersistent_BRep::Translate(const Handle(Geom_Surface)& theSurf,
+                                const Handle(Geom_Surface)& theSurf2,
+                                const TopLoc_Location& theLoc, 
+                                const TopLoc_Location& theLoc2,
+                                const GeomAbs_Shape theContinuity,
+                                StdObjMgt_TransientPersistentMap& theMap)
+{
+  Handle(CurveOn2Surfaces) aPCon2S = new CurveOn2Surfaces;
+  aPCon2S->mySurface = ShapePersistent_Geom::Translate(theSurf, theMap);
+  aPCon2S->mySurface2 = ShapePersistent_Geom::Translate(theSurf2, theMap);
+  aPCon2S->myLocation = StdObject_Location::Translate(theLoc, theMap);
+  aPCon2S->myLocation2 = StdObject_Location::Translate(theLoc2, theMap);
+  aPCon2S->myContinuity = theContinuity;
+  return aPCon2S;
+}
+
+//=======================================================================
+//function : Translate
+//purpose  : Translates a shape to its persistent avatar
+//=======================================================================
+Handle(ShapePersistent_BRep::Curve3D)
+ShapePersistent_BRep::Translate (const Handle(Geom_Curve)& theCurve,
+                                 const Standard_Real theFirstParam,
+                                 const Standard_Real theLastParam,
+                                 const TopLoc_Location& theLoc,
+                                 StdObjMgt_TransientPersistentMap& theMap)
+{
+  Handle(Curve3D) aPCurve3D = new Curve3D;
+  aPCurve3D->myCurve3D = ShapePersistent_Geom::Translate(theCurve, theMap);
+  aPCurve3D->myLocation = StdObject_Location::Translate(theLoc, theMap);
+  aPCurve3D->myFirst = theFirstParam;
+  aPCurve3D->myLast = theLastParam;
+  return aPCurve3D;
+}
+
+//=======================================================================
+//function : Translate
+//purpose  : Translates a shape to its persistent avatar
+//=======================================================================
+Handle(ShapePersistent_BRep::Polygon3D)
+ShapePersistent_BRep::Translate(const Handle(Poly_Polygon3D)& thePoly,
+                                const TopLoc_Location& theLoc,
+                                StdObjMgt_TransientPersistentMap& theMap)
+{
+  Handle(Polygon3D) aPPoly = new Polygon3D;
+  aPPoly->myPolygon3D = ShapePersistent_Poly::Translate(thePoly, theMap);
+  aPPoly->myLocation = StdObject_Location::Translate(theLoc, theMap);
+  return aPPoly;
+}
+
+//=======================================================================
+//function : Translate
+//purpose  : Translates a shape to its persistent avatar
+//=======================================================================
+Handle(ShapePersistent_BRep::PolygonOnClosedSurface)
+ShapePersistent_BRep::Translate(const Handle(Poly_Polygon2D)& thePoly,
+                                const Handle(Poly_Polygon2D)& thePoly2,
+                                const Handle(Geom_Surface)& theSurf,
+                                const TopLoc_Location& theLoc,
+                                StdObjMgt_TransientPersistentMap& theMap)
+{
+  Handle(PolygonOnClosedSurface) aPPonCS = new PolygonOnClosedSurface;
+  aPPonCS->myPolygon2D = ShapePersistent_Poly::Translate(thePoly, theMap);
+  aPPonCS->myPolygon2 = ShapePersistent_Poly::Translate(thePoly2, theMap);
+  aPPonCS->mySurface = ShapePersistent_Geom::Translate(theSurf, theMap);
+  aPPonCS->myLocation = StdObject_Location::Translate(theLoc, theMap);
+  return aPPonCS;
+}
+
+//=======================================================================
+//function : Translate
+//purpose  : Translates a shape to its persistent avatar
+//=======================================================================
+Handle(ShapePersistent_BRep::PolygonOnSurface)
+ShapePersistent_BRep::Translate(const Handle(Poly_Polygon2D)& thePoly,
+                                const Handle(Geom_Surface)& theSurf,
+                                const TopLoc_Location& theLoc,
+                                StdObjMgt_TransientPersistentMap& theMap)
+{
+  Handle(PolygonOnSurface) aPPonS = new PolygonOnSurface;
+  aPPonS->myPolygon2D = ShapePersistent_Poly::Translate(thePoly, theMap);
+  aPPonS->mySurface = ShapePersistent_Geom::Translate(theSurf, theMap);
+  aPPonS->myLocation = StdObject_Location::Translate(theLoc, theMap);
+  return aPPonS;
+}
+
+//=======================================================================
+//function : Translate
+//purpose  : Translates a shape to its persistent avatar
+//=======================================================================
+Handle(ShapePersistent_BRep::PolygonOnClosedTriangulation)
+ShapePersistent_BRep::Translate(const Handle(Poly_PolygonOnTriangulation)& thePolyOnTriang,
+                                const Handle(Poly_PolygonOnTriangulation)& thePolyOnTriang2,
+                                const Handle(Poly_Triangulation)& thePolyTriang,
+                                const TopLoc_Location& theLoc,
+                                StdObjMgt_TransientPersistentMap& theMap)
+{
+  Handle(PolygonOnClosedTriangulation) aPPonCS = new PolygonOnClosedTriangulation;
+  aPPonCS->myPolygon = ShapePersistent_Poly::Translate(thePolyOnTriang, theMap);
+  aPPonCS->myPolygon2 = ShapePersistent_Poly::Translate(thePolyOnTriang2, theMap);
+  aPPonCS->myTriangulation = ShapePersistent_Poly::Translate(thePolyTriang, theMap);
+  aPPonCS->myLocation = StdObject_Location::Translate(theLoc, theMap);
+  return aPPonCS;
+}
+
+//=======================================================================
+//function : Translate
+//purpose  : Translates a shape to its persistent avatar
+//=======================================================================
+Handle(ShapePersistent_BRep::PolygonOnTriangulation)
+ShapePersistent_BRep::Translate(const Handle(Poly_PolygonOnTriangulation)& thePolyOnTriang,
+                                const Handle(Poly_Triangulation)& thePolyTriang,
+                                const TopLoc_Location& theLoc,
+                                StdObjMgt_TransientPersistentMap& theMap)
+{
+  Handle(PolygonOnTriangulation) aPPonT = new PolygonOnTriangulation;
+  aPPonT->myPolygon = ShapePersistent_Poly::Translate(thePolyOnTriang, theMap);
+  aPPonT->myTriangulation = ShapePersistent_Poly::Translate(thePolyTriang, theMap);
+  aPPonT->myLocation = StdObject_Location::Translate(theLoc, theMap);
+  return aPPonT;
+}
index 3ef0f6d..ed4ef6e 100644 (file)
@@ -19,6 +19,7 @@
 #include <ShapePersistent_Geom.hxx>
 #include <ShapePersistent_Geom2d.hxx>
 #include <ShapePersistent_Poly.hxx>
+#include <StdObjMgt_TransientPersistentMap.hxx>
 #include <StdObject_Location.hxx>
 #include <StdObject_gp_Vectors.hxx>
 
 
 class BRep_PointRepresentation;
 class BRep_CurveRepresentation;
-
+class TopoDS_Vertex;
+class TopoDS_Edge;
+class TopoDS_Face;
 
 class ShapePersistent_BRep : public ShapePersistent_TopoDS
 {
 public:
   class PointRepresentation : public StdObjMgt_Persistent
   {
+    friend class ShapePersistent_BRep;
+
   public:
     //! Read persistent data from a file.
     Standard_EXPORT virtual void Read (StdObjMgt_ReadData& theReadData);
-
+    //! Write persistent data to a file.
+    Standard_EXPORT virtual void Write(StdObjMgt_WriteData& theWriteData) const;
+    //! Gets persistent child objects
+    virtual void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const;
+    //! Returns persistent type name
+    virtual Standard_CString PName() const { return "PBRep_PointRepresentation"; }
     //! Import transient object from the persistent data.
-    Standard_EXPORT void Import (BRep_ListOfPointRepresentation& thePoints)
-      const;
+    Standard_EXPORT void Import (BRep_ListOfPointRepresentation& thePoints) const;
 
   protected:
     virtual Handle(BRep_PointRepresentation) import() const;
@@ -58,8 +67,13 @@ public:
 
   class PointOnCurve : public PointRepresentation
   {
+    friend class ShapePersistent_BRep;
+
   public:
     virtual void Read (StdObjMgt_ReadData& theReadData);
+    virtual void Write (StdObjMgt_WriteData& theWriteData) const;
+    virtual void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const;
+    virtual Standard_CString PName() const { return "PBRep_PointOnCurve"; }
     virtual Handle(BRep_PointRepresentation) import() const;
 
   private:
@@ -68,8 +82,13 @@ public:
 
   class PointsOnSurface : public PointRepresentation
   {
+    friend class ShapePersistent_BRep;
+
   public:
     virtual void Read (StdObjMgt_ReadData& theReadData);
+    virtual void Write (StdObjMgt_WriteData& theWriteData) const;
+    virtual void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const;
+    virtual Standard_CString PName() const { return "PBRep_PointsOnSurface"; }
 
   protected:
     Handle(ShapePersistent_Geom::Surface) mySurface;
@@ -77,8 +96,13 @@ public:
 
   class PointOnCurveOnSurface : public PointsOnSurface
   {
+    friend class ShapePersistent_BRep;
+
   public:
     virtual void Read (StdObjMgt_ReadData& theReadData);
+    virtual void Write (StdObjMgt_WriteData& theWriteData) const;
+    virtual void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const;
+    virtual Standard_CString PName() const { return "PBRep_PointOnCurveOnSurface"; }
     virtual Handle(BRep_PointRepresentation) import() const;
 
   private:
@@ -87,8 +111,12 @@ public:
 
   class PointOnSurface : public PointsOnSurface
   {
+    friend class ShapePersistent_BRep;
+
   public:
     virtual void Read (StdObjMgt_ReadData& theReadData);
+    virtual void Write (StdObjMgt_WriteData& theWriteData) const;
+    virtual Standard_CString PName() const { return "PBRep_PointOnSurface"; }
     virtual Handle(BRep_PointRepresentation) import() const;
 
   private:
@@ -97,13 +125,19 @@ public:
 
   class CurveRepresentation : public StdObjMgt_Persistent
   {
+    friend class ShapePersistent_BRep;
+
   public:
     //! Read persistent data from a file.
     Standard_EXPORT virtual void Read (StdObjMgt_ReadData& theReadData);
-
+    //! Write persistent data from a file.
+    Standard_EXPORT virtual void Write (StdObjMgt_WriteData& theWriteData) const;
+    //! Gets persistent child objects
+    virtual void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const;
+    //! Returns persistent type name
+    virtual Standard_CString PName() const { return "PBRep_CurveRepresentation"; }
     //! Import transient object from the persistent data.
-    Standard_EXPORT void Import (BRep_ListOfCurveRepresentation& theCurves)
-      const;
+    Standard_EXPORT void Import (BRep_ListOfCurveRepresentation& theCurves) const;
 
   protected:
     virtual Handle(BRep_CurveRepresentation) import() const;
@@ -117,8 +151,12 @@ public:
 
   class GCurve : public CurveRepresentation
   {
+    friend class ShapePersistent_BRep;
+
   public:
     virtual void Read (StdObjMgt_ReadData& theReadData);
+    virtual void Write (StdObjMgt_WriteData& theWriteData) const;
+    virtual Standard_CString PName() const { return "PBRep_GCurve"; }
 
   protected:
     Standard_Real myFirst;
@@ -127,8 +165,13 @@ public:
 
   class Curve3D : public GCurve
   {
+    friend class ShapePersistent_BRep;
+
   public:
     virtual void Read (StdObjMgt_ReadData& theReadData);
+    virtual void Write (StdObjMgt_WriteData& theWriteData) const;
+    virtual void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const;
+    virtual Standard_CString PName() const { return "PBRep_Curve3D"; }
     virtual Handle(BRep_CurveRepresentation) import() const;
 
   private:
@@ -137,8 +180,13 @@ public:
 
   class CurveOnSurface : public GCurve
   {
+    friend class ShapePersistent_BRep;
+
   public:
     virtual void Read (StdObjMgt_ReadData& theReadData);
+    virtual void Write (StdObjMgt_WriteData& theWriteData) const;
+    virtual void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const;
+    virtual Standard_CString PName() const { return "PBRep_CurveOnSurface"; }
     virtual Handle(BRep_CurveRepresentation) import() const;
 
   protected:
@@ -150,8 +198,13 @@ public:
 
   class CurveOnClosedSurface : public CurveOnSurface
   {
+    friend class ShapePersistent_BRep;
+
   public:
     virtual void Read (StdObjMgt_ReadData& theReadData);
+    virtual void Write (StdObjMgt_WriteData& theWriteData) const;
+    virtual void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const;
+    virtual Standard_CString PName() const { return "PBRep_CurveOnClosedSurface"; }
     virtual Handle(BRep_CurveRepresentation) import() const;
 
   private:
@@ -163,8 +216,13 @@ public:
 
   class Polygon3D : public CurveRepresentation
   {
+    friend class ShapePersistent_BRep;
+
   public:
     virtual void Read (StdObjMgt_ReadData& theReadData);
+    virtual void Write (StdObjMgt_WriteData& theWriteData) const;
+    virtual void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const;
+    virtual Standard_CString PName() const { return "PBRep_Polygon3D"; }
     virtual Handle(BRep_CurveRepresentation) import() const;
 
   private:
@@ -173,8 +231,13 @@ public:
 
   class PolygonOnTriangulation : public CurveRepresentation
   {
+    friend class ShapePersistent_BRep;
+
   public:
     virtual void Read (StdObjMgt_ReadData& theReadData);
+    virtual void Write (StdObjMgt_WriteData& theWriteData) const;
+    virtual void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const;
+    virtual Standard_CString PName() const { return "PBRep_PolygonOnTriangulation"; }
     virtual Handle(BRep_CurveRepresentation) import() const;
 
   protected:
@@ -184,8 +247,13 @@ public:
 
   class PolygonOnClosedTriangulation : public PolygonOnTriangulation
   {
+    friend class ShapePersistent_BRep;
+
   public:
     virtual void Read (StdObjMgt_ReadData& theReadData);
+    virtual void Write (StdObjMgt_WriteData& theWriteData) const;
+    virtual void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const;
+    virtual Standard_CString PName() const { return "PBRep_PolygonOnClosedTriangulation"; }
     virtual Handle(BRep_CurveRepresentation) import() const;
 
   private:
@@ -194,8 +262,13 @@ public:
 
   class PolygonOnSurface : public CurveRepresentation
   {
+    friend class ShapePersistent_BRep;
+
   public:
     virtual void Read (StdObjMgt_ReadData& theReadData);
+    virtual void Write (StdObjMgt_WriteData& theWriteData) const;
+    virtual void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const;
+    virtual Standard_CString PName() const { return "PBRep_PolygonOnSurface"; }
     virtual Handle(BRep_CurveRepresentation) import() const;
 
   protected:
@@ -205,8 +278,13 @@ public:
 
   class PolygonOnClosedSurface : public PolygonOnSurface
   {
+    friend class ShapePersistent_BRep;
+
   public:
     virtual void Read (StdObjMgt_ReadData& theReadData);
+    virtual void Write (StdObjMgt_WriteData& theWriteData) const;
+    virtual void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const;
+    virtual Standard_CString PName() const { return "PBRep_PolygonOnClosedSurface"; }
     virtual Handle(BRep_CurveRepresentation) import() const;
 
   private:
@@ -215,8 +293,13 @@ public:
 
   class CurveOn2Surfaces : public CurveRepresentation
   {
+    friend class ShapePersistent_BRep;
+
   public:
     virtual void Read (StdObjMgt_ReadData& theReadData);
+    virtual void Write (StdObjMgt_WriteData& theWriteData) const;
+    virtual void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const;
+    virtual Standard_CString PName() const { return "PBRep_CurveOn2Surfaces"; }
     virtual Handle(BRep_CurveRepresentation) import() const;
 
   private:
@@ -229,12 +312,26 @@ public:
 private:
   class pTVertex : public pTBase
   {
+    friend class ShapePersistent_BRep;
+
   public:
     inline void Read (StdObjMgt_ReadData& theReadData)
     {
       pTBase::Read (theReadData);
       theReadData >> myTolerance >> myPnt >> myPoints;
     }
+    inline void Write (StdObjMgt_WriteData& theWriteData) const
+    {
+      pTBase::Write (theWriteData);
+      theWriteData << myTolerance << myPnt << myPoints;
+    }
+    inline void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const 
+    { 
+      pTBase::PChildren(theChildren);
+      theChildren.Append(myPoints);
+    }
+    inline Standard_CString PName() const 
+      { return "PBRep_TVertex"; }
 
   private:
     virtual Handle(TopoDS_TShape) createTShape() const;
@@ -247,12 +344,26 @@ private:
 
   class pTEdge : public pTBase
   {
+    friend class ShapePersistent_BRep;
+
   public:
     inline void Read (StdObjMgt_ReadData& theReadData)
     {
       pTBase::Read (theReadData);
       theReadData >> myTolerance >> myFlags >> myCurves;
     }
+    inline void Write (StdObjMgt_WriteData& theWriteData) const
+    {
+      pTBase::Write (theWriteData);
+      theWriteData << myTolerance << myFlags << myCurves;
+    }
+    inline void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const 
+    { 
+      pTBase::PChildren(theChildren);
+      theChildren.Append(myCurves);
+    }
+    inline Standard_CString PName() const 
+      { return "PBRep_TEdge"; }
 
   private:
     virtual Handle(TopoDS_TShape) createTShape() const;
@@ -265,6 +376,8 @@ private:
 
   class pTFace : public pTBase
   {
+    friend class ShapePersistent_BRep;
+
   public:
     inline void Read (StdObjMgt_ReadData& theReadData)
     {
@@ -272,6 +385,21 @@ private:
       theReadData >> mySurface >> myTriangulation >> myLocation;
       theReadData >> myTolerance >> myNaturalRestriction;
     }
+    inline void Write (StdObjMgt_WriteData& theWriteData) const
+    {
+      pTBase::Write (theWriteData);
+      theWriteData << mySurface << myTriangulation << myLocation;
+      theWriteData << myTolerance << myNaturalRestriction;
+    }
+    inline void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const 
+    {
+      pTBase::PChildren(theChildren);
+      theChildren.Append(mySurface);
+      theChildren.Append(myTriangulation);
+      myLocation.PChildren(theChildren);
+    }
+    inline Standard_CString PName() const
+      { return "PBRep_TFace"; }
 
   private:
     virtual Handle(TopoDS_TShape) createTShape() const;
@@ -292,6 +420,91 @@ public:
   typedef tObject1 <pTVertex> TVertex1;
   typedef tObject1 <pTEdge>   TEdge1;
   typedef tObject1 <pTFace>   TFace1;
+
+public:
+  //! Create a persistent object for a vertex
+  Standard_EXPORT static Handle(TVertex::pTObjectT) Translate (const TopoDS_Vertex& theVertex,
+                                                               StdObjMgt_TransientPersistentMap& theMap);
+  //! Create a persistent object for an edge
+  Standard_EXPORT static Handle(TEdge::pTObjectT) Translate (const TopoDS_Edge& theEdge,
+                                                             StdObjMgt_TransientPersistentMap& theMap,
+                                                             ShapePersistent_TriangleMode theTriangleMode);
+  //! Create a persistent object for a face
+  Standard_EXPORT static Handle(TFace::pTObjectT) Translate (const TopoDS_Face& theFace,
+                                                             StdObjMgt_TransientPersistentMap& theMap,
+                                                             ShapePersistent_TriangleMode theTriangleMode);
+  //! Create a persistent object for a point on a 3D curve
+  Standard_EXPORT static Handle(PointOnCurve) Translate(Standard_Real theParam, 
+                                                        const Handle(Geom_Curve)& theCurve, 
+                                                        const TopLoc_Location& theLoc, 
+                                                        StdObjMgt_TransientPersistentMap& theMap);
+  //! Create a persistent object for a point on a 3D curve on a surface
+  Standard_EXPORT static Handle(PointOnCurveOnSurface) Translate (Standard_Real theParam, 
+                                                                  const Handle(Geom2d_Curve)& theCurve, 
+                                                                  const Handle(Geom_Surface)& theSurf, 
+                                                                  const TopLoc_Location& theLoc,
+                                                                  StdObjMgt_TransientPersistentMap& theMap);
+  //! Create a persistent object for a point on a surface
+  Standard_EXPORT static Handle(PointOnSurface) Translate (Standard_Real theParam, 
+                                                           Standard_Real theParam2, 
+                                                           const Handle(Geom_Surface)& theSurf, 
+                                                           const TopLoc_Location& theLoc,
+                                                           StdObjMgt_TransientPersistentMap& theMap);
+  //! Create a persistent object for a curve on a surface
+  Standard_EXPORT static Handle(CurveOnSurface) Translate (const Handle(Geom2d_Curve)& theCurve, 
+                                                           const Standard_Real theFirstParam,
+                                                           const Standard_Real theLastParam, 
+                                                           const Handle(Geom_Surface)& theSurf, 
+                                                           const TopLoc_Location& theLoc,
+                                                           StdObjMgt_TransientPersistentMap& theMap);
+  //! Create a persistent object for a curve on a closed surface
+  Standard_EXPORT static Handle(CurveOnClosedSurface) Translate (const Handle(Geom2d_Curve)& theCurve, 
+                                                                 const Handle(Geom2d_Curve)& theCurve2,
+                                                                 const Standard_Real theFirstParam,
+                                                                 const Standard_Real theLastParam, 
+                                                                 const Handle(Geom_Surface)& theSurf,
+                                                                 const TopLoc_Location& theLoc, 
+                                                                 const GeomAbs_Shape theContinuity,
+                                                                 StdObjMgt_TransientPersistentMap& theMap);
+  //! Create a persistent object for a curve on two surfaces
+  Standard_EXPORT static Handle(CurveOn2Surfaces) Translate (const Handle(Geom_Surface)& theSurf, 
+                                                             const Handle(Geom_Surface)& theSurf2,
+                                                             const TopLoc_Location& theLoc, 
+                                                             const TopLoc_Location& theLoc2,
+                                                             const GeomAbs_Shape theContinuity,
+                                                             StdObjMgt_TransientPersistentMap& theMap);
+  //! Create a persistent object for a 3D curve
+  Standard_EXPORT static Handle(Curve3D) Translate (const Handle(Geom_Curve)& theCurve,
+                                                    const Standard_Real theFirstParam, 
+                                                    const Standard_Real theLastParam,
+                                                    const TopLoc_Location& theLoc,
+                                                    StdObjMgt_TransientPersistentMap& theMap);
+  //! Create a persistent object for a 3D polygon
+  Standard_EXPORT static Handle(Polygon3D) Translate (const Handle(Poly_Polygon3D)& thePoly,
+                                                      const TopLoc_Location& theLoc,
+                                                      StdObjMgt_TransientPersistentMap& theMap);
+  //! Create a persistent object for a polygon on a closed surface
+  Standard_EXPORT static Handle(PolygonOnClosedSurface) Translate (const Handle(Poly_Polygon2D)& thePoly, 
+                                                                   const Handle(Poly_Polygon2D)& thePoly2,
+                                                                   const Handle(Geom_Surface)& theSurf, 
+                                                                   const TopLoc_Location& theLoc,
+                                                                   StdObjMgt_TransientPersistentMap& theMap);
+  //! Create a persistent object for a polygon on a surface
+  Standard_EXPORT static Handle(PolygonOnSurface) Translate (const Handle(Poly_Polygon2D)& thePoly, 
+                                                             const Handle(Geom_Surface)& theSurf,
+                                                             const TopLoc_Location& theLoc, 
+                                                             StdObjMgt_TransientPersistentMap& theMap);
+  //! Create a persistent object for a polygon on a surface
+  Standard_EXPORT static Handle(PolygonOnClosedTriangulation) Translate (const Handle(Poly_PolygonOnTriangulation)& thePolyOnTriang,
+                                                                         const Handle(Poly_PolygonOnTriangulation)& thePolyOnTriang2,
+                                                                         const Handle(Poly_Triangulation)& thePolyTriang,
+                                                                         const TopLoc_Location& theLoc,
+                                                                         StdObjMgt_TransientPersistentMap& theMap);
+  //! Create a persistent object for a polygon on a surface
+  Standard_EXPORT static Handle(PolygonOnTriangulation) Translate (const Handle(Poly_PolygonOnTriangulation)& thePolyOnTriang,
+                                                                   const Handle(Poly_Triangulation)& thePolyTriang,
+                                                                   const TopLoc_Location& theLoc,
+                                                                   StdObjMgt_TransientPersistentMap& theMap);
 };
 
 #endif
index b5d1505..ef8687e 100644 (file)
 // Alternatively, this file may be used under the terms of Open CASCADE
 // commercial license or contractual agreement.
 
+#include <Standard_NullObject.hxx>
+
 #include <ShapePersistent_Geom.hxx>
+#include <ShapePersistent_Geom_Curve.hxx>
+#include <ShapePersistent_Geom_Surface.hxx>
 #include <StdObject_gp_Axes.hxx>
 #include <StdObject_gp_Vectors.hxx>
 
 void ShapePersistent_Geom::Geometry::Read (StdObjMgt_ReadData&) {}
 
 //=======================================================================
-//function : Read
-//purpose  : Read persistent data from a file
+//function : Write
+//purpose  : Write persistent data to a file
 //=======================================================================
-template<>
-void ShapePersistent_Geom::instance<ShapePersistent_Geom::AxisPlacement,
-                                    Geom_Axis2Placement>
-  ::Read (StdObjMgt_ReadData& theReadData)
-{
-  gp_Ax1 anAxis;
-  gp_Dir anXDirection;
+void ShapePersistent_Geom::Geometry::Write (StdObjMgt_WriteData&) const {}
 
-  theReadData >> anAxis >> anXDirection;
+//=======================================================================
+//function : PChildren
+//purpose  : Gets persistent objects
+//=======================================================================
+void ShapePersistent_Geom::Geometry::PChildren (SequenceOfPersistent&) const
+{ 
+}
 
-  myTransient = new Geom_Axis2Placement (anAxis.Location(),
-                                         anAxis.Direction(),
-                                         anXDirection);
+//=======================================================================
+//function : Translate
+//purpose  : Create a persistent object for a curve
+//=======================================================================
+Handle(ShapePersistent_Geom::Curve) 
+ShapePersistent_Geom::Translate (const Handle(Geom_Curve)& theCurve,
+                                 StdObjMgt_TransientPersistentMap& theMap)
+{
+  Handle(Curve) aPC;
+  if (!theCurve.IsNull())
+  {
+    if (theMap.IsBound(theCurve))
+      aPC = Handle(Curve)::DownCast(theMap.Find(theCurve));
+    else
+    {
+      Handle(Standard_Type) aCT = theCurve->DynamicType();
+      if (aCT == STANDARD_TYPE(Geom_Line)) {
+        aPC = ShapePersistent_Geom_Curve::Translate(Handle(Geom_Line)::DownCast(theCurve), theMap);
+      }
+      else if (aCT == STANDARD_TYPE(Geom_Circle)) {
+        aPC = ShapePersistent_Geom_Curve::Translate(Handle(Geom_Circle)::DownCast(theCurve), theMap);
+      }
+      else if (aCT == STANDARD_TYPE(Geom_Ellipse)) {
+        aPC = ShapePersistent_Geom_Curve::Translate(Handle(Geom_Ellipse)::DownCast(theCurve), theMap);
+      }
+      else if (aCT == STANDARD_TYPE(Geom_Hyperbola)) {
+        aPC = ShapePersistent_Geom_Curve::Translate(Handle(Geom_Hyperbola)::DownCast(theCurve), theMap);
+      }
+      else if (aCT == STANDARD_TYPE(Geom_Parabola)) {
+        aPC = ShapePersistent_Geom_Curve::Translate(Handle(Geom_Parabola)::DownCast(theCurve), theMap);
+      }
+      else if (aCT == STANDARD_TYPE(Geom_BezierCurve)) {
+        aPC = ShapePersistent_Geom_Curve::Translate(Handle(Geom_BezierCurve)::DownCast(theCurve), theMap);
+      }
+      else if (aCT == STANDARD_TYPE(Geom_BSplineCurve)) {
+        aPC = ShapePersistent_Geom_Curve::Translate(Handle(Geom_BSplineCurve)::DownCast(theCurve), theMap);
+      }
+      else if (aCT == STANDARD_TYPE(Geom_TrimmedCurve)) {
+        aPC = ShapePersistent_Geom_Curve::Translate(Handle(Geom_TrimmedCurve)::DownCast(theCurve), theMap);
+      }
+      else if (aCT == STANDARD_TYPE(Geom_OffsetCurve)) {
+        aPC = ShapePersistent_Geom_Curve::Translate(Handle(Geom_OffsetCurve)::DownCast(theCurve), theMap);
+      }
+      else {
+        Standard_NullObject::Raise("No mapping for the current Transient Curve");
+      }
+      theMap.Bind(theCurve, aPC);
+    }
+  }
+  return aPC;
+}
+
+//=======================================================================
+//function : Translate
+//purpose  : Create a persistent object for a surface
+//=======================================================================
+Handle(ShapePersistent_Geom::Surface) 
+ShapePersistent_Geom::Translate(const Handle(Geom_Surface)& theSurf,
+                                StdObjMgt_TransientPersistentMap& theMap)
+{
+  Handle(Surface) aPS;
+  if (!theSurf.IsNull())
+  {
+    if (theMap.IsBound(theSurf))
+      aPS = Handle(Surface)::DownCast(theMap.Find(theSurf));
+    else
+    {
+      Handle(Standard_Type) aST = theSurf->DynamicType();
+      if (aST == STANDARD_TYPE(Geom_Plane)) {
+        aPS = ShapePersistent_Geom_Surface::Translate(Handle(Geom_Plane)::DownCast(theSurf), theMap);
+      }
+      else if (aST == STANDARD_TYPE(Geom_CylindricalSurface)) {
+        aPS = ShapePersistent_Geom_Surface::Translate(Handle(Geom_CylindricalSurface)::DownCast(theSurf), theMap);
+      }
+      else if (aST == STANDARD_TYPE(Geom_ConicalSurface)) {
+        aPS = ShapePersistent_Geom_Surface::Translate(Handle(Geom_ConicalSurface)::DownCast(theSurf), theMap);
+      }
+      else if (aST == STANDARD_TYPE(Geom_SphericalSurface)) {
+        aPS = ShapePersistent_Geom_Surface::Translate(Handle(Geom_SphericalSurface)::DownCast(theSurf), theMap);
+      }
+      else if (aST == STANDARD_TYPE(Geom_ToroidalSurface)) {
+        aPS = ShapePersistent_Geom_Surface::Translate(Handle(Geom_ToroidalSurface)::DownCast(theSurf), theMap);
+      }
+      else if (aST == STANDARD_TYPE(Geom_SurfaceOfLinearExtrusion)) {
+        aPS = ShapePersistent_Geom_Surface::Translate(Handle(Geom_SurfaceOfLinearExtrusion)::DownCast(theSurf), theMap);
+      }
+      else if (aST == STANDARD_TYPE(Geom_SurfaceOfRevolution)) {
+        aPS = ShapePersistent_Geom_Surface::Translate(Handle(Geom_SurfaceOfRevolution)::DownCast(theSurf), theMap);
+      }
+      else if (aST == STANDARD_TYPE(Geom_BezierSurface)) {
+        aPS = ShapePersistent_Geom_Surface::Translate(Handle(Geom_BezierSurface)::DownCast(theSurf), theMap);
+      }
+      else if (aST == STANDARD_TYPE(Geom_BSplineSurface)) {
+        aPS = ShapePersistent_Geom_Surface::Translate(Handle(Geom_BSplineSurface)::DownCast(theSurf), theMap);
+      }
+      else if (aST == STANDARD_TYPE(Geom_RectangularTrimmedSurface)) {
+        aPS = ShapePersistent_Geom_Surface::Translate(Handle(Geom_RectangularTrimmedSurface)::DownCast(theSurf), theMap);
+      }
+      else if (aST == STANDARD_TYPE(Geom_OffsetSurface)) {
+        aPS = ShapePersistent_Geom_Surface::Translate(Handle(Geom_OffsetSurface)::DownCast(theSurf), theMap);
+      }
+      else {
+        Standard_NullObject::Raise("No mapping for the current Transient Surface");
+      }
+      theMap.Bind(theSurf, aPS);
+    }
+  }
+  return aPS;
 }
index b0ec0d3..6fcd32c 100644 (file)
 #ifndef _ShapePersistent_Geom_HeaderFile
 #define _ShapePersistent_Geom_HeaderFile
 
+#include <Standard_NotImplemented.hxx>
+#include <Standard_NullObject.hxx>
+
+#include <StdObjMgt_WriteData.hxx>
 #include <StdObjMgt_SharedObject.hxx>
+#include <StdObjMgt_TransientPersistentMap.hxx>
 
 #include <StdObject_gp_Vectors.hxx>
 #include <StdObject_gp_Axes.hxx>
@@ -32,8 +37,7 @@
 #include <Geom_Curve.hxx>
 #include <Geom_Surface.hxx>
 
-
-class ShapePersistent_Geom : protected StdObjMgt_SharedObject
+class ShapePersistent_Geom : public StdObjMgt_SharedObject
 {
 public:
   class Geometry : public StdObjMgt_Persistent
@@ -41,11 +45,32 @@ public:
   public:
     //! Read persistent data from a file.
     Standard_EXPORT virtual void Read (StdObjMgt_ReadData& theReadData);
+    //! Write persistent data to a file.
+    Standard_EXPORT virtual void Write (StdObjMgt_WriteData& theWriteData) const;
+    //! Gets persistent objects
+    Standard_EXPORT virtual void PChildren(SequenceOfPersistent& theChildren) const;
+    //! Returns persistent type name
+    Standard_EXPORT virtual Standard_CString PName() const { return "PGeom_Geometry"; }
   };
 
 protected:
   template <class Transient>
-  struct geometryBase : DelayedBase<Geometry, Transient> {};
+  struct geometryBase : public DelayedBase<Geometry, Transient> 
+  {
+    //! Write persistent data to a file.
+    Standard_EXPORT virtual void Write (StdObjMgt_WriteData&) const
+    {
+      Standard_NotImplemented::Raise("ShapePersistent_Geom::geometryBase::Write - not implemented");
+    }
+    //! Gets persistent child objects
+    Standard_EXPORT virtual void PChildren (StdObjMgt_Persistent::SequenceOfPersistent&) const { }
+    //! Returns persistent type name
+    Standard_EXPORT virtual Standard_CString PName() const
+    { 
+      Standard_NotImplemented::Raise("ShapePersistent_Geom::geometryBase::PName - not implemented");
+      return ""; 
+    }
+  };
 
   template <class Base, class PData>
   class subBase : public Base
@@ -54,6 +79,20 @@ protected:
     //! Read persistent data from a file.
     Standard_EXPORT virtual void Read (StdObjMgt_ReadData& theReadData)
       { PData().Read (theReadData); }
+    //! Write persistent data to a file.
+    Standard_EXPORT virtual void Write (StdObjMgt_WriteData& theWriteData) const
+      { PData().Write(theWriteData); }
+    //! Gets persistent child objects
+    Standard_EXPORT virtual void PChildren (StdObjMgt_Persistent::SequenceOfPersistent&) const
+    {
+      Standard_NotImplemented::Raise("ShapePersistent_Geom::subBase::PChildren - not implemented");
+    }
+    //! Returns persistent type name
+    Standard_EXPORT virtual Standard_CString PName() const
+    { 
+      Standard_NotImplemented::Raise("ShapePersistent_Geom::subBase::PName - not implemented");
+      return ""; 
+    }
   };
 
   template <class Base, class GpData>
@@ -61,15 +100,29 @@ protected:
   {
   public:
     //! Read persistent data from a file.
-    Standard_EXPORT virtual void Read (StdObjMgt_ReadData& theReadData)
+    Standard_EXPORT virtual void Read (StdObjMgt_ReadData&) { }
+    //! Write persistent data to a file.
+    Standard_EXPORT virtual void Write (StdObjMgt_WriteData&) const { }
+    //! Gets persistent child objects
+    Standard_EXPORT virtual void PChildren (StdObjMgt_Persistent::SequenceOfPersistent&) const { }
+    //! Returns persistent type name
+    Standard_EXPORT virtual Standard_CString PName() const
     {
-      GpData aData;
-      theReadData >> aData;
+      Standard_NotImplemented::Raise("ShapePersistent_Geom::subBase_gp::PName - not implemented");
+      return "";
     }
   };
 
   template <class Base>
-  struct subBase_empty : Base {};
+  struct subBase_empty : Base  
+  { 
+    //! Returns persistent type name
+    Standard_EXPORT virtual Standard_CString PName() const
+    {
+      Standard_NotImplemented::Raise("ShapePersistent_Geom::subBase_empty::PName - not implemented");
+      return "";
+    }
+  };
 
   template <class Base, class Target, class Data = void>
   class instance : public Base
@@ -80,7 +133,20 @@ protected:
     {
       Data aData;
       theReadData >> aData;
-      this->myTransient = new Target (aData);
+      this->myTransient = new Target(aData);
+    }
+    //! Gets persistent child objects
+    Standard_EXPORT virtual void PChildren(StdObjMgt_Persistent::SequenceOfPersistent&) const { }
+    //! Write persistent data to a file.
+    Standard_EXPORT virtual void Write(StdObjMgt_WriteData&) const
+    {
+      Standard_NotImplemented::Raise("ShapePersistent_Geom::instance::Write - not implemented");
+    }
+    //! Returns persistent type name
+    Standard_EXPORT virtual Standard_CString PName() const
+    {
+      Standard_NotImplemented::Raise("ShapePersistent_Geom::instance::PName - not implemented");
+      return "";
     }
   };
 
@@ -105,11 +171,203 @@ public:
 
   typedef geometryBase<Geom_Curve>                             Curve;
   typedef geometryBase<Geom_Surface>                           Surface;
+
+public:
+  //! Create a persistent object for a curve
+  Standard_EXPORT static Handle(Curve) Translate (const Handle(Geom_Curve)& theCurve,
+                                                  StdObjMgt_TransientPersistentMap& theMap);
+  //! Create a persistent object for a curve
+  Standard_EXPORT static Handle(Surface) Translate (const Handle(Geom_Surface)& theSurf,
+                                                    StdObjMgt_TransientPersistentMap& theMap);
 };
 
+//=======================================================================
+// Point 
+//=======================================================================
+
+template<>
+inline Standard_CString ShapePersistent_Geom::subBase_empty<ShapePersistent_Geom::basic>
+  ::PName() const { return "PGeom_Point"; }
+
+//=======================================================================
+// CartesianPoint
+//=======================================================================
+
+template<>
+inline Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom::Point,
+                                                       Geom_CartesianPoint,
+                                                      gp_Pnt>
+  ::PName() const { return "PGeom_CartesianPoint"; }
+
+template<>
+inline void ShapePersistent_Geom::instance<ShapePersistent_Geom::Point,
+                                          Geom_CartesianPoint,
+                                          gp_Pnt>
+  ::Write(StdObjMgt_WriteData& theWriteData) const
+{
+  Handle(Geom_CartesianPoint) aMyGeom =
+    Handle(Geom_CartesianPoint)::DownCast(myTransient);
+  theWriteData << aMyGeom->Pnt();
+}
+
+//=======================================================================
+// Vector
+//=======================================================================
+
+template<>
+inline Standard_CString ShapePersistent_Geom::subBase_gp<ShapePersistent_Geom::basic,
+                                                        gp_Vec>
+  ::PName() const { return "PGeom_Vector"; }
+
+//=======================================================================
+// Direction
+//=======================================================================
+
+template<>
+inline Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom::Direction,
+                                                      Geom_Direction,
+                                                      gp_Dir>
+  ::PName() const { return "PGeom_Direction"; }
+
+template<>
+inline void ShapePersistent_Geom::instance<ShapePersistent_Geom::Direction,
+                                          Geom_Direction,
+                                          gp_Dir>
+  ::Write(StdObjMgt_WriteData& theWriteData) const
+{
+  Handle(Geom_Direction) aMyGeom =
+    Handle(Geom_Direction)::DownCast(myTransient);
+  theWriteData << aMyGeom->Dir();
+}
+
+//=======================================================================
+// VectorWithMagnitude
+//=======================================================================
+
+template<>
+inline Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom::VectorWithMagnitude,
+                                                      Geom_VectorWithMagnitude,
+                                                      gp_Vec>
+  ::PName() const { return "PGeom_VectorWithMagnitude"; }
+
+template<>
+inline void ShapePersistent_Geom::instance<ShapePersistent_Geom::VectorWithMagnitude,
+                                          Geom_VectorWithMagnitude,
+                                          gp_Vec>
+  ::Write(StdObjMgt_WriteData& theWriteData) const
+{
+  Handle(Geom_VectorWithMagnitude) aMyGeom =
+    Handle(Geom_VectorWithMagnitude)::DownCast(myTransient);
+  theWriteData << aMyGeom->Vec();
+}
+
+//=======================================================================
+// AxisPlacement 
+//=======================================================================
+
+template<>
+inline Standard_CString ShapePersistent_Geom::subBase_gp<ShapePersistent_Geom::basic,
+                                                        gp_Ax1>
+  ::PName() const { return "PGeom_AxisPlacement"; }
+
+//=======================================================================
+// Axis1Placement
+//=======================================================================
+
+template<>
+inline Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom::Axis1Placement,
+                                                      Geom_Axis1Placement,
+                                                      gp_Ax1>
+  ::PName() const { return "PGeom_Axis1Placement"; }
+
+template<>
+inline void ShapePersistent_Geom::instance<ShapePersistent_Geom::Axis1Placement,
+                                          Geom_Axis1Placement,
+                                          gp_Ax1>
+  ::Write(StdObjMgt_WriteData& theWriteData) const
+{
+  Handle(Geom_Axis1Placement) aMyGeom =
+    Handle(Geom_Axis1Placement)::DownCast(myTransient);
+  write(theWriteData, aMyGeom->Ax1());
+}
+
+//=======================================================================
+// Axis2Placement 
+//=======================================================================
+
+template<>
+inline Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom::AxisPlacement,
+                                                      Geom_Axis2Placement>
+  ::PName() const { return "PGeom_Axis2Placement"; }
+
+template<>
+inline void ShapePersistent_Geom::instance<ShapePersistent_Geom::AxisPlacement,
+                                          Geom_Axis2Placement>
+  ::Read (StdObjMgt_ReadData& theReadData)
+{
+  gp_Ax1 anAxis;
+  gp_Dir anXDirection;
+
+  theReadData >> anAxis >> anXDirection;
+
+  myTransient = new Geom_Axis2Placement(anAxis.Location(),
+    anAxis.Direction(),
+    anXDirection);
+}
+
+template<>
+inline void ShapePersistent_Geom::instance<ShapePersistent_Geom::AxisPlacement,
+                                          Geom_Axis2Placement>
+  ::Write (StdObjMgt_WriteData& theWriteData) const
+{
+  Handle(Geom_Axis2Placement) aMyGeom =
+    Handle(Geom_Axis2Placement)::DownCast(myTransient);
+  const gp_Ax1& anAxis = aMyGeom->Axis();
+  const gp_Dir& anXDirection = aMyGeom->Direction();
+  write(theWriteData, anAxis) << anXDirection;
+}
+
+//=======================================================================
+// Transformation
+//=======================================================================
+
+template<>
+inline Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom::Transformation,
+                                                      Geom_Transformation,
+                                                      gp_Trsf>
+  ::PName() const { return "PGeom_Transformation"; }
+
+template<>
+inline void ShapePersistent_Geom::instance<ShapePersistent_Geom::Transformation,
+                                          Geom_Transformation,
+                                          gp_Trsf>
+  ::Write (StdObjMgt_WriteData& theWriteData) const
+{
+  theWriteData << myTransient->Trsf();
+}
+
+//=======================================================================
+// Geometry
+//=======================================================================
+
+template<>
+inline Standard_CString ShapePersistent_Geom::geometryBase<Geom_Geometry>
+  ::PName() const { return "PGeom_Geometry"; }
+
+//=======================================================================
+// Curve
+//=======================================================================
+
+template<>
+inline Standard_CString ShapePersistent_Geom::geometryBase<Geom_Curve>
+  ::PName() const { return "PGeom_Curve"; }
+
+//=======================================================================
+// Surface
+//=======================================================================
+
 template<>
-void ShapePersistent_Geom::instance<ShapePersistent_Geom::AxisPlacement,
-                                    Geom_Axis2Placement>
-  ::Read (StdObjMgt_ReadData& theReadData);
+inline Standard_CString ShapePersistent_Geom::geometryBase<Geom_Surface>
+  ::PName() const { return "PGeom_Surface"; }
 
 #endif
diff --git a/src/ShapePersistent/ShapePersistent_Geom2d.cxx b/src/ShapePersistent/ShapePersistent_Geom2d.cxx
new file mode 100644 (file)
index 0000000..45735b1
--- /dev/null
@@ -0,0 +1,185 @@
+
+#include <Standard_NullObject.hxx>
+
+#include <ShapePersistent_Geom2d.hxx>
+#include <ShapePersistent_Geom2d_Curve.hxx>
+
+#include <Geom2d_BezierCurve.hxx>
+#include <Geom2d_BSplineCurve.hxx>
+#include <Geom2d_TrimmedCurve.hxx>
+#include <Geom2d_OffsetCurve.hxx>
+
+//=======================================================================
+// Geometry
+//=======================================================================
+template<>
+Standard_CString ShapePersistent_Geom::geometryBase<Geom2d_Geometry>
+  ::PName() const { return "PGeom2d_Geometry"; }
+
+//=======================================================================
+// Point
+//=======================================================================
+template<>
+Standard_CString ShapePersistent_Geom::subBase_empty<ShapePersistent_Geom2d::geometryBase<Geom2d_Geometry> >
+  ::PName() const { return "PGeom2d_Point"; }
+
+//=======================================================================
+// CartesianPoint
+//=======================================================================
+template<>
+Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom2d::Point,
+                                                  Geom2d_CartesianPoint,
+                                                  gp_Pnt2d>
+  ::PName() const { return "PGeom2d_CartesianPoint"; }
+
+template<>
+void ShapePersistent_Geom::instance<ShapePersistent_Geom2d::Point,
+                                      Geom2d_CartesianPoint,
+                                      gp_Pnt2d>
+::Write(StdObjMgt_WriteData& theWriteData) const
+{
+  Handle(Geom2d_CartesianPoint) aMyGeom =
+    Handle(Geom2d_CartesianPoint)::DownCast(myTransient);
+  theWriteData << aMyGeom->Pnt2d();
+}
+
+//=======================================================================
+// Direction
+//=======================================================================
+template<>
+Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom2d::Direction,
+                                                  Geom2d_Direction,
+                                                  gp_Dir2d>
+  ::PName() const { return "PGeom2d_Direction"; }
+
+template<>
+void ShapePersistent_Geom::instance<ShapePersistent_Geom2d::Direction,
+                                    Geom2d_Direction,
+                                    gp_Dir2d>
+::Write(StdObjMgt_WriteData& theWriteData) const
+{
+  Handle(Geom2d_Direction) aMyGeom =
+    Handle(Geom2d_Direction)::DownCast(myTransient);
+  theWriteData << aMyGeom->Dir2d();
+}
+
+//=======================================================================
+// VectorWithMagnitude
+//=======================================================================
+template<>
+Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom2d::VectorWithMagnitude,
+                                                  Geom2d_VectorWithMagnitude,
+                                                  gp_Vec2d>
+  ::PName() const { return "PGeom2d_VectorWithMagnitude"; }
+
+template<>
+void ShapePersistent_Geom::instance<ShapePersistent_Geom2d::VectorWithMagnitude,
+                                      Geom2d_VectorWithMagnitude,
+                                      gp_Vec2d>
+::Write(StdObjMgt_WriteData& theWriteData) const
+{
+  Handle(Geom2d_VectorWithMagnitude) aMyGeom =
+    Handle(Geom2d_VectorWithMagnitude)::DownCast(myTransient);
+  theWriteData << aMyGeom->Vec2d();
+}
+
+//=======================================================================
+// AxisPlacement
+//=======================================================================
+template<>
+Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom2d::AxisPlacement,
+                                                  Geom2d_AxisPlacement,
+                                                  gp_Ax2d>
+  ::PName() const { return "PGeom2d_AxisPlacement"; }
+
+template<>
+void ShapePersistent_Geom::instance<ShapePersistent_Geom2d::AxisPlacement,
+                                      Geom2d_AxisPlacement,
+                                      gp_Ax2d>
+::Write(StdObjMgt_WriteData& theWriteData) const
+{
+  Handle(Geom2d_AxisPlacement) aMyGeom =
+    Handle(Geom2d_AxisPlacement)::DownCast(myTransient);
+  write(theWriteData, aMyGeom->Ax2d());
+}
+
+//=======================================================================
+// Transformation
+//=======================================================================
+template<>
+Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom2d::Transformation,
+                                                  Geom2d_Transformation,
+                                                  gp_Trsf2d>
+  ::PName() const { return "PGeom2d_Transformation"; }
+
+template<>
+void ShapePersistent_Geom::instance<ShapePersistent_Geom2d::Transformation,
+                                    Geom2d_Transformation,
+                                    gp_Trsf2d>
+  ::PChildren(StdObjMgt_Persistent::SequenceOfPersistent&) const
+{
+}
+
+template<>
+void ShapePersistent_Geom2d::instance<ShapePersistent_Geom2d::Transformation,
+                                      Geom2d_Transformation,
+                                      gp_Trsf2d>
+::Write(StdObjMgt_WriteData& theWriteData) const
+{
+  theWriteData << myTransient->Trsf2d();
+}
+
+//=======================================================================
+// Curve
+//=======================================================================
+template<>
+Standard_CString ShapePersistent_Geom::geometryBase<Geom2d_Curve>
+  ::PName() const { return "PGeom2d_Curve"; }
+
+Handle(ShapePersistent_Geom2d::Curve)
+ShapePersistent_Geom2d::Translate(const Handle(Geom2d_Curve)& theCurve,
+                                  StdObjMgt_TransientPersistentMap& theMap)
+{
+  Handle(ShapePersistent_Geom2d::Curve) aPC;
+  if (!theCurve.IsNull())
+  {
+    if (theMap.IsBound(theCurve))
+      aPC = Handle(ShapePersistent_Geom2d::Curve)::DownCast(theMap.Find(theCurve));
+    else
+    {
+      Handle(Standard_Type) aCT = theCurve->DynamicType();
+      if (aCT == STANDARD_TYPE(Geom2d_Line)) {
+        aPC = ShapePersistent_Geom2d_Curve::Translate(Handle(Geom2d_Line)::DownCast(theCurve), theMap);
+      }
+      else if (aCT == STANDARD_TYPE(Geom2d_Circle)) {
+        aPC = ShapePersistent_Geom2d_Curve::Translate(Handle(Geom2d_Circle)::DownCast(theCurve), theMap);
+      }
+      else if (aCT == STANDARD_TYPE(Geom2d_Ellipse)) {
+        aPC = ShapePersistent_Geom2d_Curve::Translate(Handle(Geom2d_Ellipse)::DownCast(theCurve), theMap);
+      }
+      else if (aCT == STANDARD_TYPE(Geom2d_Hyperbola)) {
+        aPC = ShapePersistent_Geom2d_Curve::Translate(Handle(Geom2d_Hyperbola)::DownCast(theCurve), theMap);
+      }
+      else if (aCT == STANDARD_TYPE(Geom2d_Parabola)) {
+        aPC = ShapePersistent_Geom2d_Curve::Translate(Handle(Geom2d_Parabola)::DownCast(theCurve), theMap);
+      }
+      else if (aCT == STANDARD_TYPE(Geom2d_BezierCurve)) {
+        aPC = ShapePersistent_Geom2d_Curve::Translate(Handle(Geom2d_BezierCurve)::DownCast(theCurve), theMap);
+      }
+      else if (aCT == STANDARD_TYPE(Geom2d_BSplineCurve)) {
+        aPC = ShapePersistent_Geom2d_Curve::Translate(Handle(Geom2d_BSplineCurve)::DownCast(theCurve), theMap);
+      }
+      else if (aCT == STANDARD_TYPE(Geom2d_TrimmedCurve)) {
+        aPC = ShapePersistent_Geom2d_Curve::Translate(Handle(Geom2d_TrimmedCurve)::DownCast(theCurve), theMap);
+      }
+      else if (aCT == STANDARD_TYPE(Geom2d_OffsetCurve)) {
+        aPC = ShapePersistent_Geom2d_Curve::Translate(Handle(Geom2d_OffsetCurve)::DownCast(theCurve), theMap);
+      }
+      else {
+        Standard_NullObject::Raise("No mapping for the current Transient Curve");
+      }
+      theMap.Bind(theCurve, aPC);
+    }
+  }
+  return aPC;
+}
index cd351ec..67b8131 100644 (file)
@@ -15,6 +15,7 @@
 #ifndef _ShapePersistent_Geom2d_HeaderFile
 #define _ShapePersistent_Geom2d_HeaderFile
 
+#include <StdObjMgt_TransientPersistentMap.hxx>
 #include <ShapePersistent_Geom.hxx>
 
 #include <Geom2d_CartesianPoint.hxx>
@@ -24,8 +25,7 @@
 #include <Geom2d_Transformation.hxx>
 #include <Geom2d_Curve.hxx>
 
-
-class ShapePersistent_Geom2d : protected ShapePersistent_Geom
+class ShapePersistent_Geom2d : public ShapePersistent_Geom
 {
   typedef geometryBase<Geom2d_Geometry> basic;
 
@@ -46,6 +46,114 @@ public:
                     gp_Trsf2d>                                   Transformation;
 
   typedef geometryBase<Geom2d_Curve>                             Curve;
+
+public:
+  //! Create a persistent object for a curve
+  Standard_EXPORT static Handle(Curve) Translate (const Handle(Geom2d_Curve)& theCurve,
+                                                  StdObjMgt_TransientPersistentMap& theMap);
 };
 
+//=======================================================================
+// Geometry
+//=======================================================================
+template<>
+Standard_CString ShapePersistent_Geom::geometryBase<Geom2d_Geometry>
+  ::PName() const;
+
+//=======================================================================
+// Point
+//=======================================================================
+template<>
+Standard_CString ShapePersistent_Geom::subBase_empty<
+  ShapePersistent_Geom2d::geometryBase<Geom2d_Geometry> >
+  ::PName() const;
+
+//=======================================================================
+// CartesianPoint
+//=======================================================================
+template<>
+Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom2d::Point,
+                                                  Geom2d_CartesianPoint,
+                                                  gp_Pnt2d>
+  ::PName() const;
+
+template<>
+void ShapePersistent_Geom::instance<ShapePersistent_Geom2d::Point,
+                                      Geom2d_CartesianPoint,
+                                      gp_Pnt2d>
+  ::Write(StdObjMgt_WriteData& theWriteData) const;
+
+//=======================================================================
+// Direction
+//=======================================================================
+template<>
+Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom2d::Direction,
+                                                  Geom2d_Direction,
+                                                  gp_Dir2d>
+  ::PName() const;
+
+template<>
+void ShapePersistent_Geom::instance<ShapePersistent_Geom2d::Direction,
+                                      Geom2d_Direction,
+                                      gp_Dir2d>
+  ::Write(StdObjMgt_WriteData& theWriteData) const;
+
+//=======================================================================
+// VectorWithMagnitude
+//=======================================================================
+template<>
+Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom2d::VectorWithMagnitude,
+                                                  Geom2d_VectorWithMagnitude,
+                                                  gp_Vec2d>
+  ::PName() const;
+
+template<>
+void ShapePersistent_Geom::instance<ShapePersistent_Geom2d::VectorWithMagnitude,
+                                      Geom2d_VectorWithMagnitude,
+                                      gp_Vec2d>
+  ::Write(StdObjMgt_WriteData& theWriteData) const;
+
+//=======================================================================
+// AxisPlacement
+//=======================================================================
+template<>
+Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom2d::AxisPlacement,
+                                                  Geom2d_AxisPlacement,
+                                                  gp_Ax2d>
+  ::PName() const;
+
+template<>
+void ShapePersistent_Geom::instance<ShapePersistent_Geom2d::AxisPlacement,
+                                      Geom2d_AxisPlacement,
+                                      gp_Ax2d>
+  ::Write(StdObjMgt_WriteData& theWriteData) const;
+
+//=======================================================================
+// Transformation
+//=======================================================================
+template<>
+Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom2d::Transformation,
+                                                  Geom2d_Transformation,
+                                                  gp_Trsf2d>
+  ::PName() const;
+
+template<>
+void ShapePersistent_Geom::instance<ShapePersistent_Geom2d::Transformation,
+                                    Geom2d_Transformation,
+                                    gp_Trsf2d>
+  ::PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const;
+
+template<>
+void ShapePersistent_Geom::instance<ShapePersistent_Geom2d::Transformation,
+                                      Geom2d_Transformation,
+                                      gp_Trsf2d>
+  ::Write(StdObjMgt_WriteData& theWriteData) const;
+
+//=======================================================================
+// Curve
+//=======================================================================
+template<>
+Standard_CString ShapePersistent_Geom2d::geometryBase<Geom2d_Curve>
+  ::PName() const;
+
 #endif
index 92f9bd0..8aaa8cd 100644 (file)
@@ -11,6 +11,8 @@
 // Alternatively, this file may be used under the terms of Open CASCADE
 // commercial license or contractual agreement.
 
+#include <Standard_NullObject.hxx>
+
 #include <ShapePersistent_Geom2d_Curve.hxx>
 
 #include <Geom2d_BezierCurve.hxx>
@@ -74,3 +76,308 @@ Handle(Geom2d_Curve) ShapePersistent_Geom2d_Curve::pOffset::Import() const
 
   return new Geom2d_OffsetCurve (myBasisCurve->Import(), myOffsetValue);
 }
+
+//=======================================================================
+// Line
+//=======================================================================
+template<>
+Standard_CString ShapePersistent_Geom2d_Curve::instance<ShapePersistent_Geom2d::Curve,
+                                                        Geom2d_Line,
+                                                        gp_Ax2d>
+  ::PName() const { return "PGeom2d_Line"; }
+
+template<>
+void ShapePersistent_Geom2d_Curve::instance<ShapePersistent_Geom2d::Curve,
+                                            Geom2d_Line,
+                                            gp_Ax2d>
+  ::Write(StdObjMgt_WriteData& theWriteData) const
+{
+  Handle(Geom2d_Line) aMyGeom =
+    Handle(Geom2d_Line)::DownCast(myTransient);
+  write(theWriteData, aMyGeom->Position());
+}
+
+Handle(ShapePersistent_Geom2d::Curve) 
+ShapePersistent_Geom2d_Curve::Translate(const Handle(Geom2d_Line)& theCurve,
+                                        StdObjMgt_TransientPersistentMap& theMap)
+{
+  Handle(ShapePersistent_Geom2d::Curve) aPC;
+  if (!theCurve.IsNull())
+  {
+    if (theMap.IsBound(theCurve))
+      aPC = Handle(ShapePersistent_Geom2d::Curve)::DownCast(theMap.Find(theCurve));
+    else {
+      Handle(Line) aPT = new Line;
+      aPT->myTransient = theCurve;
+      aPC = aPT;
+    }
+  }
+  return aPC;
+}
+
+//=======================================================================
+// Conic
+//=======================================================================
+template<>
+Standard_CString ShapePersistent_Geom2d_Curve::subBase_gp<ShapePersistent_Geom2d::Curve,
+                                                          gp_Ax22d>
+  ::PName() const { return "PGeom2d_Conic"; }
+
+//=======================================================================
+// Circle
+//=======================================================================
+template<>
+Standard_CString ShapePersistent_Geom2d_Curve::instance<ShapePersistent_Geom2d_Curve::Conic,
+                                                        Geom2d_Circle,
+                                                        gp_Circ2d>
+  ::PName() const { return "PGeom2d_Circle"; }
+
+template<>
+void ShapePersistent_Geom2d_Curve::instance<ShapePersistent_Geom2d_Curve::Conic,
+                                            Geom2d_Circle,
+                                            gp_Circ2d>
+  ::Write(StdObjMgt_WriteData& theWriteData) const
+{
+  Handle(Geom2d_Circle) aMyGeom =
+    Handle(Geom2d_Circle)::DownCast(myTransient);
+  theWriteData << aMyGeom->Circ2d();
+}
+
+Handle(ShapePersistent_Geom2d::Curve) 
+ShapePersistent_Geom2d_Curve::Translate(const Handle(Geom2d_Circle)& theCurve,
+                                        StdObjMgt_TransientPersistentMap& theMap)
+{
+  Handle(ShapePersistent_Geom2d::Curve) aPC;
+  if (!theCurve.IsNull())
+  {
+    if (theMap.IsBound(theCurve))
+      aPC = Handle(ShapePersistent_Geom2d::Curve)::DownCast(theMap.Find(theCurve));
+    else {
+      Handle(Circle) aPT = new Circle;
+      aPT->myTransient = theCurve;
+      aPC = aPT;
+    }
+  }
+  return aPC;
+}
+
+//=======================================================================
+// Ellipse
+//=======================================================================
+template<>
+Standard_CString ShapePersistent_Geom2d_Curve::instance<ShapePersistent_Geom2d_Curve::Conic,
+                                                        Geom2d_Ellipse,
+                                                        gp_Elips2d>
+  ::PName() const { return "PGeom2d_Ellipse"; }
+
+template<>
+void ShapePersistent_Geom2d_Curve::instance<ShapePersistent_Geom2d_Curve::Conic,
+                                            Geom2d_Ellipse,
+                                            gp_Elips2d>
+  ::Write(StdObjMgt_WriteData& theWriteData) const
+{
+  Handle(Geom2d_Ellipse) aMyGeom =
+    Handle(Geom2d_Ellipse)::DownCast(myTransient);
+  theWriteData << aMyGeom->Elips2d();
+}
+
+Handle(ShapePersistent_Geom2d::Curve) 
+ShapePersistent_Geom2d_Curve::Translate(const Handle(Geom2d_Ellipse)& theCurve,
+                                        StdObjMgt_TransientPersistentMap& theMap)
+{
+  Handle(ShapePersistent_Geom2d::Curve) aPC;
+  if (!theCurve.IsNull())
+  {
+    if (theMap.IsBound(theCurve))
+      aPC = Handle(ShapePersistent_Geom2d::Curve)::DownCast(theMap.Find(theCurve));
+    else {
+      Handle(Ellipse) aPT = new Ellipse;
+      aPT->myTransient = theCurve;
+      aPC = aPT;
+    }
+  }
+  return aPC;
+}
+
+//=======================================================================
+// Hyperbola
+//=======================================================================
+template<>
+Standard_CString ShapePersistent_Geom2d_Curve::instance<ShapePersistent_Geom2d_Curve::Conic,
+                                                        Geom2d_Hyperbola,
+                                                        gp_Hypr2d>
+  ::PName() const { return "PGeom2d_Hyperbola"; }
+
+template<>
+void ShapePersistent_Geom2d_Curve::instance<ShapePersistent_Geom2d_Curve::Conic,
+                                            Geom2d_Hyperbola,
+                                            gp_Hypr2d>
+  ::Write(StdObjMgt_WriteData& theWriteData) const
+{
+  Handle(Geom2d_Hyperbola) aMyGeom =
+    Handle(Geom2d_Hyperbola)::DownCast(myTransient);
+  theWriteData << aMyGeom->Hypr2d();
+}
+
+Handle(ShapePersistent_Geom2d::Curve) 
+ShapePersistent_Geom2d_Curve::Translate(const Handle(Geom2d_Hyperbola)& theCurve,
+                                        StdObjMgt_TransientPersistentMap& theMap)
+{
+  Handle(ShapePersistent_Geom2d::Curve) aPC;
+  if (!theCurve.IsNull())
+  {
+    if (theMap.IsBound(theCurve))
+      aPC = Handle(ShapePersistent_Geom2d::Curve)::DownCast(theMap.Find(theCurve));
+    else {
+      Handle(Hyperbola) aPT = new Hyperbola;
+      aPT->myTransient = theCurve;
+      aPC = aPT;
+    }
+  }
+  return aPC;
+}
+
+//=======================================================================
+// Parabola
+//=======================================================================
+template<>
+Standard_CString ShapePersistent_Geom2d_Curve::instance<ShapePersistent_Geom2d_Curve::Conic,
+                                                        Geom2d_Parabola,
+                                                        gp_Parab2d>
+  ::PName() const { return "PGeom2d_Hyperbola"; }
+
+template<>
+void ShapePersistent_Geom2d_Curve::instance<ShapePersistent_Geom2d_Curve::Conic,
+                                            Geom2d_Parabola,
+                                            gp_Parab2d>
+  ::Write(StdObjMgt_WriteData& theWriteData) const
+{
+  Handle(Geom2d_Parabola) aMyGeom =
+    Handle(Geom2d_Parabola)::DownCast(myTransient);
+  theWriteData << aMyGeom->Parab2d();
+}
+
+Handle(ShapePersistent_Geom2d::Curve) 
+ShapePersistent_Geom2d_Curve::Translate(const Handle(Geom2d_Parabola)& theCurve,
+                                        StdObjMgt_TransientPersistentMap& theMap)
+{
+  Handle(ShapePersistent_Geom2d::Curve) aPC;
+  if (!theCurve.IsNull())
+  {
+    if (theMap.IsBound(theCurve))
+      aPC = Handle(ShapePersistent_Geom2d::Curve)::DownCast(theMap.Find(theCurve));
+    else {
+      Handle(Parabola) aPT = new Parabola;
+      aPT->myTransient = theCurve;
+      aPC = aPT;
+    }
+  }
+  return aPC;
+}
+
+//=======================================================================
+// BezierCurve
+//=======================================================================
+Handle(ShapePersistent_Geom2d::Curve)
+ShapePersistent_Geom2d_Curve::Translate(const Handle(Geom2d_BezierCurve)& theCurve,
+                                        StdObjMgt_TransientPersistentMap& theMap)
+{
+  Handle(ShapePersistent_Geom2d::Curve) aPC;
+  if (!theCurve.IsNull())
+  {
+    if (theMap.IsBound(theCurve))
+      aPC = Handle(ShapePersistent_Geom2d::Curve)::DownCast(theMap.Find(theCurve));
+    else {
+      Handle(Bezier) aPBC = new Bezier;
+      Handle(pBezier) aPpBC = new pBezier;
+      aPpBC->myRational = theCurve->IsRational();
+      aPpBC->myPoles = StdLPersistent_HArray1::Translate<TColgp_HArray1OfPnt2d>("PColgp_HArray1OfPnt2d", theCurve->Poles());
+      if (theCurve->IsRational()) {
+        aPpBC->myWeights = StdLPersistent_HArray1::Translate<TColStd_HArray1OfReal>(*theCurve->Weights());
+      }
+      aPBC->myPersistent = aPpBC;
+      aPC = aPBC;
+    }
+  }
+  return aPC;
+}
+
+//=======================================================================
+// BSplineCurve
+//=======================================================================
+Handle(ShapePersistent_Geom2d::Curve)
+ShapePersistent_Geom2d_Curve::Translate(const Handle(Geom2d_BSplineCurve)& theCurve,
+                                        StdObjMgt_TransientPersistentMap& theMap)
+{
+  Handle(ShapePersistent_Geom2d::Curve) aPC;
+  if (!theCurve.IsNull())
+  {
+    if (theMap.IsBound(theCurve))
+      aPC = Handle(ShapePersistent_Geom2d::Curve)::DownCast(theMap.Find(theCurve));
+    else {
+      Handle(BSpline) aPBSC = new BSpline;
+      Handle(pBSpline) aPpBSC = new pBSpline;
+      aPpBSC->myRational = theCurve->IsRational();
+      aPpBSC->myPeriodic = theCurve->IsPeriodic();
+      aPpBSC->mySpineDegree = theCurve->Degree();
+      aPpBSC->myPoles = StdLPersistent_HArray1::Translate<TColgp_HArray1OfPnt2d>("PColgp_HArray1OfPnt2d", theCurve->Poles());
+      if (theCurve->IsRational()) {
+        aPpBSC->myWeights = StdLPersistent_HArray1::Translate<TColStd_HArray1OfReal>(*theCurve->Weights());
+      }
+      aPpBSC->myKnots = StdLPersistent_HArray1::Translate<TColStd_HArray1OfReal>(theCurve->Knots());
+      aPpBSC->myMultiplicities = StdLPersistent_HArray1::Translate<TColStd_HArray1OfInteger>(theCurve->Multiplicities());
+      aPBSC->myPersistent = aPpBSC;
+      aPC = aPBSC;
+    }
+  }
+  return aPC;
+}
+
+//=======================================================================
+// TrimmedCurve
+//=======================================================================
+Handle(ShapePersistent_Geom2d::Curve)
+ShapePersistent_Geom2d_Curve::Translate(const Handle(Geom2d_TrimmedCurve)& theCurve,
+                                        StdObjMgt_TransientPersistentMap& theMap)
+{
+  Handle(ShapePersistent_Geom2d::Curve) aPC = new Trimmed;
+  if (!theCurve.IsNull())
+  {
+    if (theMap.IsBound(theCurve))
+      aPC = Handle(ShapePersistent_Geom2d::Curve)::DownCast(theMap.Find(theCurve));
+    else {
+      Handle(Trimmed) aPTC = new Trimmed;
+      Handle(pTrimmed) aPpTC = new pTrimmed;
+      aPpTC->myFirstU = theCurve->FirstParameter();
+      aPpTC->myLastU = theCurve->LastParameter();
+      aPpTC->myBasisCurve = ShapePersistent_Geom2d::Translate(theCurve->BasisCurve(), theMap);
+      aPTC->myPersistent = aPpTC;
+      aPC = aPTC;
+    }
+  }
+  return aPC;
+}
+
+//=======================================================================
+// OffsetCurve
+//=======================================================================
+Handle(ShapePersistent_Geom2d::Curve)
+ShapePersistent_Geom2d_Curve::Translate(const Handle(Geom2d_OffsetCurve)& theCurve,
+                                        StdObjMgt_TransientPersistentMap& theMap)
+{
+  Handle(ShapePersistent_Geom2d::Curve) aPC = new Offset;
+  if (!theCurve.IsNull())
+  {
+    if (theMap.IsBound(theCurve))
+      aPC = Handle(ShapePersistent_Geom2d::Curve)::DownCast(theMap.Find(theCurve));
+    else {
+      Handle(Offset) aPOC = new Offset;
+      Handle(pOffset) aPpOC = new pOffset;
+      aPpOC->myOffsetValue = theCurve->Offset();
+      aPpOC->myBasisCurve = ShapePersistent_Geom2d::Translate(theCurve->BasisCurve(), theMap);
+      aPOC->myPersistent = aPpOC;
+      aPC = aPOC;
+    }
+  }
+  return aPC;
+}
index c253038..6522d7a 100644 (file)
@@ -15,6 +15,8 @@
 #ifndef _ShapePersistent_Geom2d_Curve_HeaderFile
 #define _ShapePersistent_Geom2d_Curve_HeaderFile
 
+#include <StdObjMgt_TransientPersistentMap.hxx>
+
 #include <ShapePersistent_Geom2d.hxx>
 #include <ShapePersistent_HArray1.hxx>
 #include <StdLPersistent_HArray1.hxx>
 #include <Geom2d_Ellipse.hxx>
 #include <Geom2d_Hyperbola.hxx>
 #include <Geom2d_Parabola.hxx>
+#include <Geom2d_BezierCurve.hxx>
+#include <Geom2d_BSplineCurve.hxx>
+#include <Geom2d_TrimmedCurve.hxx>
+#include <Geom2d_OffsetCurve.hxx>
 
 #include <gp_Circ2d.hxx>
 #include <gp_Elips2d.hxx>
@@ -31,7 +37,7 @@
 #include <gp_Parab2d.hxx>
 
 
-class ShapePersistent_Geom2d_Curve : protected ShapePersistent_Geom2d
+class ShapePersistent_Geom2d_Curve : public ShapePersistent_Geom2d
 {
   typedef Curve::PersistentBase pBase;
 
@@ -39,9 +45,20 @@ class ShapePersistent_Geom2d_Curve : protected ShapePersistent_Geom2d
 
   class pBezier : public pBounded
   {
+    friend class ShapePersistent_Geom2d_Curve;
+
   public:
     inline void Read (StdObjMgt_ReadData& theReadData)
       { theReadData >> myRational >> myPoles >> myWeights; }
+    inline void Write (StdObjMgt_WriteData& theWriteData) const
+      { theWriteData << myRational << myPoles << myWeights; }
+    inline void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
+    {
+      theChildren.Append(myPoles);
+      theChildren.Append(myWeights);
+    }
+    inline Standard_CString PName() const
+      { return "PGeom2d_BezierCurve"; }
 
     virtual Handle(Geom2d_Curve) Import() const;
 
@@ -53,12 +70,28 @@ class ShapePersistent_Geom2d_Curve : protected ShapePersistent_Geom2d
 
   class pBSpline : public pBounded
   {
+    friend class ShapePersistent_Geom2d_Curve;
+
   public:
     inline void Read (StdObjMgt_ReadData& theReadData)
     {
       theReadData >> myRational >> myPeriodic >> mySpineDegree;
       theReadData >> myPoles >> myWeights >> myKnots >> myMultiplicities;
     }
+    inline void Write (StdObjMgt_WriteData& theWriteData) const
+    {
+      theWriteData << myRational << myPeriodic << mySpineDegree;
+      theWriteData << myPoles << myWeights << myKnots << myMultiplicities;
+    }
+    inline void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
+    {
+      theChildren.Append(myPoles);
+      theChildren.Append(myWeights);
+      theChildren.Append(myKnots);
+      theChildren.Append(myMultiplicities);
+    }
+    inline Standard_CString PName() const 
+      { return "PGeom2d_BSplineCurve"; }
 
     virtual Handle(Geom2d_Curve) Import() const;
 
@@ -74,9 +107,17 @@ class ShapePersistent_Geom2d_Curve : protected ShapePersistent_Geom2d
 
   class pTrimmed : public pBounded
   {
+    friend class ShapePersistent_Geom2d_Curve;
+
   public:
     inline void Read (StdObjMgt_ReadData& theReadData)
       { theReadData >> myBasisCurve >> myFirstU >> myLastU; }
+    inline void Write (StdObjMgt_WriteData& theWriteData) const
+      { theWriteData << myBasisCurve << myFirstU << myLastU; }
+    inline void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
+      { theChildren.Append(myBasisCurve); }
+    inline Standard_CString PName() const
+      { return "PGeom2d_TrimmedCurve"; }
 
     virtual Handle(Geom2d_Curve) Import() const;
 
@@ -88,9 +129,17 @@ class ShapePersistent_Geom2d_Curve : protected ShapePersistent_Geom2d
 
   class pOffset : public pBase
   {
+    friend class ShapePersistent_Geom2d_Curve;
+
   public:
     inline void Read (StdObjMgt_ReadData& theReadData)
       { theReadData >> myBasisCurve >> myOffsetValue; }
+    inline void Write (StdObjMgt_WriteData& theWriteData) const
+      { theWriteData << myBasisCurve << myOffsetValue; }
+    inline void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
+      { theChildren.Append(myBasisCurve); }
+    inline Standard_CString PName() const
+      { return "PGeom2d_OffsetCurve"; }
 
     virtual Handle(Geom2d_Curve) Import() const;
 
@@ -114,6 +163,118 @@ public:
   typedef Delayed<Bounded, pTrimmed>                    Trimmed;
 
   typedef Delayed<Curve, pOffset>                       Offset;
+
+public:
+  //! Create a persistent object for a line
+  Standard_EXPORT static Handle(Curve) Translate (const Handle(Geom2d_Line)& theCurve,
+                                                  StdObjMgt_TransientPersistentMap& theMap);
+  //! Create a persistent object for a circle
+  Standard_EXPORT static Handle(Curve) Translate (const Handle(Geom2d_Circle)& theCurve,
+                                                  StdObjMgt_TransientPersistentMap& theMap);
+  //! Create a persistent object for a ellipse
+  Standard_EXPORT static Handle(Curve) Translate (const Handle(Geom2d_Ellipse)& theCurve,
+                                                  StdObjMgt_TransientPersistentMap& theMap);
+  //! Create a persistent object for a hyperbola
+  Standard_EXPORT static Handle(Curve) Translate (const Handle(Geom2d_Hyperbola)& theCurve,
+                                                  StdObjMgt_TransientPersistentMap& theMap);
+  //! Create a persistent object for a parabola
+  Standard_EXPORT static Handle(Curve) Translate (const Handle(Geom2d_Parabola)& theCurve,
+                                                  StdObjMgt_TransientPersistentMap& theMap);
+  //! Create a persistent object for a Bezier curve
+  Standard_EXPORT static Handle(Curve) Translate (const Handle(Geom2d_BezierCurve)& theCurve,
+                                                  StdObjMgt_TransientPersistentMap& theMap);
+  //! Create a persistent object for a BSpline curve
+  Standard_EXPORT static Handle(Curve) Translate (const Handle(Geom2d_BSplineCurve)& theCurve,
+                                                  StdObjMgt_TransientPersistentMap& theMap);
+  //! Create a persistent object for a trimmed curve
+  Standard_EXPORT static Handle(Curve) Translate (const Handle(Geom2d_TrimmedCurve)& theCurve,
+                                                  StdObjMgt_TransientPersistentMap& theMap);
+  //! Create a persistent object for an offset curve 
+  Standard_EXPORT static Handle(Curve) Translate (const Handle(Geom2d_OffsetCurve)& theCurve,
+                                                  StdObjMgt_TransientPersistentMap& theMap);
 };
 
+//=======================================================================
+// Line
+//=======================================================================
+template<>
+Standard_CString ShapePersistent_Geom2d_Curve::instance<ShapePersistent_Geom2d::Curve,
+                                                        Geom2d_Line,
+                                                        gp_Ax2d>
+  ::PName() const;
+
+template<>
+void ShapePersistent_Geom2d_Curve::instance<ShapePersistent_Geom2d::Curve,
+                                            Geom2d_Line,
+                                            gp_Ax2d>
+  ::Write(StdObjMgt_WriteData& theWriteData) const;
+
+//=======================================================================
+// Conic
+//=======================================================================
+template<>
+Standard_CString ShapePersistent_Geom2d_Curve::subBase_gp<ShapePersistent_Geom2d::Curve,
+                                                          gp_Ax22d>
+  ::PName() const;
+
+//=======================================================================
+// Circle
+//=======================================================================
+template<>
+Standard_CString ShapePersistent_Geom2d_Curve::instance<ShapePersistent_Geom2d_Curve::Conic,
+                                                        Geom2d_Circle,
+                                                        gp_Circ2d>
+  ::PName() const;
+
+template<>
+void ShapePersistent_Geom2d_Curve::instance<ShapePersistent_Geom2d_Curve::Conic,
+                                            Geom2d_Circle,
+                                            gp_Circ2d>
+  ::Write(StdObjMgt_WriteData& theWriteData) const;
+
+//=======================================================================
+// Ellipse
+//=======================================================================
+template<>
+Standard_CString ShapePersistent_Geom2d_Curve::instance<ShapePersistent_Geom2d_Curve::Conic,
+                                                        Geom2d_Ellipse,
+                                                        gp_Elips2d>
+  ::PName() const;
+
+template<>
+void ShapePersistent_Geom2d_Curve::instance<ShapePersistent_Geom2d_Curve::Conic,
+                                            Geom2d_Ellipse,
+                                            gp_Elips2d>
+  ::Write(StdObjMgt_WriteData& theWriteData) const;
+
+//=======================================================================
+// Hyperbola
+//=======================================================================
+template<>
+Standard_CString ShapePersistent_Geom2d_Curve::instance<ShapePersistent_Geom2d_Curve::Conic,
+                                                        Geom2d_Hyperbola,
+                                                        gp_Hypr2d>
+  ::PName() const;
+
+template<>
+void ShapePersistent_Geom2d_Curve::instance<ShapePersistent_Geom2d_Curve::Conic,
+                                            Geom2d_Hyperbola,
+                                            gp_Hypr2d>
+  ::Write(StdObjMgt_WriteData& theWriteData) const;
+
+//=======================================================================
+// Parabola
+//=======================================================================
+template<>
+Standard_CString ShapePersistent_Geom2d_Curve::instance<ShapePersistent_Geom2d_Curve::Conic,
+                                                        Geom2d_Parabola,
+                                                        gp_Parab2d>
+  ::PName() const;
+
+template<>
+void ShapePersistent_Geom2d_Curve::instance<ShapePersistent_Geom2d_Curve::Conic,
+                                            Geom2d_Parabola,
+                                            gp_Parab2d>
+  ::Write(StdObjMgt_WriteData& theWriteData) const;
+
 #endif
index 11b667d..8828067 100644 (file)
@@ -11,6 +11,8 @@
 // Alternatively, this file may be used under the terms of Open CASCADE
 // commercial license or contractual agreement.
 
+#include <Standard_NullObject.hxx>
+
 #include <ShapePersistent_Geom_Curve.hxx>
 
 #include <Geom_BezierCurve.hxx>
@@ -75,3 +77,309 @@ Handle(Geom_Curve) ShapePersistent_Geom_Curve::pOffset::Import() const
   return new Geom_OffsetCurve
     (myBasisCurve->Import(), myOffsetValue, myOffsetDirection);
 }
+
+//=======================================================================
+// Line
+//=======================================================================
+template<>
+Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom::Curve,
+                                                Geom_Line,
+                                                gp_Ax1>
+  ::PName() const { return "PGeom_Line"; }
+
+template<>
+void ShapePersistent_Geom::instance<ShapePersistent_Geom::Curve,
+                                    Geom_Line,
+                                    gp_Ax1>
+  ::Write(StdObjMgt_WriteData& theWriteData) const
+{
+  Handle(Geom_Line) aMyGeom =
+    Handle(Geom_Line)::DownCast(myTransient);
+  write(theWriteData, aMyGeom->Position());
+}
+
+Handle(ShapePersistent_Geom::Curve)
+ShapePersistent_Geom_Curve::Translate(const Handle(Geom_Line)& theCurve,
+                                      StdObjMgt_TransientPersistentMap& theMap)
+{
+  Handle(ShapePersistent_Geom::Curve) aPC;
+  if (!theCurve.IsNull())
+  {
+    if (theMap.IsBound(theCurve))
+      aPC = Handle(ShapePersistent_Geom::Curve)::DownCast(theMap.Find(theCurve));
+    else {
+      Handle(Line) aPT = new Line;
+      aPT->myTransient = theCurve;
+      aPC = aPT;
+    }
+  }
+  return aPC;
+}
+
+//=======================================================================
+// Conic
+//=======================================================================
+template<>
+Standard_CString ShapePersistent_Geom::subBase_gp<ShapePersistent_Geom::Curve,
+                                                  gp_Ax2>
+  ::PName() const { return "PGeom_Conic"; }
+
+//=======================================================================
+// Circle
+//=======================================================================
+template<>
+Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom_Curve::Conic,
+                                                Geom_Circle,
+                                                gp_Circ>
+  ::PName() const { return "PGeom_Circle"; }
+
+template<>
+void ShapePersistent_Geom::instance<ShapePersistent_Geom_Curve::Conic,
+                                    Geom_Circle,
+                                    gp_Circ>
+  ::Write(StdObjMgt_WriteData& theWriteData) const
+{
+  Handle(Geom_Circle) aMyGeom =
+    Handle(Geom_Circle)::DownCast(myTransient);
+  theWriteData << aMyGeom->Circ();
+}
+
+Handle(ShapePersistent_Geom::Curve)
+ShapePersistent_Geom_Curve::Translate(const Handle(Geom_Circle)& theCurve,
+                                      StdObjMgt_TransientPersistentMap& theMap)
+{
+  Handle(ShapePersistent_Geom::Curve) aPC;
+  if (!theCurve.IsNull())
+  {
+    if (theMap.IsBound(theCurve))
+      aPC = Handle(ShapePersistent_Geom::Curve)::DownCast(theMap.Find(theCurve));
+    else {
+      Handle(Circle) aPT = new Circle;
+      aPT->myTransient = theCurve;
+      aPC = aPT;
+    }
+  }
+  return aPC;
+}
+
+//=======================================================================
+// Ellipse
+//=======================================================================
+template<>
+Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom_Curve::Conic,
+                                                Geom_Ellipse,
+                                                gp_Elips>
+  ::PName() const { return "PGeom_Ellipse"; }
+
+template<>
+void ShapePersistent_Geom::instance<ShapePersistent_Geom_Curve::Conic,
+                                    Geom_Ellipse,
+                                    gp_Elips>
+  ::Write(StdObjMgt_WriteData& theWriteData) const
+{
+  Handle(Geom_Ellipse) aMyGeom =
+    Handle(Geom_Ellipse)::DownCast(myTransient);
+  theWriteData << aMyGeom->Elips();
+}
+
+Handle(ShapePersistent_Geom::Curve)
+ShapePersistent_Geom_Curve::Translate(const Handle(Geom_Ellipse)& theCurve,
+                                      StdObjMgt_TransientPersistentMap& theMap)
+{
+  Handle(ShapePersistent_Geom::Curve) aPC;
+  if (!theCurve.IsNull())
+  {
+    if (theMap.IsBound(theCurve))
+      aPC = Handle(ShapePersistent_Geom::Curve)::DownCast(theMap.Find(theCurve));
+    else {
+      Handle(Ellipse) aPT = new Ellipse;
+      aPT->myTransient = theCurve;
+      aPC = aPT;
+    }
+  }
+  return aPC;
+}
+
+//=======================================================================
+// Hyperbola
+//=======================================================================
+template<>
+Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom_Curve::Conic,
+                                                Geom_Hyperbola,
+                                                gp_Hypr>
+  ::PName() const { return "PGeom_Hyperbola"; }
+
+template<>
+void ShapePersistent_Geom::instance<ShapePersistent_Geom_Curve::Conic,
+                                    Geom_Hyperbola,
+                                    gp_Hypr>
+  ::Write(StdObjMgt_WriteData& theWriteData) const
+{
+  Handle(Geom_Hyperbola) aMyGeom =
+    Handle(Geom_Hyperbola)::DownCast(myTransient);
+  theWriteData << aMyGeom->Hypr();
+}
+
+Handle(ShapePersistent_Geom::Curve)
+ShapePersistent_Geom_Curve::Translate(const Handle(Geom_Hyperbola)& theCurve,
+                                      StdObjMgt_TransientPersistentMap& theMap)
+{
+  Handle(ShapePersistent_Geom::Curve) aPC;
+  if (!theCurve.IsNull())
+  {
+    if (theMap.IsBound(theCurve))
+      aPC = Handle(ShapePersistent_Geom::Curve)::DownCast(theMap.Find(theCurve));
+    else {
+      Handle(Hyperbola) aPT = new Hyperbola;
+      aPT->myTransient = theCurve;
+      aPC = aPT;
+    }
+  }
+  return aPC;
+}
+
+//=======================================================================
+// Parabola
+//=======================================================================
+template<>
+Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom_Curve::Conic,
+                                                Geom_Parabola,
+                                                gp_Parab>
+  ::PName() const { return "PGeom_Parabola"; }
+
+template<>
+void ShapePersistent_Geom::instance<ShapePersistent_Geom_Curve::Conic,
+                                    Geom_Parabola,
+                                    gp_Parab>
+  ::Write(StdObjMgt_WriteData& theWriteData) const
+{
+  Handle(Geom_Parabola) aMyGeom =
+    Handle(Geom_Parabola)::DownCast(myTransient);
+  theWriteData << aMyGeom->Parab();
+}
+
+Handle(ShapePersistent_Geom::Curve) 
+ShapePersistent_Geom_Curve::Translate(const Handle(Geom_Parabola)& theCurve,
+                                      StdObjMgt_TransientPersistentMap& theMap)
+{
+  Handle(ShapePersistent_Geom::Curve) aPC;
+  if (!theCurve.IsNull())
+  {
+    if (theMap.IsBound(theCurve))
+      aPC = Handle(ShapePersistent_Geom::Curve)::DownCast(theMap.Find(theCurve));
+    else {
+      Handle(Parabola) aPT = new Parabola;
+      aPT->myTransient = theCurve;
+      aPC = aPT;
+    }
+  }
+  return aPC;
+}
+
+//=======================================================================
+// BezierCurve
+//=======================================================================
+Handle(ShapePersistent_Geom::Curve)
+ShapePersistent_Geom_Curve::Translate(const Handle(Geom_BezierCurve)& theCurve,
+                                      StdObjMgt_TransientPersistentMap& theMap)
+{
+  Handle(ShapePersistent_Geom::Curve) aPC;
+  if (!theCurve.IsNull())
+  {
+    if (theMap.IsBound(theCurve))
+      aPC = Handle(ShapePersistent_Geom::Curve)::DownCast(theMap.Find(theCurve));
+    else {
+      Handle(Bezier) aPBC = new Bezier;
+      Handle(pBezier) aPpBC = new pBezier;
+      aPpBC->myRational = theCurve->IsRational();
+      aPpBC->myPoles = StdLPersistent_HArray1::Translate<TColgp_HArray1OfPnt>("PColgp_HArray1OfPnt", theCurve->Poles());
+      if (theCurve->IsRational()) {
+        aPpBC->myWeights = StdLPersistent_HArray1::Translate<TColStd_HArray1OfReal>(*theCurve->Weights());
+      }
+      aPBC->myPersistent = aPpBC;
+      aPC = aPBC;
+    }
+  }
+  return aPC;
+}
+
+//=======================================================================
+// BSplineCurve
+//=======================================================================
+Handle(ShapePersistent_Geom::Curve)
+ShapePersistent_Geom_Curve::Translate(const Handle(Geom_BSplineCurve)& theCurve,
+                                      StdObjMgt_TransientPersistentMap& theMap)
+{
+  Handle(ShapePersistent_Geom::Curve) aPC;
+  if (!theCurve.IsNull())
+  {
+    if (theMap.IsBound(theCurve))
+      aPC = Handle(ShapePersistent_Geom::Curve)::DownCast(theMap.Find(theCurve));
+    else {
+      Handle(BSpline) aPBSC = new BSpline;
+      Handle(pBSpline) aPpBSC = new pBSpline;
+      aPpBSC->myRational = theCurve->IsRational();
+      aPpBSC->myPeriodic = theCurve->IsPeriodic();
+      aPpBSC->mySpineDegree = theCurve->Degree();
+      aPpBSC->myPoles = StdLPersistent_HArray1::Translate<TColgp_HArray1OfPnt>("PColgp_HArray1OfPnt", theCurve->Poles());
+      if (theCurve->IsRational()) {
+        aPpBSC->myWeights = StdLPersistent_HArray1::Translate<TColStd_HArray1OfReal>(*theCurve->Weights());
+      }
+      aPpBSC->myKnots = StdLPersistent_HArray1::Translate<TColStd_HArray1OfReal>(theCurve->Knots());
+      aPpBSC->myMultiplicities = StdLPersistent_HArray1::Translate<TColStd_HArray1OfInteger>(theCurve->Multiplicities());
+      aPBSC->myPersistent = aPpBSC;
+      aPC = aPBSC;
+    }
+  }
+  return aPC;
+}
+
+//=======================================================================
+// TrimmedCurve
+//=======================================================================
+Handle(ShapePersistent_Geom::Curve)
+ShapePersistent_Geom_Curve::Translate(const Handle(Geom_TrimmedCurve)& theCurve,
+                                      StdObjMgt_TransientPersistentMap& theMap)
+{
+  Handle(ShapePersistent_Geom::Curve) aPC;
+  if (!theCurve.IsNull())
+  {
+    if (theMap.IsBound(theCurve))
+      aPC = Handle(ShapePersistent_Geom::Curve)::DownCast(theMap.Find(theCurve));
+    else {
+      Handle(Trimmed) aPTC = new Trimmed;
+      Handle(pTrimmed) aPpTC = new pTrimmed;
+      aPpTC->myFirstU = theCurve->FirstParameter();
+      aPpTC->myLastU = theCurve->LastParameter();
+      aPpTC->myBasisCurve = ShapePersistent_Geom::Translate(theCurve->BasisCurve(), theMap);
+      aPTC->myPersistent = aPpTC;
+      aPC = aPTC;
+    }
+  }
+  return aPC;
+}
+
+//=======================================================================
+// OffsetCurve
+//=======================================================================
+Handle(ShapePersistent_Geom::Curve)
+ShapePersistent_Geom_Curve::Translate(const Handle(Geom_OffsetCurve)& theCurve,
+                                      StdObjMgt_TransientPersistentMap& theMap)
+{
+  Handle(ShapePersistent_Geom::Curve) aPC;
+  if (!theCurve.IsNull())
+  {
+    if (theMap.IsBound(theCurve))
+      aPC = Handle(ShapePersistent_Geom::Curve)::DownCast(theMap.Find(theCurve));
+    else {
+      Handle(Offset) aPOC = new Offset;
+      Handle(pOffset) aPpOC = new pOffset;
+      aPpOC->myOffsetDirection = theCurve->Direction();
+      aPpOC->myOffsetValue = theCurve->Offset();
+      aPpOC->myBasisCurve = ShapePersistent_Geom::Translate(theCurve->BasisCurve(), theMap);
+      aPOC->myPersistent = aPpOC;
+      aPC = aPOC;
+    }
+  }
+  return aPC;
+}
index 1cb00a6..0e4cef5 100644 (file)
@@ -15,6 +15,8 @@
 #ifndef _ShapePersistent_Geom_Curve_HeaderFile
 #define _ShapePersistent_Geom_Curve_HeaderFile
 
+#include <StdObjMgt_TransientPersistentMap.hxx>
+
 #include <ShapePersistent_Geom.hxx>
 #include <ShapePersistent_HArray1.hxx>
 #include <StdLPersistent_HArray1.hxx>
 #include <Geom_Ellipse.hxx>
 #include <Geom_Hyperbola.hxx>
 #include <Geom_Parabola.hxx>
+#include <Geom_BezierCurve.hxx>
+#include <Geom_BSplineCurve.hxx>
+#include <Geom_TrimmedCurve.hxx>
+#include <Geom_OffsetCurve.hxx>
 
 #include <gp_Circ.hxx>
 #include <gp_Elips.hxx>
@@ -32,7 +38,6 @@
 
 class gp_Dir;
 
-
 class ShapePersistent_Geom_Curve : private ShapePersistent_Geom
 {
   typedef Curve::PersistentBase pBase;
@@ -41,9 +46,19 @@ class ShapePersistent_Geom_Curve : private ShapePersistent_Geom
 
   class pBezier : public pBounded
   {
+    friend class ShapePersistent_Geom_Curve;
+
   public:
     inline void Read (StdObjMgt_ReadData& theReadData)
       { theReadData >> myRational >> myPoles >> myWeights; }
+    inline void Write(StdObjMgt_WriteData& theWriteData)
+      { theWriteData << myRational << myPoles << myWeights; }
+    inline void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
+    {
+      theChildren.Append(myPoles);
+      theChildren.Append(myWeights);
+    }
+    inline Standard_CString PName() const { return "PGeom_BezierCurve"; }
 
     virtual Handle(Geom_Curve) Import() const;
 
@@ -55,12 +70,27 @@ class ShapePersistent_Geom_Curve : private ShapePersistent_Geom
 
   class pBSpline : public pBounded
   {
+    friend class ShapePersistent_Geom_Curve;
+
   public:
     inline void Read (StdObjMgt_ReadData& theReadData)
     {
       theReadData >> myRational >> myPeriodic >> mySpineDegree;
       theReadData >> myPoles >> myWeights >> myKnots >> myMultiplicities;
     }
+    inline void Write (StdObjMgt_WriteData& theWriteData) const
+    {
+      theWriteData << myRational << myPeriodic << mySpineDegree;
+      theWriteData << myPoles << myWeights << myKnots << myMultiplicities;
+    }
+    inline void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
+    {
+      theChildren.Append(myPoles);
+      theChildren.Append(myWeights);
+      theChildren.Append(myKnots);
+      theChildren.Append(myMultiplicities);
+    }
+    inline Standard_CString PName() const { return "PGeom_BSplineCurve"; }
 
     virtual Handle(Geom_Curve) Import() const;
 
@@ -76,9 +106,16 @@ class ShapePersistent_Geom_Curve : private ShapePersistent_Geom
 
   class pTrimmed : public pBounded
   {
+    friend class ShapePersistent_Geom_Curve;
+
   public:
     inline void Read (StdObjMgt_ReadData& theReadData)
       { theReadData >> myBasisCurve >> myFirstU >> myLastU; }
+    inline void Write (StdObjMgt_WriteData& theWriteData) const
+      { theWriteData << myBasisCurve << myFirstU << myLastU; }
+    inline void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
+      { theChildren.Append(myBasisCurve); }
+    inline Standard_CString PName() const { return "PGeom_TrimmedCurve"; }
 
     virtual Handle(Geom_Curve) Import() const;
 
@@ -90,9 +127,16 @@ class ShapePersistent_Geom_Curve : private ShapePersistent_Geom
 
   class pOffset : public pBase
   {
+    friend class ShapePersistent_Geom_Curve;
+
   public:
     inline void Read (StdObjMgt_ReadData& theReadData)
       { theReadData >> myBasisCurve >> myOffsetDirection >> myOffsetValue; }
+    inline void Write (StdObjMgt_WriteData& theWriteData) const
+      { theWriteData << myBasisCurve << myOffsetDirection << myOffsetValue; }
+    inline void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
+      { theChildren.Append(myBasisCurve); }
+    inline Standard_CString PName() const { return "PGeom_OffsetCurve"; }
 
     virtual Handle(Geom_Curve) Import() const;
 
@@ -117,6 +161,118 @@ public:
   typedef Delayed<Bounded, pTrimmed>                Trimmed;
 
   typedef Delayed<Curve, pOffset>                   Offset;
+
+public:
+  //! Create a persistent object for a line
+  Standard_EXPORT static Handle(Curve) Translate (const Handle(Geom_Line)& theCurve,
+                                                  StdObjMgt_TransientPersistentMap& theMap);
+  //! Create a persistent object for a circle
+  Standard_EXPORT static Handle(Curve) Translate (const Handle(Geom_Circle)& theCurve,
+                                                  StdObjMgt_TransientPersistentMap& theMap);
+  //! Create a persistent object for a ellipse
+  Standard_EXPORT static Handle(Curve) Translate (const Handle(Geom_Ellipse)& theCurve,
+                                                  StdObjMgt_TransientPersistentMap& theMap);
+  //! Create a persistent object for a hyperbola
+  Standard_EXPORT static Handle(Curve) Translate (const Handle(Geom_Hyperbola)& theCurve,
+                                                  StdObjMgt_TransientPersistentMap& theMap);
+  //! Create a persistent object for a parabola
+  Standard_EXPORT static Handle(Curve) Translate (const Handle(Geom_Parabola)& theCurve,
+                                                  StdObjMgt_TransientPersistentMap& theMap);
+  //! Create a persistent object for a Bezier curve
+  Standard_EXPORT static Handle(Curve) Translate (const Handle(Geom_BezierCurve)& theCurve,
+                                                  StdObjMgt_TransientPersistentMap& theMap);
+  //! Create a persistent object for a BSpline curve
+  Standard_EXPORT static Handle(Curve) Translate (const Handle(Geom_BSplineCurve)& theCurve,
+                                                  StdObjMgt_TransientPersistentMap& theMap);
+  //! Create a persistent object for a trimmed curve
+  Standard_EXPORT static Handle(Curve) Translate (const Handle(Geom_TrimmedCurve)& theCurve,
+                                                  StdObjMgt_TransientPersistentMap& theMap);
+  //! Create a persistent object for an offset curve 
+  Standard_EXPORT static Handle(Curve) Translate (const Handle(Geom_OffsetCurve)& theCurve,
+                                                  StdObjMgt_TransientPersistentMap& theMap);
 };
 
+//=======================================================================
+// Line
+//=======================================================================
+template<>
+Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom::Curve, 
+                                                Geom_Line, 
+                                                gp_Ax1>
+  ::PName() const;
+
+template<>
+void ShapePersistent_Geom::instance<ShapePersistent_Geom::Curve,
+                                    Geom_Line,
+                                    gp_Ax1>
+  ::Write(StdObjMgt_WriteData& theWriteData) const;
+
+//=======================================================================
+// Conic
+//=======================================================================
+template<>
+Standard_CString ShapePersistent_Geom::subBase_gp<ShapePersistent_Geom::Curve, 
+                                                  gp_Ax2>
+  ::PName() const;
+
+//=======================================================================
+// Circle
+//=======================================================================
+template<>
+Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom_Curve::Conic, 
+                                                Geom_Circle, 
+                                                gp_Circ>
+  ::PName() const;
+
+template<>
+void ShapePersistent_Geom::instance<ShapePersistent_Geom_Curve::Conic,
+                                    Geom_Circle,
+                                    gp_Circ>
+  ::Write(StdObjMgt_WriteData& theWriteData) const;
+
+//=======================================================================
+// Ellipse
+//=======================================================================
+template<>
+Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom_Curve::Conic,
+                                                Geom_Ellipse,
+                                                gp_Elips>
+  ::PName() const;
+
+template<>
+void ShapePersistent_Geom::instance<ShapePersistent_Geom_Curve::Conic,
+                                    Geom_Ellipse,
+                                    gp_Elips>
+  ::Write(StdObjMgt_WriteData& theWriteData) const;
+
+//=======================================================================
+// Hyperbola
+//=======================================================================
+template<>
+Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom_Curve::Conic,
+                                                Geom_Hyperbola,
+                                                gp_Hypr>
+  ::PName() const;
+
+template<>
+void ShapePersistent_Geom::instance<ShapePersistent_Geom_Curve::Conic,
+                                    Geom_Hyperbola,
+                                    gp_Hypr>
+  ::Write(StdObjMgt_WriteData& theWriteData) const;
+
+//=======================================================================
+// Parabola
+//=======================================================================
+template<>
+Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom_Curve::Conic,
+                                                Geom_Parabola,
+                                                gp_Parab>
+  ::PName() const;
+
+template<>
+void ShapePersistent_Geom::instance<ShapePersistent_Geom_Curve::Conic,
+                                    Geom_Parabola,
+                                    gp_Parab>
+  ::Write(StdObjMgt_WriteData& theWriteData) const;
+
 #endif
index ba383a0..3b7d39f 100644 (file)
@@ -12,6 +12,8 @@
 // commercial license or contractual agreement.
 
 #include <ShapePersistent_Geom_Surface.hxx>
+#include <StdLPersistent_HArray1.hxx>
+#include <ShapePersistent_HArray2.hxx>
 
 #include <Geom_SurfaceOfLinearExtrusion.hxx>
 #include <Geom_SurfaceOfRevolution.hxx>
@@ -108,3 +110,374 @@ Handle(Geom_Surface) ShapePersistent_Geom_Surface::pOffset::Import() const
 
   return new Geom_OffsetSurface (myBasisSurface->Import(), myOffsetValue);
 }
+
+//=======================================================================
+// Elementary
+//=======================================================================
+template<>
+Standard_CString ShapePersistent_Geom::subBase_gp<ShapePersistent_Geom::Surface,
+                                                  gp_Ax3>
+  ::PName() const { return "PGeom_ElementarySurface"; }
+
+//=======================================================================
+// Plane
+//=======================================================================
+template<>
+Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom::subBase_gp<ShapePersistent_Geom::Surface, gp_Ax3>,
+                                                Geom_Plane,
+                                                gp_Ax3>
+  ::PName() const { return "PGeom_Plane"; }
+
+template<>
+void ShapePersistent_Geom::instance<ShapePersistent_Geom::subBase_gp<ShapePersistent_Geom::Surface, gp_Ax3>,
+                                    Geom_Plane,
+                                    gp_Ax3>
+  ::Write(StdObjMgt_WriteData& theWriteData) const
+{
+  Handle(Geom_Plane) aMyGeom =
+    Handle(Geom_Plane)::DownCast(myTransient);
+  theWriteData << aMyGeom->Position();
+}
+
+Handle(ShapePersistent_Geom::Surface) 
+ShapePersistent_Geom_Surface::Translate(const Handle(Geom_Plane)& theSurf,
+                                        StdObjMgt_TransientPersistentMap& theMap)
+{
+  Handle(ShapePersistent_Geom::Surface) aPS;
+  if (!theSurf.IsNull())
+  {
+    if (theMap.IsBound(theSurf))
+      aPS = Handle(ShapePersistent_Geom::Surface)::DownCast(theMap.Find(theSurf));
+    else
+    {
+      Handle(Plane) aPP = new Plane;
+      aPP->myTransient = theSurf;
+      aPS = aPP;
+    }
+  }
+  return aPS;
+}
+
+//=======================================================================
+// Conical
+//=======================================================================
+template<>
+Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom::subBase_gp<ShapePersistent_Geom::Surface, gp_Ax3>,
+                                                Geom_ConicalSurface,
+                                                gp_Cone>
+  ::PName() const { return "PGeom_ConicalSurface"; }
+
+template<>
+void ShapePersistent_Geom::instance<ShapePersistent_Geom::subBase_gp<ShapePersistent_Geom::Surface, gp_Ax3>,
+                                    Geom_ConicalSurface,
+                                    gp_Cone>
+  ::Write(StdObjMgt_WriteData& theWriteData) const
+{
+  Handle(Geom_ConicalSurface) aMyGeom =
+    Handle(Geom_ConicalSurface)::DownCast(myTransient);
+  theWriteData << aMyGeom->Cone();
+}
+
+Handle(ShapePersistent_Geom::Surface) 
+ShapePersistent_Geom_Surface::Translate(const Handle(Geom_ConicalSurface)& theSurf,
+                                        StdObjMgt_TransientPersistentMap& theMap)
+{
+  Handle(ShapePersistent_Geom::Surface) aPS;
+  if (!theSurf.IsNull())
+  {
+    if (theMap.IsBound(theSurf))
+      aPS = Handle(ShapePersistent_Geom::Surface)::DownCast(theMap.Find(theSurf));
+    else
+    {
+      Handle(Conical) aPCon = new Conical;
+      aPCon->myTransient = theSurf;
+      aPS = aPCon;
+    }
+  }
+  return aPS;
+}
+
+//=======================================================================
+// Cylindrical
+//=======================================================================
+template<>
+Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom::subBase_gp<ShapePersistent_Geom::Surface, gp_Ax3>,
+                                                Geom_CylindricalSurface,
+                                                gp_Cylinder>
+  ::PName() const { return "PGeom_CylindricalSurface"; }
+
+template<>
+void ShapePersistent_Geom::instance<ShapePersistent_Geom::subBase_gp<ShapePersistent_Geom::Surface, gp_Ax3>,
+                                    Geom_CylindricalSurface,
+                                    gp_Cylinder>
+  ::Write(StdObjMgt_WriteData& theWriteData) const
+{
+  Handle(Geom_CylindricalSurface) aMyGeom =
+    Handle(Geom_CylindricalSurface)::DownCast(myTransient);
+  theWriteData << aMyGeom->Cylinder();
+}
+
+Handle(ShapePersistent_Geom::Surface) 
+ShapePersistent_Geom_Surface::Translate(const Handle(Geom_CylindricalSurface)& theSurf,
+                                        StdObjMgt_TransientPersistentMap& theMap)
+{
+  Handle(ShapePersistent_Geom::Surface) aPS;
+  if (!theSurf.IsNull())
+  {
+    if (theMap.IsBound(theSurf))
+      aPS = Handle(ShapePersistent_Geom::Surface)::DownCast(theMap.Find(theSurf));
+    else
+    {
+      Handle(Cylindrical) aPCyl = new Cylindrical;
+      aPCyl->myTransient = theSurf;
+      aPS = aPCyl;
+    }
+  }
+  return aPS;
+}
+
+//=======================================================================
+// Spherical
+//=======================================================================
+template<>
+Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom::subBase_gp<ShapePersistent_Geom::Surface, gp_Ax3>,
+                                                Geom_SphericalSurface,
+                                                gp_Sphere>
+  ::PName() const { return "PGeom_SphericalSurface"; }
+
+template<>
+void ShapePersistent_Geom::instance<ShapePersistent_Geom::subBase_gp<ShapePersistent_Geom::Surface, gp_Ax3>,
+                                    Geom_SphericalSurface,
+                                    gp_Sphere>
+  ::Write(StdObjMgt_WriteData& theWriteData) const
+{
+  Handle(Geom_SphericalSurface) aMyGeom =
+    Handle(Geom_SphericalSurface)::DownCast(myTransient);
+  theWriteData << aMyGeom->Sphere();
+}
+
+Handle(ShapePersistent_Geom::Surface) 
+ShapePersistent_Geom_Surface::Translate(const Handle(Geom_SphericalSurface)& theSurf,
+                                        StdObjMgt_TransientPersistentMap& theMap)
+{
+  Handle(ShapePersistent_Geom::Surface) aPS;
+  if (!theSurf.IsNull())
+  {
+    if (theMap.IsBound(theSurf))
+      aPS = Handle(ShapePersistent_Geom::Surface)::DownCast(theMap.Find(theSurf));
+    else
+    {
+      Handle(Spherical) aPSph = new Spherical;
+      aPSph->myTransient = theSurf;
+      aPS = aPSph;
+    }
+  }
+  return aPS;
+}
+
+//=======================================================================
+// Toroidal
+//=======================================================================
+template<>
+Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom::subBase_gp<ShapePersistent_Geom::Surface, gp_Ax3>,
+                                                Geom_ToroidalSurface,
+                                                gp_Torus>
+  ::PName() const { return "PGeom_ToroidalSurface"; }
+
+template<>
+void ShapePersistent_Geom::instance<ShapePersistent_Geom::subBase_gp<ShapePersistent_Geom::Surface, gp_Ax3>,
+                                    Geom_ToroidalSurface,
+                                    gp_Torus>
+  ::Write(StdObjMgt_WriteData& theWriteData) const
+{
+  Handle(Geom_ToroidalSurface) aMyGeom =
+    Handle(Geom_ToroidalSurface)::DownCast(myTransient);
+  theWriteData << aMyGeom->Torus();
+}
+
+Handle(ShapePersistent_Geom::Surface) 
+ShapePersistent_Geom_Surface::Translate(const Handle(Geom_ToroidalSurface)& theSurf,
+                                        StdObjMgt_TransientPersistentMap& theMap)
+{
+  Handle(ShapePersistent_Geom::Surface) aPS;
+  if (!theSurf.IsNull())
+  {
+    if (theMap.IsBound(theSurf))
+      aPS = Handle(ShapePersistent_Geom::Surface)::DownCast(theMap.Find(theSurf));
+    else
+    {
+      Handle(Toroidal) aPTor = new Toroidal;
+      aPTor->myTransient = theSurf;
+      aPS = aPTor;
+    }
+  }
+  return aPS;
+}
+
+//=======================================================================
+// LinearExtrusion
+//=======================================================================
+Handle(ShapePersistent_Geom::Surface)
+ShapePersistent_Geom_Surface::Translate(const Handle(Geom_SurfaceOfLinearExtrusion)& theSurf,
+                                        StdObjMgt_TransientPersistentMap& theMap)
+{
+  Handle(ShapePersistent_Geom::Surface) aPS;
+  if (!theSurf.IsNull())
+  {
+    if (theMap.IsBound(theSurf))
+      aPS = Handle(ShapePersistent_Geom::Surface)::DownCast(theMap.Find(theSurf));
+    else
+    {
+      Handle(LinearExtrusion) aPLE = new LinearExtrusion;
+      Handle(pLinearExtrusion) aPpLE = new pLinearExtrusion;
+      aPpLE->myDirection = theSurf->Direction();
+      aPpLE->myBasisCurve = ShapePersistent_Geom::Translate(theSurf->BasisCurve(), theMap);
+      aPLE->myPersistent = aPpLE;
+      aPS = aPLE;
+    }
+  }
+  return aPS;
+}
+
+//=======================================================================
+// Revolution
+//=======================================================================
+Handle(ShapePersistent_Geom::Surface)
+ShapePersistent_Geom_Surface::Translate(const Handle(Geom_SurfaceOfRevolution)& theSurf,
+                                        StdObjMgt_TransientPersistentMap& theMap)
+{
+  Handle(ShapePersistent_Geom::Surface) aPS;
+  if (!theSurf.IsNull())
+  {
+    if (theMap.IsBound(theSurf))
+      aPS = Handle(ShapePersistent_Geom::Surface)::DownCast(theMap.Find(theSurf));
+    else
+    {
+      Handle(Revolution) aPR = new Revolution;
+      Handle(pRevolution) aPpR = new pRevolution;
+      aPpR->myLocation = theSurf->Location();
+      aPpR->myDirection = theSurf->Direction();
+      aPpR->myBasisCurve = ShapePersistent_Geom::Translate(theSurf->BasisCurve(), theMap);
+      aPR->myPersistent = aPpR;
+      aPS = aPR;
+    }
+  }
+  return aPS;
+}
+
+//=======================================================================
+// 
+//=======================================================================
+Handle(ShapePersistent_Geom::Surface)
+ShapePersistent_Geom_Surface::Translate(const Handle(Geom_BezierSurface)& theSurf,
+                                        StdObjMgt_TransientPersistentMap& theMap)
+{
+  Handle(ShapePersistent_Geom::Surface) aPS;
+  if (!theSurf.IsNull())
+  {
+    if (theMap.IsBound(theSurf))
+      aPS = Handle(ShapePersistent_Geom::Surface)::DownCast(theMap.Find(theSurf));
+    else
+    {
+      Handle(Bezier) aPB = new Bezier;
+      Handle(pBezier) aPpB = new pBezier;
+      aPpB->myURational = theSurf->IsURational();
+      aPpB->myVRational = theSurf->IsVRational();
+      aPpB->myPoles = StdLPersistent_HArray2::Translate<TColgp_HArray2OfPnt>("PColgp_HArray2OfPnt", theSurf->Poles());
+      if (theSurf->IsURational() || theSurf->IsVRational()) {
+        aPpB->myWeights = StdLPersistent_HArray2::Translate<TColStd_HArray2OfReal>(*theSurf->Weights());
+      }
+      aPB->myPersistent = aPpB;
+      aPS = aPB;
+    }
+  }
+  return aPS;
+}
+
+//=======================================================================
+// BSpline
+//=======================================================================
+Handle(ShapePersistent_Geom::Surface)
+ShapePersistent_Geom_Surface::Translate(const Handle(Geom_BSplineSurface)& theSurf,
+                                        StdObjMgt_TransientPersistentMap& theMap)
+{
+  Handle(ShapePersistent_Geom::Surface) aPS;
+  if (!theSurf.IsNull())
+  {
+    if (theMap.IsBound(theSurf))
+      aPS = Handle(ShapePersistent_Geom::Surface)::DownCast(theMap.Find(theSurf));
+    else
+    {
+      Handle(BSpline) aPBS = new BSpline;
+      Handle(pBSpline) aPpBS = new pBSpline;
+      aPpBS->myURational = theSurf->IsURational();
+      aPpBS->myVRational = theSurf->IsVRational();
+      aPpBS->myUPeriodic = theSurf->IsUPeriodic();
+      aPpBS->myVPeriodic = theSurf->IsVPeriodic();
+      aPpBS->myUSpineDegree = theSurf->UDegree();
+      aPpBS->myVSpineDegree = theSurf->VDegree();
+      aPpBS->myPoles = StdLPersistent_HArray2::Translate<TColgp_HArray2OfPnt>("PColgp_HArray2OfPnt", theSurf->Poles());
+      if (theSurf->IsURational() || theSurf->IsVRational()) {
+        aPpBS->myWeights = StdLPersistent_HArray2::Translate<TColStd_HArray2OfReal>(*theSurf->Weights());
+      }
+      aPpBS->myUKnots = StdLPersistent_HArray1::Translate<TColStd_HArray1OfReal>(theSurf->UKnots());
+      aPpBS->myVKnots = StdLPersistent_HArray1::Translate<TColStd_HArray1OfReal>(theSurf->VKnots());
+      aPpBS->myUMultiplicities = StdLPersistent_HArray1::Translate<TColStd_HArray1OfInteger>(theSurf->UMultiplicities());
+      aPpBS->myVMultiplicities = StdLPersistent_HArray1::Translate<TColStd_HArray1OfInteger>(theSurf->VMultiplicities());
+
+      aPBS->myPersistent = aPpBS;
+      aPS = aPBS;
+    }
+  }
+  return aPS;
+}
+
+//=======================================================================
+// RectangularTrimmed
+//=======================================================================
+Handle(ShapePersistent_Geom::Surface)
+ShapePersistent_Geom_Surface::Translate(const Handle(Geom_RectangularTrimmedSurface)& theSurf,
+                                        StdObjMgt_TransientPersistentMap& theMap)
+{
+  Handle(ShapePersistent_Geom::Surface) aPS;
+  if (!theSurf.IsNull())
+  {
+    if (theMap.IsBound(theSurf))
+      aPS = Handle(ShapePersistent_Geom::Surface)::DownCast(theMap.Find(theSurf));
+    else
+    {
+      Handle(RectangularTrimmed) aPRT = new RectangularTrimmed;
+      Handle(pRectangularTrimmed) aPpRT = new pRectangularTrimmed;
+      theSurf->Bounds(aPpRT->myFirstU, aPpRT->myLastU, aPpRT->myFirstV, aPpRT->myLastV);
+      aPpRT->myBasisSurface = ShapePersistent_Geom::Translate(theSurf->BasisSurface(), theMap);
+      aPRT->myPersistent = aPpRT;
+      aPS = aPRT;
+    }
+  }
+  return aPS;
+}
+
+//=======================================================================
+// Offset
+//=======================================================================
+Handle(ShapePersistent_Geom::Surface)
+ShapePersistent_Geom_Surface::Translate(const Handle(Geom_OffsetSurface)& theSurf,
+                                        StdObjMgt_TransientPersistentMap& theMap)
+{
+  Handle(ShapePersistent_Geom::Surface) aPS;
+  if (!theSurf.IsNull())
+  {
+    if (theMap.IsBound(theSurf))
+      aPS = Handle(ShapePersistent_Geom::Surface)::DownCast(theMap.Find(theSurf));
+    else
+    {
+      Handle(Offset) aPO = new Offset;
+      Handle(pOffset) aPpO = new pOffset;
+      aPpO->myOffsetValue = theSurf->Offset();
+      aPpO->myBasisSurface = ShapePersistent_Geom::Translate(theSurf->BasisSurface(), theMap);
+      aPO->myPersistent = aPpO;
+      aPS = aPO;
+    }
+  }
+  return aPS;
+}
index fd48747..02f56ab 100644 (file)
@@ -15,6 +15,8 @@
 #ifndef _ShapePersistent_Geom_Surface_HeaderFile
 #define _ShapePersistent_Geom_Surface_HeaderFile
 
+#include <StdObjMgt_TransientPersistentMap.hxx>
+
 #include <ShapePersistent_Geom.hxx>
 #include <ShapePersistent_HArray2.hxx>
 #include <StdLPersistent_HArray1.hxx>
 #include <Geom_CylindricalSurface.hxx>
 #include <Geom_SphericalSurface.hxx>
 #include <Geom_ToroidalSurface.hxx>
+#include <Geom_SurfaceOfLinearExtrusion.hxx>
+#include <Geom_SurfaceOfRevolution.hxx>
+#include <Geom_BezierSurface.hxx>
+#include <Geom_BSplineSurface.hxx>
+#include <Geom_RectangularTrimmedSurface.hxx>
+#include <Geom_OffsetSurface.hxx>
 
 #include <gp_Ax3.hxx>
 #include <gp_Cone.hxx>
@@ -42,31 +50,54 @@ class ShapePersistent_Geom_Surface : private ShapePersistent_Geom
 
   class pSweptData
   {
+    friend class ShapePersistent_Geom_Surface;
+
   public:
     inline void Read (StdObjMgt_ReadData& theReadData)
       { theReadData >> myBasisCurve >> myDirection; }
+    inline void Write (StdObjMgt_WriteData& theWriteData) const
+      { theWriteData << myBasisCurve << myDirection; }
+    inline void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
+      { theChildren.Append(myBasisCurve); }
 
   protected:
     Handle(Curve) myBasisCurve;
     gp_Dir        myDirection;
   };
 
-  struct pSwept : pBase, pSweptData {};
+  struct pSwept : pBase, pSweptData 
+  {
+    inline Standard_CString PName() const 
+      { return "PGeom_SweptSurface"; }
+  };
 
   class pLinearExtrusion : public pSwept
   {
+    friend class ShapePersistent_Geom_Surface;
+
   public:
     virtual Handle(Geom_Surface) Import() const;
+    inline Standard_CString PName() const 
+      { return "PGeom_SurfaceOfLinearExtrusion"; }
   };
 
   class pRevolution : public pSwept
   {
+    friend class ShapePersistent_Geom_Surface;
+
   public:
     inline void Read (StdObjMgt_ReadData& theReadData)
     {
       pSwept::Read (theReadData);
       theReadData >> myLocation;
     }
+    inline void Write (StdObjMgt_WriteData& theWriteData) const
+    {
+      pSwept::Write(theWriteData);
+      theWriteData << myLocation;
+    }
+    inline Standard_CString PName() const 
+      { return "PGeom_SurfaceOfRevolution"; }
 
     virtual Handle(Geom_Surface) Import() const;
 
@@ -78,9 +109,20 @@ class ShapePersistent_Geom_Surface : private ShapePersistent_Geom
 
   class pBezier : public pBounded
   {
+    friend class ShapePersistent_Geom_Surface;
+
   public:
     inline void Read (StdObjMgt_ReadData& theReadData)
       { theReadData >> myURational >> myVRational >> myPoles >> myWeights; }
+    inline void Write (StdObjMgt_WriteData& theWriteData) const
+      { theWriteData << myURational << myVRational << myPoles << myWeights; }
+    inline void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
+    {
+      theChildren.Append(myPoles);
+      theChildren.Append(myWeights);
+    }
+    inline Standard_CString PName() const 
+      { return "PGeom_BezierSurface"; }
 
     virtual Handle(Geom_Surface) Import() const;
 
@@ -93,6 +135,8 @@ class ShapePersistent_Geom_Surface : private ShapePersistent_Geom
 
   class pBSpline : public pBounded
   {
+    friend class ShapePersistent_Geom_Surface;
+
   public:
     inline void Read (StdObjMgt_ReadData& theReadData)
     {
@@ -104,6 +148,27 @@ class ShapePersistent_Geom_Surface : private ShapePersistent_Geom
       theReadData >> myUKnots >> myVKnots;
       theReadData >> myUMultiplicities >> myVMultiplicities;
     }
+    inline void Write (StdObjMgt_WriteData& theWriteData) const
+    {
+      theWriteData << myURational << myVRational;
+      theWriteData << myUPeriodic << myVPeriodic;
+      theWriteData << myUSpineDegree << myVSpineDegree;
+      theWriteData << myPoles;
+      theWriteData << myWeights;
+      theWriteData << myUKnots << myVKnots;
+      theWriteData << myUMultiplicities << myVMultiplicities;
+    }
+    inline void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
+    {
+      theChildren.Append(myPoles);
+      theChildren.Append(myWeights);
+      theChildren.Append(myUKnots);
+      theChildren.Append(myVKnots);
+      theChildren.Append(myUMultiplicities);
+      theChildren.Append(myVMultiplicities);
+    }
+    inline Standard_CString PName() const 
+      { return "PGeom_BSplineSurface"; }
 
     virtual Handle(Geom_Surface) Import() const;
 
@@ -124,12 +189,23 @@ class ShapePersistent_Geom_Surface : private ShapePersistent_Geom
 
   class pRectangularTrimmed : public pBounded
   {
+    friend class ShapePersistent_Geom_Surface;
+
   public:
     inline void Read (StdObjMgt_ReadData& theReadData)
     {
       theReadData >> myBasisSurface;
       theReadData >> myFirstU >> myLastU >> myFirstV >> myLastV;
     }
+    inline void Write (StdObjMgt_WriteData& theWriteData) const
+    {
+      theWriteData << myBasisSurface;
+      theWriteData << myFirstU << myLastU << myFirstV << myLastV;
+    }
+    inline void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
+      { theChildren.Append(myBasisSurface); }
+    inline Standard_CString PName() const 
+      { return "PGeom_RectangularTrimmedSurface"; }
 
     virtual Handle(Geom_Surface) Import() const;
 
@@ -143,9 +219,17 @@ class ShapePersistent_Geom_Surface : private ShapePersistent_Geom
 
   class pOffset : public pBase
   {
+    friend class ShapePersistent_Geom_Surface;
+
   public:
     inline void Read (StdObjMgt_ReadData& theReadData)
       { theReadData >> myBasisSurface >> myOffsetValue; }
+    inline void Write (StdObjMgt_WriteData& theWriteData) const
+      { theWriteData << myBasisSurface << myOffsetValue; }
+    inline void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
+      { theChildren.Append(myBasisSurface); }
+    inline Standard_CString PName() const 
+      { return "PGeom_OffsetSurface"; }
 
     virtual Handle(Geom_Surface) Import() const;
 
@@ -172,6 +256,124 @@ public:
   typedef Delayed<Bounded, pRectangularTrimmed>                      RectangularTrimmed;
 
   typedef Delayed<Surface, pOffset>                                  Offset;
+
+public:
+  //! Create a persistent object for a plane
+  Standard_EXPORT static Handle(Surface) Translate (const Handle(Geom_Plane)& theSurf,
+                                                    StdObjMgt_TransientPersistentMap& theMap);
+  //! Create a persistent object for a cylinder
+  Standard_EXPORT static Handle(Surface) Translate (const Handle(Geom_CylindricalSurface)& theSurf,
+                                                    StdObjMgt_TransientPersistentMap& theMap);
+  //! Create a persistent object for a cone
+  Standard_EXPORT static Handle(Surface) Translate (const Handle(Geom_ConicalSurface)& theSurf,
+                                                    StdObjMgt_TransientPersistentMap& theMap);
+  //! Create a persistent object for a sphere
+  Standard_EXPORT static Handle(Surface) Translate (const Handle(Geom_SphericalSurface)& theSurf,
+                                                    StdObjMgt_TransientPersistentMap& theMap);
+  //! Create a persistent object for a torus
+  Standard_EXPORT static Handle(Surface) Translate (const Handle(Geom_ToroidalSurface)& theSurf,
+                                                    StdObjMgt_TransientPersistentMap& theMap);
+  //! Create a persistent object for a surface of linear extrusion
+  Standard_EXPORT static Handle(Surface) Translate (const Handle(Geom_SurfaceOfLinearExtrusion)& theSurf,
+                                                    StdObjMgt_TransientPersistentMap& theMap);
+  //! Create a persistent object for a surface of evolution
+  Standard_EXPORT static Handle(Surface) Translate (const Handle(Geom_SurfaceOfRevolution)& theSurf,
+                                                    StdObjMgt_TransientPersistentMap& theMap);
+  //! Create a persistent object for a Bezier surface
+  Standard_EXPORT static Handle(Surface) Translate (const Handle(Geom_BezierSurface)& theSurf,
+                                                    StdObjMgt_TransientPersistentMap& theMap);
+  //! Create a persistent object for a BSpline surface
+  Standard_EXPORT static Handle(Surface) Translate (const Handle(Geom_BSplineSurface)& theSurf,
+                                                    StdObjMgt_TransientPersistentMap& theMap);
+  //! Create a persistent object for a rectangylar trimmed surface
+  Standard_EXPORT static Handle(Surface) Translate (const Handle(Geom_RectangularTrimmedSurface)& theSurf,
+                                                    StdObjMgt_TransientPersistentMap& theMap);
+  //! Create a persistent object for an offset surface 
+  Standard_EXPORT static Handle(Surface) Translate (const Handle(Geom_OffsetSurface)& theSurf,
+                                                    StdObjMgt_TransientPersistentMap& theMap);
 };
 
+//=======================================================================
+// Elementary
+//=======================================================================
+template<>
+Standard_CString ShapePersistent_Geom::subBase_gp<ShapePersistent_Geom::Surface, 
+                                                  gp_Ax3>
+  ::PName() const;
+
+//=======================================================================
+// Plane
+//=======================================================================
+template<>
+Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom::subBase_gp<ShapePersistent_Geom::Surface, gp_Ax3>, 
+                                                Geom_Plane, 
+                                                gp_Ax3>
+  ::PName() const;
+
+template<>
+void ShapePersistent_Geom::instance<ShapePersistent_Geom::subBase_gp<ShapePersistent_Geom::Surface, gp_Ax3>,
+                                    Geom_Plane,
+                                    gp_Ax3>
+  ::Write(StdObjMgt_WriteData& theWriteData) const;
+
+//=======================================================================
+// Conical
+//=======================================================================
+template<>
+Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom::subBase_gp<ShapePersistent_Geom::Surface, gp_Ax3>,
+                                                Geom_ConicalSurface,
+                                                gp_Cone>
+  ::PName() const;
+
+template<>
+void ShapePersistent_Geom::instance<ShapePersistent_Geom::subBase_gp<ShapePersistent_Geom::Surface, gp_Ax3>,
+                                    Geom_ConicalSurface,
+                                    gp_Cone>
+  ::Write(StdObjMgt_WriteData& theWriteData) const;
+
+//=======================================================================
+// Cylindrical
+//=======================================================================
+template<>
+Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom::subBase_gp<ShapePersistent_Geom::Surface, gp_Ax3>,
+                                                Geom_CylindricalSurface,
+                                                gp_Cylinder>
+  ::PName() const;
+
+template<>
+void ShapePersistent_Geom::instance<ShapePersistent_Geom::subBase_gp<ShapePersistent_Geom::Surface, gp_Ax3>,
+                                    Geom_CylindricalSurface,
+                                    gp_Cylinder>
+  ::Write(StdObjMgt_WriteData& theWriteData) const;
+
+//=======================================================================
+// Spherical
+//=======================================================================
+template<>
+Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom::subBase_gp<ShapePersistent_Geom::Surface, gp_Ax3>,
+                                                Geom_SphericalSurface,
+                                                gp_Sphere>
+  ::PName() const;
+
+template<>
+void ShapePersistent_Geom::instance<ShapePersistent_Geom::subBase_gp<ShapePersistent_Geom::Surface, gp_Ax3>,
+                                    Geom_SphericalSurface,
+                                    gp_Sphere>
+  ::Write(StdObjMgt_WriteData& theWriteData) const;
+
+//=======================================================================
+// Toroidal
+//=======================================================================
+template<>
+Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom::subBase_gp<ShapePersistent_Geom::Surface, gp_Ax3>,
+                                                Geom_ToroidalSurface,
+                                                gp_Torus>
+  ::PName() const;
+
+template<>
+void ShapePersistent_Geom::instance<ShapePersistent_Geom::subBase_gp<ShapePersistent_Geom::Surface, gp_Ax3>,
+                                    Geom_ToroidalSurface,
+                                    gp_Torus>
+  ::Write(StdObjMgt_WriteData& theWriteData) const;
+
 #endif
index d25a7f5..6ddbf7c 100644 (file)
@@ -49,7 +49,7 @@ public:
 };
 
 inline StdObjMgt_ReadData& operator >>
-  (StdObjMgt_ReadData& theReadData, Poly_Triangle& theTriangle)
+  (StdObjMgt_ReadData::Object theReadData, Poly_Triangle& theTriangle)
 {
   Standard_Integer N1, N2, N3;
   theReadData >> N1 >> N2 >> N3;
@@ -57,4 +57,13 @@ inline StdObjMgt_ReadData& operator >>
   return theReadData;
 }
 
+inline StdObjMgt_WriteData& operator <<
+  (StdObjMgt_WriteData::Object theWriteData, const Poly_Triangle& theTriangle)
+{
+  Standard_Integer N1, N2, N3;
+  theTriangle.Get(N1, N2, N3);
+  theWriteData << N1 << N2 << N3;
+  return theWriteData;
+}
+
 #endif
index 35af5f9..c6e5556 100644 (file)
@@ -11,8 +11,9 @@
 // Alternatively, this file may be used under the terms of Open CASCADE
 // commercial license or contractual agreement.
 
-#include <ShapePersistent_HSequence.hxx>
 #include <StdObjMgt_ReadData.hxx>
+#include <StdObjMgt_WriteData.hxx>
+#include <ShapePersistent_HSequence.hxx>
 
 
 template <class SequenceClass>
@@ -23,6 +24,13 @@ void ShapePersistent_HSequence::node<SequenceClass>::Read
 }
 
 template <class SequenceClass>
+void ShapePersistent_HSequence::node<SequenceClass>::Write
+  (StdObjMgt_WriteData& theWriteData) const
+{
+  theWriteData << myPreviuos << myItem << myNext;
+}
+
+template <class SequenceClass>
 void ShapePersistent_HSequence::instance<SequenceClass>::Read
   (StdObjMgt_ReadData& theReadData)
 {
@@ -30,6 +38,13 @@ void ShapePersistent_HSequence::instance<SequenceClass>::Read
 }
 
 template <class SequenceClass>
+void ShapePersistent_HSequence::instance<SequenceClass>::Write
+  (StdObjMgt_WriteData& theWriteData) const
+{
+  theWriteData << myFirst << myLast << mySize;
+}
+
+template <class SequenceClass>
 Handle(SequenceClass)
   ShapePersistent_HSequence::instance<SequenceClass>::Import() const
 {
@@ -50,3 +65,48 @@ template class ShapePersistent_HSequence::instance<TColgp_HSequenceOfXYZ>;
 template class ShapePersistent_HSequence::instance<TColgp_HSequenceOfPnt>;
 template class ShapePersistent_HSequence::instance<TColgp_HSequenceOfDir>;
 template class ShapePersistent_HSequence::instance<TColgp_HSequenceOfVec>;
+
+
+//=======================================================================
+// XYZ 
+//=======================================================================
+template<>
+Standard_CString ShapePersistent_HSequence::instance<TColgp_HSequenceOfXYZ>
+  ::PName() const { return "PColgp_HSequenceOfXYZ"; }
+
+template<>
+Standard_CString ShapePersistent_HSequence::node<TColgp_HSequenceOfXYZ>
+  ::PName() const { return "PColgp_SeqNodeOfHSequenceOfXYZ"; }
+
+//=======================================================================
+// Pnt 
+//=======================================================================
+template<>
+Standard_CString ShapePersistent_HSequence::instance<TColgp_HSequenceOfPnt>
+  ::PName() const { return "PColgp_HSequenceOfPnt"; }
+
+template<>
+Standard_CString ShapePersistent_HSequence::node<TColgp_HSequenceOfPnt>
+  ::PName() const { return "PColgp_SeqNodeOfHSequenceOfPnt"; }
+
+//=======================================================================
+// Dir 
+//=======================================================================
+template<>
+Standard_CString ShapePersistent_HSequence::instance<TColgp_HSequenceOfDir>
+  ::PName() const { return "PColgp_HSequenceOfDir"; }
+
+template<>
+Standard_CString ShapePersistent_HSequence::node<TColgp_HSequenceOfDir>
+  ::PName() const { return "PColgp_SeqNodeOfHSequenceOffDir"; }
+
+//=======================================================================
+// Vec 
+//=======================================================================
+template<>
+Standard_CString ShapePersistent_HSequence::instance<TColgp_HSequenceOfVec>
+  ::PName() const { return "PColgp_HSequenceOfVec"; }
+
+template<>
+Standard_CString ShapePersistent_HSequence::node<TColgp_HSequenceOfVec>
+  ::PName() const { return "PColgp_SeqNodeOfHSequenceOfVec"; }
index 87d5dd6..c22c1ed 100644 (file)
@@ -15,6 +15,8 @@
 #ifndef _ShapePersistent_HSequence_HeaderFile
 #define _ShapePersistent_HSequence_HeaderFile
 
+#include <Standard_NotImplemented.hxx>
+
 #include <StdObjMgt_Persistent.hxx>
 #include <StdObject_gp_Vectors.hxx>
 
@@ -36,6 +38,23 @@ class ShapePersistent_HSequence
     //! Read persistent data from a file.
     Standard_EXPORT virtual void Read (StdObjMgt_ReadData& theReadData);
 
+    //! Write persistent data to a file.
+    Standard_EXPORT virtual void Write (StdObjMgt_WriteData& theWriteData) const;
+
+    //! Gets persistent objects
+    Standard_EXPORT virtual void PChildren (SequenceOfPersistent& theChildren) const
+    {
+      theChildren.Append(this->myPreviuos);
+      theChildren.Append(this->myNext);
+    }
+
+    //! Returns persistent type name
+    Standard_EXPORT virtual Standard_CString PName() const
+    {
+      Standard_NotImplemented::Raise("ShapePersistent_HSequence::node::PName - not implemented");
+      return "";
+    }
+
     const Handle(node)& Previuos() const  { return myPreviuos; } 
     const Handle(node)& Next()     const  { return myNext; } 
     const ItemType&     Item()     const  { return myItem; }
@@ -56,6 +75,23 @@ class ShapePersistent_HSequence
     //! Read persistent data from a file.
     Standard_EXPORT virtual void Read (StdObjMgt_ReadData& theReadData);
 
+    //! Write persistent data to a file.
+    Standard_EXPORT virtual void Write (StdObjMgt_WriteData& theWriteData) const;
+
+    //! Gets persistent objects
+    Standard_EXPORT virtual void PChildren(SequenceOfPersistent& theChildren) const
+    {
+      theChildren.Append(this->myFirst);
+      theChildren.Append(this->myLast);
+    }
+
+    //! Returns persistent type name
+    Standard_EXPORT virtual Standard_CString PName() const
+    {
+      Standard_NotImplemented::Raise("ShapePersistent_HSequence::instance::PName - not implemented");
+      return "";
+    }
+
     //! Import transient object from the persistent data.
     Standard_EXPORT Handle(SequenceClass) Import() const;
 
@@ -72,4 +108,48 @@ public:
   typedef instance<TColgp_HSequenceOfVec> Vec;
 };
 
+//=======================================================================
+// XYZ 
+//=======================================================================
+template<>
+Standard_CString ShapePersistent_HSequence::instance<TColgp_HSequenceOfXYZ>
+  ::PName() const;
+
+template<>
+Standard_CString ShapePersistent_HSequence::node<TColgp_HSequenceOfXYZ>
+  ::PName() const;
+
+//=======================================================================
+// Pnt 
+//=======================================================================
+template<>
+Standard_CString ShapePersistent_HSequence::instance<TColgp_HSequenceOfPnt>
+  ::PName() const;
+
+template<>
+Standard_CString ShapePersistent_HSequence::node<TColgp_HSequenceOfPnt>
+  ::PName() const;
+
+//=======================================================================
+// Dir 
+//=======================================================================
+template<>
+Standard_CString ShapePersistent_HSequence::instance<TColgp_HSequenceOfDir>
+  ::PName() const;
+
+template<>
+Standard_CString ShapePersistent_HSequence::node<TColgp_HSequenceOfDir>
+  ::PName() const;
+
+//=======================================================================
+// Vec 
+//=======================================================================
+template<>
+Standard_CString ShapePersistent_HSequence::instance<TColgp_HSequenceOfVec>
+  ::PName() const;
+
+template<>
+Standard_CString ShapePersistent_HSequence::node<TColgp_HSequenceOfVec>
+  ::PName() const;
+
 #endif
index 8691385..f471c49 100644 (file)
@@ -12,6 +12,7 @@
 // commercial license or contractual agreement.
 
 #include <ShapePersistent_Poly.hxx>
+#include <ShapePersistent_HArray1.hxx>
 
 #include <Poly_Polygon2D.hxx>
 #include <Poly_Polygon3D.hxx>
 #include <Poly_Triangulation.hxx>
 
 
+void ShapePersistent_Poly::pPolygon2D::PChildren
+  (StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
+{
+  theChildren.Append(myNodes);
+}
+
 Handle(Poly_Polygon2D) ShapePersistent_Poly::pPolygon2D::Import() const
 {
   if (myNodes.IsNull())
@@ -29,6 +36,13 @@ Handle(Poly_Polygon2D) ShapePersistent_Poly::pPolygon2D::Import() const
   return aPolygon;
 }
 
+void ShapePersistent_Poly::pPolygon3D::PChildren
+  (StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
+{
+  theChildren.Append(myNodes);
+  theChildren.Append(myParameters);
+}
+
 Handle(Poly_Polygon3D) ShapePersistent_Poly::pPolygon3D::Import() const
 {
   if (myNodes.IsNull() || myParameters.IsNull())
@@ -40,6 +54,13 @@ Handle(Poly_Polygon3D) ShapePersistent_Poly::pPolygon3D::Import() const
   return aPolygon;
 }
 
+void ShapePersistent_Poly::pPolygonOnTriangulation::PChildren
+  (StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
+{
+  theChildren.Append(myNodes);
+  theChildren.Append(myParameters);
+}
+
 Handle(Poly_PolygonOnTriangulation)
   ShapePersistent_Poly::pPolygonOnTriangulation::Import() const
 {
@@ -59,12 +80,20 @@ Handle(Poly_PolygonOnTriangulation)
   return aPolygon;
 }
 
+void ShapePersistent_Poly::pTriangulation::PChildren
+  (StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
+{
+  theChildren.Append(myNodes);
+  theChildren.Append(myUVNodes);
+  theChildren.Append(myTriangles);
+}
+
 Handle(Poly_Triangulation) ShapePersistent_Poly::pTriangulation::Import() const
 {
   Handle(Poly_Triangulation) aTriangulation;
 
 // Triangulation is not used
-#if 0
+#if 1
   if (myNodes && myTriangles)
   {
     if (myUVNodes)
@@ -81,3 +110,104 @@ Handle(Poly_Triangulation) ShapePersistent_Poly::pTriangulation::Import() const
 
   return aTriangulation;
 }
+
+Handle(ShapePersistent_Poly::Polygon2D) 
+ShapePersistent_Poly::Translate(const Handle(Poly_Polygon2D)& thePoly,
+                                StdObjMgt_TransientPersistentMap& theMap)
+{
+  Handle(Polygon2D) aPP;
+  if (!thePoly.IsNull()) 
+  {
+    if (theMap.IsBound(thePoly))
+      aPP = Handle(Polygon2D)::DownCast(theMap.Find(thePoly));
+    else 
+    {
+      aPP = new Polygon2D;
+      aPP->myPersistent = new pPolygon2D;
+      aPP->myPersistent->myDeflection = thePoly->Deflection();
+      aPP->myPersistent->myNodes =
+        StdLPersistent_HArray1::Translate<TColgp_HArray1OfPnt2d>("PColgp_HArray1OfPnt2d", thePoly->Nodes());
+      theMap.Bind(thePoly, aPP);
+    }
+  }
+  return aPP;
+}
+
+Handle(ShapePersistent_Poly::Polygon3D) 
+ShapePersistent_Poly::Translate(const Handle(Poly_Polygon3D)& thePoly,
+                                StdObjMgt_TransientPersistentMap& theMap)
+{
+  Handle(Polygon3D) aPP = new Polygon3D;
+  if (!thePoly.IsNull()) 
+  {
+    if (theMap.IsBound(thePoly))
+      aPP = Handle(Polygon3D)::DownCast(theMap.Find(thePoly));
+    else 
+    {
+      aPP = new Polygon3D;
+      aPP->myPersistent = new pPolygon3D;
+      aPP->myPersistent->myDeflection = thePoly->Deflection();
+      aPP->myPersistent->myNodes =
+        StdLPersistent_HArray1::Translate<TColgp_HArray1OfPnt>("PColgp_HArray1OfPnt", thePoly->Nodes());
+      if (thePoly->HasParameters()) {
+        aPP->myPersistent->myParameters =
+          StdLPersistent_HArray1::Translate<TColStd_HArray1OfReal>(thePoly->Parameters());
+      }
+      theMap.Bind(thePoly, aPP);
+    }
+  }
+  return aPP;
+}
+
+Handle(ShapePersistent_Poly::PolygonOnTriangulation) 
+ShapePersistent_Poly::Translate(const Handle(Poly_PolygonOnTriangulation)& thePolyOnTriang,
+                                StdObjMgt_TransientPersistentMap& theMap)
+{
+  Handle(PolygonOnTriangulation) aPPonT;
+  if (!thePolyOnTriang.IsNull())
+  {
+    if (theMap.IsBound(thePolyOnTriang))
+      aPPonT = Handle(PolygonOnTriangulation)::DownCast(theMap.Find(thePolyOnTriang));
+    else
+    {
+      aPPonT = new PolygonOnTriangulation;
+      aPPonT->myPersistent = new pPolygonOnTriangulation;
+      aPPonT->myPersistent->myDeflection = thePolyOnTriang->Deflection();
+      aPPonT->myPersistent->myNodes =
+        StdLPersistent_HArray1::Translate<TColStd_HArray1OfInteger>(thePolyOnTriang->Nodes());
+      if (thePolyOnTriang->HasParameters()) {
+        aPPonT->myPersistent->myParameters =
+          StdLPersistent_HArray1::Translate<TColStd_HArray1OfReal>(thePolyOnTriang->Parameters()->Array1());
+      }
+      theMap.Bind(thePolyOnTriang, aPPonT);
+    }
+  }
+  return aPPonT;
+}
+
+Handle(ShapePersistent_Poly::Triangulation) 
+ShapePersistent_Poly::Translate(const Handle(Poly_Triangulation)& thePolyTriang,
+                                StdObjMgt_TransientPersistentMap& theMap)
+{
+  Handle(Triangulation) aPT;
+  if (!thePolyTriang.IsNull()) 
+  {
+    if (theMap.IsBound(thePolyTriang))
+      aPT = Handle(Triangulation)::DownCast(theMap.Find(thePolyTriang));
+    else 
+    {
+      aPT = new Triangulation;
+      aPT->myPersistent = new pTriangulation;
+      aPT->myPersistent->myNodes = 
+        StdLPersistent_HArray1::Translate<TColgp_HArray1OfPnt>("PColgp_HArray1OfPnt", thePolyTriang->Nodes());
+      aPT->myPersistent->myTriangles = 
+        StdLPersistent_HArray1::Translate<Poly_HArray1OfTriangle>("PPoly_HArray1OfTriangle", thePolyTriang->Triangles());
+      if (thePolyTriang->HasUVNodes()) {
+        aPT->myPersistent->myUVNodes = 
+          StdLPersistent_HArray1::Translate<TColgp_HArray1OfPnt2d>("PColgp_HArray1OfPnt2d", thePolyTriang->UVNodes());
+      }
+      theMap.Bind(thePolyTriang, aPT);
+    }
+  }
+  return aPT;
+}
index 18efeaf..8a7bca2 100644 (file)
@@ -16,7 +16,9 @@
 #define _ShapePersistent_Poly_HeaderFile
 
 #include <StdObjMgt_SharedObject.hxx>
+#include <StdObjMgt_TransientPersistentMap.hxx>
 #include <StdObjMgt_ReadData.hxx>
+#include <StdObjMgt_WriteData.hxx>
 #include <StdLPersistent_HArray1.hxx>
 #include <ShapePersistent_HArray1.hxx>
 
@@ -30,9 +32,15 @@ class ShapePersistent_Poly : private StdObjMgt_SharedObject
 {
   class pPolygon2D : public Standard_Transient
   {
+    friend class ShapePersistent_Poly;
+
   public:
     inline void Read (StdObjMgt_ReadData& theReadData)
       { theReadData >> myDeflection >> myNodes; }
+    inline void Write (StdObjMgt_WriteData& theWriteData) const
+      { theWriteData << myDeflection << myNodes; }
+    Standard_EXPORT void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const;
+    inline Standard_CString PName() const { return "PPoly_Polygon2D"; }
 
     Handle(Poly_Polygon2D) Import() const;
 
@@ -43,9 +51,15 @@ class ShapePersistent_Poly : private StdObjMgt_SharedObject
 
   class pPolygon3D : public Standard_Transient
   {
+    friend class ShapePersistent_Poly;
+
   public:
     inline void Read (StdObjMgt_ReadData& theReadData)
       { theReadData >> myDeflection >> myNodes >> myParameters; }
+    inline void Write (StdObjMgt_WriteData& theWriteData) const
+      { theWriteData << myDeflection << myNodes << myParameters; }
+    Standard_EXPORT void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const;
+    inline Standard_CString PName() const { return "PPoly_Polygon3D"; }
 
     Handle(Poly_Polygon3D) Import() const;
 
@@ -57,9 +71,15 @@ class ShapePersistent_Poly : private StdObjMgt_SharedObject
 
   class pPolygonOnTriangulation : public Standard_Transient
   {
+    friend class ShapePersistent_Poly;
+
   public:
     inline void Read (StdObjMgt_ReadData& theReadData)
       { theReadData >> myDeflection >> myNodes >> myParameters; }
+    inline void Write (StdObjMgt_WriteData& theWriteData) const
+      { theWriteData << myDeflection << myNodes << myParameters; }
+    Standard_EXPORT void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const;
+    inline Standard_CString PName() const { return "PPoly_PolygonOnTriangulation"; }
 
     Handle(Poly_PolygonOnTriangulation) Import() const;
 
@@ -71,9 +91,15 @@ class ShapePersistent_Poly : private StdObjMgt_SharedObject
 
   class pTriangulation : public Standard_Transient
   {
+    friend class ShapePersistent_Poly;
+
   public:
     inline void Read (StdObjMgt_ReadData& theReadData)
       { theReadData >> myDeflection >> myNodes >> myUVNodes >> myTriangles; }
+    inline void Write (StdObjMgt_WriteData& theWriteData) const
+      { theWriteData << myDeflection << myNodes << myUVNodes << myTriangles; }
+    Standard_EXPORT void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const;
+    inline Standard_CString PName() const { return "PPoly_Triangulation"; }
 
     Handle(Poly_Triangulation) Import() const;
 
@@ -86,7 +112,7 @@ class ShapePersistent_Poly : private StdObjMgt_SharedObject
 
   template <class Persistent, class Transient>
   struct instance
-    : Delayed <DelayedBase<StdObjMgt_Persistent, Transient, Persistent> > {};
+    : public Delayed <DelayedBase<StdObjMgt_Persistent, Transient, Persistent> > {};
 
 public:
   typedef instance <pPolygon2D, Poly_Polygon2D>         Polygon2D;
@@ -94,6 +120,20 @@ public:
   typedef instance <pPolygonOnTriangulation,
                     Poly_PolygonOnTriangulation>        PolygonOnTriangulation;
   typedef instance <pTriangulation, Poly_Triangulation> Triangulation;
+
+public:
+  //! Create a persistent object for a 2D polygon
+  Standard_EXPORT static Handle(Polygon2D) Translate (const Handle(Poly_Polygon2D)& thePoly,
+                                                      StdObjMgt_TransientPersistentMap& theMap);
+  //! Create a persistent object for a 3D polygon
+  Standard_EXPORT static Handle(Polygon3D) Translate (const Handle(Poly_Polygon3D)& thePoly,
+                                                      StdObjMgt_TransientPersistentMap& theMap);
+  //! Create a persistent object for a triangulation
+  Standard_EXPORT static Handle(PolygonOnTriangulation) Translate (const Handle(Poly_PolygonOnTriangulation)& thePolyOnTriang,
+                                                                   StdObjMgt_TransientPersistentMap& theMap);
+  //! Create a persistent object for a polygon on triangulation
+  Standard_EXPORT static Handle(Triangulation) Translate(const Handle(Poly_Triangulation)& thePolyTriang,
+                                                         StdObjMgt_TransientPersistentMap& theMap);
 };
 
 #endif
index fd67472..032a9ec 100644 (file)
 // commercial license or contractual agreement.
 
 #include <ShapePersistent_TopoDS.hxx>
+#include <ShapePersistent_BRep.hxx>
 
 #include <BRep_Builder.hxx>
 
+#include <TopoDS.hxx>
+#include <TopoDS_Iterator.hxx>
+#include <TopoDS_Vertex.hxx>
+
+#include <Standard_Assert.hxx>
 
 enum
 {
@@ -26,7 +32,6 @@ enum
   ConvexMask     = 64
 };
 
-
 //=======================================================================
 //function : Read
 //purpose  : Read persistent data from a file
@@ -37,6 +42,18 @@ void ShapePersistent_TopoDS::HShape::Read (StdObjMgt_ReadData& theReadData)
   StdObject_Shape::read (theReadData);
 }
 
+void ShapePersistent_TopoDS::HShape::Write (StdObjMgt_WriteData& theWriteData) const
+{
+  theWriteData << myEntry;
+  StdObject_Shape::write (theWriteData);
+}
+
+void ShapePersistent_TopoDS::HShape::PChildren(SequenceOfPersistent& theChildren) const
+{
+  theChildren.Append(myEntry);
+  StdObject_Shape::PChildren(theChildren);
+}
+
 void ShapePersistent_TopoDS::pTBase::setFlags
   (const Handle(TopoDS_TShape)& theTShape) const
 {
@@ -94,3 +111,131 @@ template class ShapePersistent_TopoDS::pTSimple<TopoDS_TShell>;
 template class ShapePersistent_TopoDS::pTSimple<TopoDS_TSolid>;
 template class ShapePersistent_TopoDS::pTSimple<TopoDS_TCompSolid>;
 template class ShapePersistent_TopoDS::pTSimple<TopoDS_TCompound>;
+
+//=======================================================================
+//function : Translate
+//purpose  : Creates a persistent object from a shape
+//=======================================================================
+Handle(ShapePersistent_TopoDS::HShape)
+ShapePersistent_TopoDS::Translate (const TopoDS_Shape& theShape,
+                                   StdObjMgt_TransientPersistentMap& theMap,
+                                   ShapePersistent_TriangleMode theTriangleMode)
+{
+  Handle(HShape) pHShape;
+
+  if (theShape.IsNull())
+    return pHShape;
+
+  pHShape = new HShape;
+
+  if (theMap.IsBound(theShape.TShape()))
+  {
+    // found in the registered
+    Handle(StdPersistent_TopoDS::TShape) aPShape =
+      Handle(StdPersistent_TopoDS::TShape)::DownCast(theMap.Find(theShape.TShape()));
+    pHShape->myTShape = aPShape;
+  }
+  else
+  {
+    pTShape* aPTShape = 0;
+    switch (theShape.ShapeType())
+    {
+    case TopAbs_VERTEX: {
+      Handle(ShapePersistent_BRep::TVertex) aPVertex = new ShapePersistent_BRep::TVertex;
+      pHShape->myTShape = aPVertex;
+      aPVertex->myPersistent = ShapePersistent_BRep::Translate(TopoDS::Vertex(theShape), theMap);
+      aPTShape = aPVertex->myPersistent.get();
+    } break;
+    case TopAbs_EDGE: {
+      Handle(ShapePersistent_BRep::TEdge) aPEdge = new ShapePersistent_BRep::TEdge;
+      pHShape->myTShape = aPEdge;
+      aPEdge->myPersistent = ShapePersistent_BRep::Translate(TopoDS::Edge(theShape), theMap, theTriangleMode);
+      aPTShape = aPEdge->myPersistent.get();
+    } break;
+    case TopAbs_FACE: {
+      Handle(ShapePersistent_BRep::TFace) aPFace = new ShapePersistent_BRep::TFace;
+      pHShape->myTShape = aPFace;
+      aPFace->myPersistent = ShapePersistent_BRep::Translate(TopoDS::Face(theShape), theMap, theTriangleMode);
+      aPTShape = aPFace->myPersistent.get();
+    } break;
+    case TopAbs_WIRE: {
+      Handle(TWire) aPWire = new TWire;
+      pHShape->myTShape = aPWire;
+      aPWire->myPersistent = new TWire::pTObjectT;
+      aPTShape = aPWire->myPersistent.get();
+    } break;
+    case TopAbs_SHELL: {
+      Handle(TShell) aPShell = new TShell;
+      pHShape->myTShape = aPShell;
+      aPShell->myPersistent = new TShell::pTObjectT;
+      aPTShape = aPShell->myPersistent.get();
+    } break;
+    case TopAbs_SOLID: {
+      Handle(TSolid) aPSolid = new TSolid;
+      pHShape->myTShape = aPSolid;
+      aPSolid->myPersistent = new TSolid::pTObjectT;
+      aPTShape = aPSolid->myPersistent.get();
+    } break;
+    case TopAbs_COMPSOLID: {
+      Handle(TCompSolid) aPCompSolid = new TCompSolid;
+      pHShape->myTShape = aPCompSolid;
+      aPCompSolid->myPersistent = new TCompSolid::pTObjectT;
+      aPTShape = aPCompSolid->myPersistent.get();
+    } break;
+    case TopAbs_COMPOUND: {
+      Handle(TCompound) aPComp = new TCompound;
+      pHShape->myTShape = aPComp;
+      aPComp->myPersistent = new TCompound::pTObjectT;
+      aPTShape = aPComp->myPersistent.get();
+    } break;
+    
+    case TopAbs_SHAPE:
+    default:
+      Standard_ASSERT_INVOKE ("Unsupported shape type");
+      break;
+    }
+
+    // Register in the persistent map
+    theMap.Bind(theShape.TShape(), pHShape->myTShape);
+
+    // Shape flags
+    Standard_Integer aFlags = 0;
+    if (theShape.Modified())   aFlags |= ModifiedMask;
+    if (theShape.Checked())    aFlags |= CheckedMask;
+    if (theShape.Orientable()) aFlags |= OrientableMask;
+    if (theShape.Closed())     aFlags |= ClosedMask;
+    if (theShape.Infinite())   aFlags |= InfiniteMask;
+    if (theShape.Convex())     aFlags |= ConvexMask;
+    aPTShape->myFlags = aFlags;
+
+    // Copy current Shape
+    TopoDS_Shape S = theShape;
+    S.Orientation(TopAbs_FORWARD);
+    S.Location(TopLoc_Location());
+    // Count the number of <sub-shape> of the Shape's TShape
+    Standard_Integer nbElem = 0;
+    TopoDS_Iterator anItCount(S);
+    while (anItCount.More()) {
+      ++nbElem;
+      anItCount.Next();
+    }
+
+    if (nbElem > 0)
+    {
+      Handle(StdLPersistent_HArray1OfPersistent) aShapes =
+        new StdLPersistent_HArray1OfPersistent(1, nbElem);
+      // translate <sub-shapes>
+      TopoDS_Iterator anItTrans(S);
+      for (Standard_Integer i = 1; anItTrans.More(); anItTrans.Next(), ++i) {
+        aShapes->SetValue(i, Translate(anItTrans.Value(), theMap, theTriangleMode));
+      }
+      aPTShape->myShapes = StdLPersistent_HArray1::Translate<StdLPersistent_HArray1OfPersistent>
+        ("PTopoDS_HArray1OfHShape", aShapes->Array1());
+    }
+  }
+
+  pHShape->myOrient = theShape.Orientation();
+  pHShape->myLocation = StdObject_Location::Translate(theShape.Location(), theMap);
+
+  return pHShape;
+}
index de0d0b1..ec7748e 100644 (file)
 #ifndef _ShapePersistent_TopoDS_HeaderFile
 #define _ShapePersistent_TopoDS_HeaderFile
 
+#include <ShapePersistent_TriangleMode.hxx>
+
 #include <StdPersistent_TopoDS.hxx>
 #include <StdPersistent_HArray1.hxx>
 #include <StdLPersistent_HArray1.hxx>
 #include <StdObject_Shape.hxx>
+#include <StdObjMgt_TransientPersistentMap.hxx>
 
 #include <TopoDS_TWire.hxx>
 #include <TopoDS_TShell.hxx>
@@ -35,6 +38,12 @@ public:
   public:
     //! Read persistent data from a file.
     Standard_EXPORT virtual void Read (StdObjMgt_ReadData& theReadData);
+    //! Write persistent data to a file
+    Standard_EXPORT virtual void Write (StdObjMgt_WriteData& theWriteData) const;
+    //! Gets persistent child objects
+    Standard_EXPORT virtual void PChildren(SequenceOfPersistent& theChildren) const;
+    //! Returns persistent type name
+    Standard_EXPORT virtual Standard_CString PName() const { return "PTopoDS_HShape"; }
 
   private:
     Handle(StdObjMgt_Persistent) myEntry;
@@ -72,27 +81,30 @@ protected:
 private:
   template <class Target>
   class pTSimple : public pTBase
-    { virtual Handle(TopoDS_TShape) createTShape() const; };
+  { 
+    virtual Handle(TopoDS_TShape) createTShape() const; 
+  public:
+    inline Standard_CString PName() const;
+  };
 
   template <class Persistent, class ShapesArray>
   class pTObject : public Persistent
   {
     virtual void addShapes (TopoDS_Shape& theParent) const
-    {
-      pTBase::addShapesT<ShapesArray> (theParent);
-    }
+      { pTBase::addShapesT<ShapesArray> (theParent); }
   };
 
   template <class Persistent, class ShapesArray>
-  struct tObjectT : Delayed <DelayedBase<TShape, TopoDS_TShape, pTBase>,
-                             pTObject<Persistent, ShapesArray> > {};
+  struct tObjectT : public Delayed <DelayedBase<TShape, TopoDS_TShape, pTBase>,
+                                    pTObject<Persistent, ShapesArray> > 
+    { typedef pTObject<Persistent, ShapesArray> pTObjectT; };
 
 protected:
   template <class Persistent>
-  struct tObject  : tObjectT<Persistent, StdLPersistent_HArray1::Persistent> {};
+  struct tObject : public tObjectT<Persistent, StdLPersistent_HArray1::Persistent> { };
 
   template <class Persistent>
-  struct tObject1 : tObjectT<Persistent, StdPersistent_HArray1::Shape1> {};
+  struct tObject1 : public tObjectT<Persistent, StdPersistent_HArray1::Shape1> { };
 
 public:
   typedef tObject  <pTSimple<TopoDS_TWire>      > TWire;
@@ -106,6 +118,32 @@ public:
   typedef tObject1 <pTSimple<TopoDS_TSolid>     > TSolid1;
   typedef tObject1 <pTSimple<TopoDS_TCompSolid> > TCompSolid1;
   typedef tObject1 <pTSimple<TopoDS_TCompound>  > TCompound1;
+
+public:
+  //! Create a persistent object for a shape
+  Standard_EXPORT static Handle(HShape) Translate (const TopoDS_Shape& theShape,
+                                                   StdObjMgt_TransientPersistentMap& theMap,
+                                                   ShapePersistent_TriangleMode theTriangleMode);
 };
 
+template<>
+inline Standard_CString ShapePersistent_TopoDS::pTSimple<TopoDS_TWire>::PName() const 
+  { return "PTopoDS_TWire"; }
+
+template<>
+inline Standard_CString ShapePersistent_TopoDS::pTSimple<TopoDS_TShell>::PName() const
+  { return "PTopoDS_TShell"; }
+
+template<>
+inline Standard_CString ShapePersistent_TopoDS::pTSimple<TopoDS_TSolid>::PName() const
+  { return "PTopoDS_TSolid"; }
+
+template<>
+inline Standard_CString ShapePersistent_TopoDS::pTSimple<TopoDS_TCompSolid>::PName() const
+  { return "PTopoDS_TCompSolid"; }
+
+template<>
+inline Standard_CString ShapePersistent_TopoDS::pTSimple<TopoDS_TCompound>::PName() const
+  { return "PTopoDS_TCompound"; }
+
 #endif
diff --git a/src/ShapePersistent/ShapePersistent_TriangleMode.hxx b/src/ShapePersistent/ShapePersistent_TriangleMode.hxx
new file mode 100644 (file)
index 0000000..336b702
--- /dev/null
@@ -0,0 +1,14 @@
+
+#ifndef _ShapePersistent_TriangleMode_HeaderFile
+#define _ShapePersistent_TriangleMode_HeaderFile
+
+#include <Standard_PrimitiveTypes.hxx>
+
+
+enum ShapePersistent_TriangleMode
+{
+  ShapePersistent_WithTriangle,
+  ShapePersistent_WithoutTriangle
+};
+
+#endif // _ShapePersistent_TriangleMode_HeaderFile
index 9adb12e..19530a1 100644 (file)
@@ -131,8 +131,8 @@ Handle(StdObjMgt_Persistent) StdLDrivers_DocumentRetrievalDriver::read (
   NCollection_Array1<StdObjMgt_Persistent::Instantiator>
     anInstantiators (1, aTypeData.NumberOfTypes());
   {
-    StdObjMgt_MapOfInstantiators aMapOfInstantiators;
-    bindTypes (aMapOfInstantiators);
+    StdObjMgt_MapOfInstantiators aMapOfInst;
+    bindTypes (aMapOfInst);
 
     TColStd_SequenceOfAsciiString anUnknownTypes;
     Standard_Integer        aCurTypeNum;
@@ -144,7 +144,7 @@ Handle(StdObjMgt_Persistent) StdLDrivers_DocumentRetrievalDriver::read (
       aCurTypeNum  = aTypeData.Type (aCurTypeName);
 
       StdObjMgt_Persistent::Instantiator anInstantiator;
-      if (aMapOfInstantiators.Find (aCurTypeName, anInstantiator))
+      if (aMapOfInst.Find(aCurTypeName, anInstantiator))
         anInstantiators (aCurTypeNum) = anInstantiator;
       else
         anUnknownTypes.Append (aCurTypeName);
index 5276e50..7e30016 100644 (file)
@@ -13,6 +13,7 @@
 
 #include <StdLPersistent_Data.hxx>
 #include <StdObjMgt_ReadData.hxx>
+#include <StdObjMgt_WriteData.hxx>
 
 #include <TDF_Data.hxx>
 #include <TDF_Attribute.hxx>
@@ -81,6 +82,15 @@ void StdLPersistent_Data::Read (StdObjMgt_ReadData& theReadData)
 }
 
 //=======================================================================
+//function : Write
+//purpose  : Write persistent data to a file
+//=======================================================================
+void StdLPersistent_Data::Write (StdObjMgt_WriteData& theWriteData) const
+{
+  theWriteData << myVersion << myLabels << myAttributes;
+}
+
+//=======================================================================
 //function : Import
 //purpose  : Import transient data from the persistent data
 //=======================================================================
index d6d7b3d..999bee2 100644 (file)
@@ -26,6 +26,17 @@ class StdLPersistent_Data : public StdObjMgt_Persistent
 public:
   //! Read persistent data from a file.
   Standard_EXPORT virtual void Read (StdObjMgt_ReadData& theReadData);
+  //! Write persistent data to a file.
+  Standard_EXPORT virtual void Write (StdObjMgt_WriteData& theWriteData) const;
+  //! Gets persistent child objects
+  Standard_EXPORT virtual void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
+  {
+    theChildren.Append(myLabels);
+    theChildren.Append(myAttributes);
+  }
+  //! Returns persistent type name
+  Standard_EXPORT virtual Standard_CString PName() const
+    { return "PDF_Data"; }
 
   //! Import transient data from the persistent data.
   Standard_EXPORT Handle(TDF_Data) Import() const;
index cc82951..5e29e79 100644 (file)
@@ -32,6 +32,17 @@ class StdLPersistent_Dependency
     //! Read persistent data from a file.
     inline void Read (StdObjMgt_ReadData& theReadData)
       { theReadData >> myName >> myVariables; }
+    //! Write persistent data to a file.
+    inline void Write (StdObjMgt_WriteData& theWriteData) const
+      { theWriteData << myName << myVariables; }
+    //! Gets persistent child objects
+    inline void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
+    {
+      theChildren.Append(myName);
+      theChildren.Append(myVariables);
+    }
+    //! Returns persistent type name
+    Standard_CString PName() const;
 
     //! Import transient attribuite from the persistent data.
     void Import (const Handle(AttribClass)& theAttribute) const;
@@ -46,4 +57,12 @@ public:
   typedef instance<TDataStd_Relation>   Relation;
 };
 
+template<>
+inline Standard_CString StdLPersistent_Dependency::instance<TDataStd_Expression>::PName() const
+  { return "PDataStd_Expression"; }
+
+template<>
+inline Standard_CString StdLPersistent_Dependency::instance<TDataStd_Relation>::PName() const
+  { return "PDataStd_Relation"; }
+
 #endif
index b311af4..7b20456 100644 (file)
@@ -14,6 +14,7 @@
 #include <StdLPersistent_Document.hxx>
 #include <StdLPersistent_Data.hxx>
 #include <StdObjMgt_ReadData.hxx>
+#include <StdObjMgt_WriteData.hxx>
 
 #include <TDocStd_Document.hxx>
 #include <TDocStd_Owner.hxx>
@@ -29,6 +30,24 @@ void StdLPersistent_Document::Read (StdObjMgt_ReadData& theReadData)
 }
 
 //=======================================================================
+//function : Write
+//purpose  : Write persistent data to a file
+//=======================================================================
+void StdLPersistent_Document::Write (StdObjMgt_WriteData& theWriteData) const
+{
+  theWriteData << myData;
+}
+
+//=======================================================================
+//function : PChildren
+//purpose  : Gets persistent child objects
+//=======================================================================
+void StdLPersistent_Document::PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
+{
+  theChildren.Append(myData);
+}
+
+//=======================================================================
 //function : Import
 //purpose  : Import transient document from the persistent data
 //=======================================================================
index 5ce8b61..6b4318d 100644 (file)
@@ -26,6 +26,13 @@ class StdLPersistent_Document : public StdObjMgt_Persistent
 public:
   //! Read persistent data from a file.
   Standard_EXPORT virtual void Read (StdObjMgt_ReadData& theReadData);
+  //! Read persistent data from a file.
+  Standard_EXPORT virtual void Write (StdObjMgt_WriteData& theWriteData) const;
+  //! Gets persistent child objects
+  Standard_EXPORT virtual void PChildren(StdObjMgt_Persistent::SequenceOfPersistent&) const;
+  //! Returns persistent type name
+  Standard_EXPORT virtual Standard_CString PName() const
+    { return "PDocStd_Document"; }
 
   //! Import transient document from the persistent data.
   Standard_EXPORT virtual void ImportDocument
index 4d74f42..4474fd6 100644 (file)
@@ -27,6 +27,13 @@ public:
   //! Read persistent data from a file.
   inline void Read (StdObjMgt_ReadData& theReadData)
     { theReadData >> myDriverGUID >> myFailure; }
+  //! Write persistent data to a file.
+  inline void Write (StdObjMgt_WriteData& theWriteData) const
+    { theWriteData << myDriverGUID << myFailure; }
+  //! Gets persistent child objects
+  inline void PChildren(StdObjMgt_Persistent::SequenceOfPersistent&) const {}
+  //! Returns persistent type name
+  inline Standard_CString PName() const { return "PFunction_Function"; }
 
   //! Import transient attribuite from the persistent data.
   void Import (const Handle(TFunction_Function)& theAttribute) const
index 99e4e42..7318651 100644 (file)
@@ -32,3 +32,21 @@ void StdLPersistent_HArray1::base::Read (StdObjMgt_ReadData& theReadData)
   for (Standard_Integer i = aLowerBound; i <= anUpperBound; i++)
     readValue (anObjectData, i);
 }
+
+//=======================================================================
+//function : Write
+//purpose  : Write persistent data to a file
+//=======================================================================
+void StdLPersistent_HArray1::base::Write (StdObjMgt_WriteData& theWriteData) const
+{
+  Standard_Integer aLowerBound = lowerBound(), anUpperBound = upperBound();
+  theWriteData << aLowerBound << anUpperBound;
+
+  StdObjMgt_WriteData::Object anObjectData(theWriteData);
+
+  Standard_Integer aSize = anUpperBound - aLowerBound + 1;
+  anObjectData << aSize;
+
+  for (Standard_Integer i = aLowerBound; i <= anUpperBound; i++)
+    writeValue(theWriteData, i);
+}
index e24faa5..20be0e8 100644 (file)
 #ifndef _StdLPersistent_HArray1_HeaderFile
 #define _StdLPersistent_HArray1_HeaderFile
 
+#include <Standard_NotImplemented.hxx>
+#include <Standard_NullValue.hxx>
+
 #include <StdObjMgt_Persistent.hxx>
 #include <StdObjMgt_ReadData.hxx>
+#include <StdObjMgt_WriteData.hxx>
 
 #include <NCollection_DefineHArray1.hxx>
 
@@ -40,19 +44,27 @@ class StdLPersistent_HArray1
   public:
     //! Read persistent data from a file.
     Standard_EXPORT virtual void Read (StdObjMgt_ReadData& theReadData);
+    //! Write persistent data to a file.
+    Standard_EXPORT virtual void Write (StdObjMgt_WriteData& theWriteData) const;
 
   protected:
+    virtual Standard_Integer lowerBound() const = 0;
+    virtual Standard_Integer upperBound() const = 0;
     virtual void createArray (const Standard_Integer theLowerBound,
                               const Standard_Integer theUpperBound) = 0;
 
     virtual void readValue (StdObjMgt_ReadData& theReadData,
                             const Standard_Integer theIndex) = 0;
+    virtual void writeValue(StdObjMgt_WriteData& theWriteData,
+                            const Standard_Integer theIndex) const = 0;
   };
 
 protected:
   template <class ArrayClass>
   class instance : public base
   {
+    friend class StdLPersistent_HArray1;
+
   public:
     typedef Handle(ArrayClass)              ArrayHandle;
     typedef typename ArrayClass::value_type ValueType;
@@ -63,27 +75,105 @@ protected:
     const Handle(ArrayClass)& Array() const  { return myArray; }
 
   protected:
-    virtual void createArray (const Standard_Integer theLowerBound,
+    virtual Standard_Integer lowerBound() const { return myArray->Lower(); }
+    virtual Standard_Integer upperBound() const { return myArray->Upper(); }
+    virtual void createArray(const Standard_Integer theLowerBound,
                               const Standard_Integer theUpperBound)
       { myArray = new ArrayClass (theLowerBound, theUpperBound); }
 
     virtual void readValue (StdObjMgt_ReadData& theReadData,
                             const Standard_Integer theIndex)
       { theReadData >> myArray->ChangeValue (theIndex); }
+    virtual void writeValue(StdObjMgt_WriteData& theWriteData,
+                            const Standard_Integer theIndex) const
+      { theWriteData << myArray->Value(theIndex); }
+    virtual void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
+      { return PChildrenT(theChildren); }
+    virtual Standard_CString PName() const
+      { return PNameT(); }
+    Standard_CString PNameT() const 
+    {
+      Standard_NotImplemented::Raise("StdLPersistent_HArray1::instance::PName - not implemented"); 
+      return "";
+    }
+    void PChildrenT(StdObjMgt_Persistent::SequenceOfPersistent&) const {}
 
   protected:
     Handle(ArrayClass) myArray;
   };
 
+  template <class ArrayClass>
+  class named_instance : public instance<ArrayClass>
+  {
+    friend class StdLPersistent_HArray1;
+
+  public:
+    virtual Standard_CString PName() const
+    { 
+      Standard_NullValue_Raise_if(!myPName,
+        "StdLPersistent_HArray1::named_instance::PName - name not set");
+      return myPName; 
+    }
+
+  protected:
+    named_instance(Standard_CString thePName) : myPName(thePName) {}
+
+    Standard_CString myPName;
+  };
+
 public:
   typedef instance<TColStd_HArray1OfInteger>           Integer;
   typedef instance<TColStd_HArray1OfReal>              Real;
   typedef instance<TColStd_HArray1OfByte>              Byte;
   typedef instance<StdLPersistent_HArray1OfPersistent> Persistent;
+
+public:
+  template <class ArrayClass>
+  static Handle(instance<ArrayClass>) Translate(const ArrayClass& theArray)
+  {
+    Handle(instance<ArrayClass>) aPArray = new instance<ArrayClass>;
+    aPArray->myArray = new ArrayClass(theArray.Lower(), theArray.Upper());
+    for (Standard_Integer i = theArray.Lower(); i <= theArray.Upper(); ++i)
+      aPArray->myArray->ChangeValue(i) = theArray.Value(i);
+    return aPArray;
+  }
+  template <class ArrayClass>
+  static Handle(instance<ArrayClass>) Translate(Standard_CString thePName, const ArrayClass& theArray)
+  {
+    Handle(named_instance<ArrayClass>) aPArray = new named_instance<ArrayClass>(thePName);
+    aPArray->myArray = new ArrayClass(theArray.Lower(), theArray.Upper());
+    for (Standard_Integer i = theArray.Lower(); i <= theArray.Upper(); ++i)
+      aPArray->myArray->ChangeValue(i) = theArray.Value(i);
+    return aPArray;
+  }
 };
 
+template<>
+inline Standard_CString StdLPersistent_HArray1::instance<TColStd_HArray1OfInteger>::PNameT() const
+  { return "PColStd_HArray1OfInteger"; }
+
+template<>
+inline Standard_CString StdLPersistent_HArray1::instance<TColStd_HArray1OfReal>::PNameT() const
+  { return "PColStd_HArray1OfReal"; }
+
+template<>
+inline Standard_CString StdLPersistent_HArray1::instance<TColStd_HArray1OfByte>::PNameT() const
+  { return "PColStd_HArray1OfByte"; }
+
 inline StdObjMgt_ReadData& operator >>
   (StdObjMgt_ReadData& theReadData, Standard_Byte& theByte)
     { return theReadData >> reinterpret_cast<Standard_Character&> (theByte); }
 
+inline StdObjMgt_WriteData& operator >>
+  (StdObjMgt_WriteData& theWriteData, const Standard_Byte& theByte)
+    { return theWriteData << reinterpret_cast<const Standard_Character&> (theByte); }
+
+template<>
+inline void StdLPersistent_HArray1::instance<StdLPersistent_HArray1OfPersistent>::PChildrenT
+  (StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
+  { 
+    for (Standard_Integer i = myArray->Lower(); i <= myArray->Upper(); ++i)
+      theChildren.Append(myArray->Value(i));
+  }
+
 #endif
index 8c8afa4..cde9009 100644 (file)
@@ -36,3 +36,24 @@ void StdLPersistent_HArray2::base::Read (StdObjMgt_ReadData& theReadData)
     for (Standard_Integer aCol = aLowerCol; aCol <= anUpperCol; aCol++)
       readValue (anObjectData, aRow, aCol);
 }
+
+//=======================================================================
+//function : Read
+//purpose  : Read persistent data from a file
+//=======================================================================
+void StdLPersistent_HArray2::base::Write (StdObjMgt_WriteData& theWriteData) const
+{
+  Standard_Integer aLowerRow, aLowerCol, anUpperRow, anUpperCol;
+  lowerBound(aLowerRow, aLowerCol);
+  upperBound(anUpperRow, anUpperCol);
+  theWriteData << aLowerRow << aLowerCol << anUpperRow << anUpperCol;
+
+  StdObjMgt_WriteData::Object anObjectData(theWriteData);
+
+  Standard_Integer aSize = (anUpperRow - aLowerRow + 1) * (anUpperCol - aLowerCol + 1);
+  anObjectData << aSize;
+
+  for (Standard_Integer aRow = aLowerRow; aRow <= anUpperRow; aRow++)
+    for (Standard_Integer aCol = aLowerCol; aCol <= anUpperCol; aCol++)
+      writeValue(anObjectData, aRow, aCol);
+}
index c4941fc..f88b028 100644 (file)
 #ifndef _StdLPersistent_HArray2_HeaderFile
 #define _StdLPersistent_HArray2_HeaderFile
 
+#include <Standard_NotImplemented.hxx>
+#include <Standard_NullValue.hxx>
+
 #include <StdObjMgt_Persistent.hxx>
 #include <StdObjMgt_ReadData.hxx>
+#include <StdObjMgt_WriteData.hxx>
 
 #include <NCollection_DefineHArray2.hxx>
 
@@ -36,8 +40,15 @@ class StdLPersistent_HArray2
     //! Read persistent data from a file.
     Standard_EXPORT virtual void Read (StdObjMgt_ReadData& theReadData);
 
+    //! Read persistent data from a file.
+    Standard_EXPORT virtual void Write (StdObjMgt_WriteData& theWriteData) const;
+
   protected:
-    virtual void createArray (
+    virtual void lowerBound(Standard_Integer& theRow, 
+                            Standard_Integer& theCol) const = 0;
+    virtual void upperBound(Standard_Integer& theRow, 
+                            Standard_Integer& theCol) const = 0;
+    virtual void createArray(
       const Standard_Integer theLowerRow, const Standard_Integer theLowerCol,
       const Standard_Integer theUpperRow, const Standard_Integer theUpperCol)
         = 0;
@@ -45,12 +56,17 @@ class StdLPersistent_HArray2
     virtual void readValue (StdObjMgt_ReadData&    theReadData,
                             const Standard_Integer theRow,
                             const Standard_Integer theCol) = 0;
+    virtual void writeValue(StdObjMgt_WriteData&   theWriteData,
+                            const Standard_Integer theRow,
+                            const Standard_Integer theCol) const = 0;
   };
 
 protected:
   template <class ArrayClass>
   class instance : public base
   {
+    friend class StdLPersistent_HArray2;
+
   public:
     typedef Handle(ArrayClass) ArrayHandle;
 
@@ -59,27 +75,114 @@ protected:
     const Handle(ArrayClass)& Array() const  { return myArray; }
 
   protected:
-    virtual void createArray (
+    virtual void lowerBound(Standard_Integer& theRow,
+      Standard_Integer& theCol) const
+    {
+      theRow = myArray->LowerRow(); 
+      theCol = myArray->LowerCol();
+    }
+    virtual void upperBound(Standard_Integer& theRow,
+      Standard_Integer& theCol) const
+    { 
+      theRow = myArray->UpperRow(); 
+      theCol = myArray->UpperCol(); 
+    }
+    virtual void createArray(
       const Standard_Integer theLowerRow, const Standard_Integer theLowerCol,
       const Standard_Integer theUpperRow, const Standard_Integer theUpperCol)
     {
       myArray = new ArrayClass (theLowerRow, theUpperRow,
                                 theLowerCol, theUpperCol);
     }
-
     virtual void readValue (StdObjMgt_ReadData&    theReadData,
                             const Standard_Integer theRow,
                             const Standard_Integer theCol)
       { theReadData >> myArray->ChangeValue (theRow, theCol); }
+    virtual void writeValue(StdObjMgt_WriteData&   theWriteData,
+                            const Standard_Integer theRow,
+                            const Standard_Integer theCol) const
+    {
+      theWriteData << myArray->Value(theRow, theCol);
+    }
+    virtual void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
+      { return PChildrenT(theChildren); }
+    virtual Standard_CString PName() const
+      { return PNameT(); }
+    Standard_CString PNameT() const
+    {
+      Standard_NotImplemented::Raise("StdLPersistent_HArray2::instance::PName - not implemented");
+      return "";
+    }
+    void PChildrenT(StdObjMgt_Persistent::SequenceOfPersistent&) const {}
 
   protected:
     Handle(ArrayClass) myArray;
   };
 
+  template <class ArrayClass>
+  class named_instance : public instance<ArrayClass>
+  {
+    friend class StdLPersistent_HArray2;
+
+  public:
+    virtual Standard_CString PName() const
+    {
+      Standard_NullValue_Raise_if(!myPName,
+        "StdLPersistent_HArray2::named_instance::PName - name not set");
+      return myPName;
+    }
+
+  protected:
+    named_instance(Standard_CString thePName) : myPName(thePName) {}
+
+    Standard_CString myPName;
+  };
+
 public:
   typedef instance<TColStd_HArray2OfInteger>           Integer;
   typedef instance<TColStd_HArray2OfReal>              Real;
   typedef instance<StdLPersistent_HArray2OfPersistent> Persistent;
+
+public:
+  template <class ArrayClass>
+  static Handle(instance<ArrayClass>) Translate(const ArrayClass& theArray)
+  {
+    Handle(instance<ArrayClass>) aPArray = new instance<ArrayClass>;
+    aPArray->myArray = new ArrayClass(theArray.LowerRow(), theArray.UpperRow(),
+      theArray.LowerCol(), theArray.UpperCol());
+    for (Standard_Integer i = theArray.LowerRow(); i <= theArray.UpperRow(); ++i)
+      for (Standard_Integer j = theArray.LowerCol(); j <= theArray.UpperCol(); ++j)
+        aPArray->myArray->ChangeValue(i, j) = theArray.Value(i, j);
+    return aPArray;
+  }
+  template <class ArrayClass>
+  static Handle(instance<ArrayClass>) Translate(Standard_CString thePName, const ArrayClass& theArray)
+  {
+    Handle(named_instance<ArrayClass>) aPArray = new named_instance<ArrayClass>(thePName);
+    aPArray->myArray = new ArrayClass(theArray.LowerRow(), theArray.UpperRow(),
+      theArray.LowerCol(), theArray.UpperCol());
+    for (Standard_Integer i = theArray.LowerRow(); i <= theArray.UpperRow(); ++i)
+      for (Standard_Integer j = theArray.LowerCol(); j <= theArray.UpperCol(); ++j)
+        aPArray->myArray->ChangeValue(i, j) = theArray.Value(i, j);
+    return aPArray;
+  }
 };
 
+template<>
+inline Standard_CString StdLPersistent_HArray2::instance<TColStd_HArray2OfInteger>::PNameT() const
+  { return "PColStd_HArray2OfInteger"; }
+
+template<>
+inline Standard_CString StdLPersistent_HArray2::instance<TColStd_HArray2OfReal>::PNameT() const
+  { return "PColStd_HArray2OfReal"; }
+
+template<>
+inline void StdLPersistent_HArray2::instance<StdLPersistent_HArray2OfPersistent>::PChildrenT
+  (StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
+  { 
+    for (Standard_Integer i = myArray->LowerRow(); i <= myArray->UpperRow(); ++i)
+      for (Standard_Integer j = myArray->LowerCol(); j <= myArray->UpperCol(); ++j)
+        theChildren.Append(myArray->Value(i, j));
+  }
+
 #endif
index 98e5d83..436f1ca 100644 (file)
@@ -13,6 +13,7 @@
 
 #include <StdLPersistent_HString.hxx>
 #include <StdObjMgt_ReadData.hxx>
+#include <StdObjMgt_WriteData.hxx>
 #include <TDF_Label.hxx>
 #include <TDF_Tool.hxx>
 
@@ -40,6 +41,26 @@ void StdLPersistent_HString::instance<StringClass, CharType>::Read
 }
 
 //=======================================================================
+//function : Write
+//purpose  : Write persistent data to a file
+//=======================================================================
+template <class StringClass, typename CharType>
+void StdLPersistent_HString::instance<StringClass, CharType>::Write
+  (StdObjMgt_WriteData& theWriteData) const
+{
+  StdObjMgt_WriteData::Object anObjectData(theWriteData);
+
+  Standard_Integer aSize = myValue->Length();
+  anObjectData << aSize;
+
+  for (Standard_Integer i = 1; i <= aSize; i++)
+  {
+    CharType aChar (0);
+    anObjectData << aChar;
+  }
+}
+
+//=======================================================================
 //function : Label
 //purpose  : Get/create a label defined by referenced string
 //=======================================================================
index a608d24..21ee8eb 100644 (file)
@@ -30,6 +30,9 @@ class StdLPersistent_HString
   public:
     //! Read persistent data from a file.
     Standard_EXPORT virtual void Read (StdObjMgt_ReadData& theReadData);
+    //! Write persistent data to a file.
+    Standard_EXPORT virtual void Write (StdObjMgt_WriteData& theWriteData) const;
+    Standard_EXPORT virtual void PChildren(StdObjMgt_Persistent::SequenceOfPersistent&) const { }
 
     //! Get/create a label defined by referenced string.
     Standard_EXPORT virtual TDF_Label Label (const Handle(TDF_Data)& theDF) const;
@@ -48,6 +51,8 @@ public:
   public:
     //! Get referenced ASCII string.
     Standard_EXPORT virtual Handle(TCollection_HAsciiString) AsciiString() const;
+
+    inline Standard_CString PName() const { return "PCollection_HAsciiString"; }
   };
 
   class Extended
@@ -56,6 +61,8 @@ public:
   public:
     //! Get referenced extended string.
     Standard_EXPORT virtual Handle(TCollection_HExtendedString) ExtString() const;
+
+    inline Standard_CString PName() const { return "PCollection_HExtendedString"; }
   };
 };
 
index 27c79ce..b1132b6 100644 (file)
@@ -32,6 +32,8 @@ class StdLPersistent_NamedData : public StdObjMgt_Attribute<TDataStd_NamedData>
 
     inline void Read (StdObjMgt_ReadData& theReadData)
       { theReadData >> myKeys >> myValues; }
+    inline void Write (StdObjMgt_WriteData& theWriteData) const
+      { theWriteData << myKeys << myValues; }
 
     inline operator bool() const
       { return !myKeys.IsNull(); }
@@ -60,6 +62,24 @@ public:
     myRealArrays.Read (theReadData);
   }
 
+  //! Write persistent data to a file.
+  inline void Write (StdObjMgt_WriteData& theWriteData) const
+  {
+    theWriteData << myDimensions;
+    myInts.Write(theWriteData);
+    myReals.Write(theWriteData);
+    myStrings.Write(theWriteData);
+    myBytes.Write(theWriteData);
+    myIntArrays.Write(theWriteData);
+    myRealArrays.Write(theWriteData);
+  }
+
+  //! Gets persistent child objects
+  void PChildren(StdObjMgt_Persistent::SequenceOfPersistent&) const {}
+
+  //! Returns persistent type name
+  Standard_CString PName() const { return "PDataStd_NamedData"; }
+
   //! Import transient attribuite from the persistent data.
   void Import (const Handle(TDataStd_NamedData)& theAttribute) const;
 
index 227c5fb..409051e 100644 (file)
@@ -26,13 +26,20 @@ public:
   //! Read persistent data from a file.
   inline void Read (StdObjMgt_ReadData& theReadData)
     { theReadData >> myValue >> myDimension; }
+  //! Write persistent data from a file.
+  inline void Write (StdObjMgt_WriteData& theWriteData) const
+    { theWriteData << myValue << myDimension; }
+  //! Gets persistent child objects
+  void PChildren(StdObjMgt_Persistent::SequenceOfPersistent&) const {}
+  //! Returns persistent type name
+  Standard_CString PName() const { return "PDataStd_Real"; }
 
   //! Import transient attribuite from the persistent data.
   void Import (const Handle(TDataStd_Real)& theAttribute) const
   {
     theAttribute->Set          (myValue);
     theAttribute->SetDimension (static_cast<TDataStd_RealEnum> (myDimension));
-       theAttribute->SetID(TDataStd_Real::GetID());
+    theAttribute->SetID(TDataStd_Real::GetID());
   }
 
 private:
index 7e45aa6..7caa24a 100644 (file)
@@ -25,6 +25,27 @@ void StdLPersistent_TreeNode::Read (StdObjMgt_ReadData& theReadData)
 }
 
 //=======================================================================
+//function : Write
+//purpose  : Write persistent data to a file
+//=======================================================================
+void StdLPersistent_TreeNode::Write (StdObjMgt_WriteData& theWriteData) const
+{
+  theWriteData << myDynamicData->First << myNext << myDynamicData->TreeID;
+}
+
+//=======================================================================
+//function : PChildren
+//purpose  : Gets persistent child objects
+//=======================================================================
+void StdLPersistent_TreeNode::PChildren
+  (StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
+{
+  theChildren.Append(myNext);
+  if (!myDynamicData.IsNull())
+    theChildren.Append(myDynamicData->First);
+}
+
+//=======================================================================
 //function : CreateAttribute
 //purpose  : Create an empty transient attribuite
 //=======================================================================
index 6fb7e67..789029d 100644 (file)
@@ -28,6 +28,16 @@ public:
   //! Read persistent data from a file.
   Standard_EXPORT virtual void Read (StdObjMgt_ReadData& theReadData);
 
+  //! Write persistent data to a file.
+  Standard_EXPORT virtual void Write (StdObjMgt_WriteData& theWriteData) const;
+
+  //! Gets persistent child objects
+  Standard_EXPORT virtual void PChildren(StdObjMgt_Persistent::SequenceOfPersistent&) const;
+
+  //! Returns persistent type name
+  Standard_EXPORT virtual Standard_CString PName() const
+    { return "PDataStd_TreeNode"; }
+
   //! Create an empty transient attribuite
   Standard_EXPORT virtual Handle(TDF_Attribute) CreateAttribute();
 
index d68806c..2dea893 100644 (file)
@@ -48,15 +48,27 @@ class StdLPersistent_Value
 
 public:
 
-  typedef integer <TDF_TagSource>                TagSource;
-  typedef string <TDF_Reference>                 Reference;  
-  typedef string <TDataStd_Comment>              Comment;
+  class TagSource : public integer <TDF_TagSource> {
+  public:
+    Standard_CString PName() const { return "PDF_TagSource"; }
+  };
+
+  class Reference : public string <TDF_Reference> {
+  public:
+    Standard_CString PName() const { return "PDF_Reference"; }
+  };
+
+  class Comment : public string <TDataStd_Comment> {
+  public:
+    Standard_CString PName() const { return "PDF_Comment"; }
+  };
 
   class UAttribute : public string <TDataStd_UAttribute>
   {
   public:
     //! Create an empty transient attribuite
     Standard_EXPORT virtual Handle(TDF_Attribute) CreateAttribute();
+    Standard_CString PName() const { return "PDataStd_UAttribute"; }
   };
 
   class Integer : public integer <TDataStd_Integer>
@@ -64,6 +76,7 @@ public:
   public:
     //! Create an empty transient attribuite
     Standard_EXPORT virtual Handle(TDF_Attribute) CreateAttribute();
+    Standard_CString PName() const { return "PDataStd_Integer"; }
   };
 
   class Name : public string <TDataStd_Name>
@@ -71,6 +84,7 @@ public:
   public:
     //! Create an empty transient attribuite
     Standard_EXPORT virtual Handle(TDF_Attribute) CreateAttribute();
+    Standard_CString PName() const { return "PDataStd_Name"; }
   };
 
   class AsciiString : public string <TDataStd_AsciiString, StdLPersistent_HString::Ascii>
@@ -78,7 +92,23 @@ public:
   public:
     //! Create an empty transient attribuite
     Standard_EXPORT virtual Handle(TDF_Attribute) CreateAttribute();
+    Standard_CString PName() const { return "PDataStd_AsciiString"; }
   };
 };
 
+template<>
+template<>
+inline Standard_CString StdObjMgt_Attribute<TDF_TagSource>::Simple<Standard_Integer>::PName() const
+  { return "PDF_TagSource"; }
+
+template<>
+template<>
+inline Standard_CString StdObjMgt_Attribute<TDF_Reference>::Simple<Handle(StdObjMgt_Persistent)>::PName() const
+  { return "PDF_Reference"; }
+
+template<>
+template<>
+inline Standard_CString StdObjMgt_Attribute<TDataStd_Comment>::Simple<Handle(StdObjMgt_Persistent)>::PName() const
+  { return "PDataStd_Comment"; }
+
 #endif
index 8b9f21c..ab46337 100644 (file)
@@ -27,6 +27,14 @@ public:
   //! Read persistent data from a file.
   inline void Read (StdObjMgt_ReadData& theReadData)
     { theReadData >> myIsConstant >> myUnit; }
+  //! Write persistent data to a file.
+  inline void Write (StdObjMgt_WriteData& theWriteData) const
+    { theWriteData << myIsConstant << myUnit; }
+  //! Gets persistent child objects
+  inline void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const 
+    { theChildren.Append(myUnit); }
+  //! Returns persistent type name
+  inline Standard_CString PName() const { return "PDataStd_Variable"; }
 
   //! Import transient attribuite from the persistent data.
   void Import (const Handle(TDataStd_Variable)& theAttribute) const
index 5c8ad24..77e9412 100644 (file)
@@ -31,6 +31,12 @@ protected:
   public:
     //! Read persistent data from a file.
     Standard_EXPORT virtual void Read (StdObjMgt_ReadData&) {}
+    //! Write persistent data to a file.
+    Standard_EXPORT virtual void Write (StdObjMgt_WriteData&) const {}
+    //! Gets persistent child objects
+    inline void PChildren(StdObjMgt_Persistent::SequenceOfPersistent&) const {}
+    //! Returns persistent type name
+    Standard_CString PName() const;
 
     //! Import transient attribuite from the persistent data
     Standard_EXPORT virtual void ImportAttribute() {}
@@ -42,4 +48,16 @@ public:
   typedef instance<TDataStd_NoteBook>  NoteBook;
 };
 
+template<>
+inline Standard_CString StdLPersistent_Void::instance<TDataStd_Directory>::PName() const
+  { return "PDataStd_Directory"; }
+
+template<>
+inline Standard_CString StdLPersistent_Void::instance<TDataStd_Tick>::PName() const
+  { return "PDataStd_Tick"; }
+
+template<>
+inline Standard_CString StdLPersistent_Void::instance<TDataStd_NoteBook>::PName() const
+  { return "PDataStd_Notebook"; }
+
 #endif
index b370f15..238ba10 100644 (file)
@@ -27,6 +27,17 @@ public:
   //! Read persistent data from a file.
   inline void Read (StdObjMgt_ReadData& theReadData)
     { theReadData >> myDocEntry >> myLabEntry; }
+  //! Write persistent data to a file.
+  inline void Write (StdObjMgt_WriteData& theWriteData) const
+    { theWriteData << myDocEntry << myLabEntry; }
+  //! Gets persistent child objects
+  inline void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
+  {
+    theChildren.Append(myDocEntry);
+    theChildren.Append(myLabEntry);
+  }
+  //! Returns persistent type name
+  inline Standard_CString PName() const { return "PDocStd_XLink"; }
 
   //! Import transient attribuite from the persistent data.
   void Import (const Handle(TDocStd_XLink)& theAttribute) const
index 6ca1b5f..17269aa 100644 (file)
@@ -1,8 +1,10 @@
 StdObjMgt_Attribute.hxx
-StdObjMgt_MapOfInstantiators.cxx
 StdObjMgt_MapOfInstantiators.hxx
 StdObjMgt_Persistent.cxx
 StdObjMgt_Persistent.hxx
 StdObjMgt_ReadData.cxx
 StdObjMgt_ReadData.hxx
+StdObjMgt_WriteData.hxx
+StdObjMgt_WriteData.cxx
 StdObjMgt_SharedObject.hxx
+StdObjMgt_TransientPersistentMap.hxx
index 4d891e8..0a203cc 100644 (file)
@@ -16,6 +16,7 @@
 
 #include <StdObjMgt_Persistent.hxx>
 #include <StdObjMgt_ReadData.hxx>
+#include <StdObjMgt_WriteData.hxx>
 
 
 //! Root class for a temporary persistent object corresponding to an attribute.
@@ -31,7 +32,7 @@ class StdObjMgt_Attribute : public Standard_Transient
 
     //! Get transient attribuite for the persistent data
     Standard_EXPORT virtual Handle(TDF_Attribute) GetAttribute() const
-    { return Handle(TDF_Attribute)(myTransient); }
+      { return Handle(TDF_Attribute)(myTransient); }
 
   protected:
     Handle(Transient) myTransient;
@@ -47,6 +48,11 @@ public:
     //! Read persistent data from a file.
     Standard_EXPORT virtual void Read (StdObjMgt_ReadData& theReadData)
       { theReadData >> myData; }
+    //! Write persistent data to a file.
+    Standard_EXPORT virtual void Write (StdObjMgt_WriteData& theWriteData) const
+      { theWriteData << myData; }
+    Standard_EXPORT virtual void PChildren(StdObjMgt_Persistent::SequenceOfPersistent&) const { }
+    Standard_EXPORT virtual Standard_CString PName() const { return "StdObjMgt_Attribute::undefined"; }
 
   protected:
     DataType myData;
@@ -66,6 +72,12 @@ private:
       myPersistent = new Persistent;
       myPersistent->Read (theReadData);
     }
+    //! Write persistent data to a file.
+    Standard_EXPORT virtual void Write(StdObjMgt_WriteData& theWriteData) const
+      { myPersistent->Write(theWriteData); }
+    Standard_EXPORT virtual void PChildren(StdObjMgt_Persistent::SequenceOfPersistent&) const { }
+    Standard_EXPORT virtual Standard_CString PName() const 
+      { return myPersistent->PName(); }
 
     //! Import transient attribuite from the persistent data
     Standard_EXPORT virtual void ImportAttribute()
index 66901f6..2107caa 100644 (file)
 
 #include <StdObjMgt_Persistent.hxx>
 
+StdObjMgt_Persistent::StdObjMgt_Persistent()
+  : myTypeNum(0)
+  , myRefNum(0)
+{
+
+}
 
 //=======================================================================
 //function : ImportDocument
index c95754e..b688249 100644 (file)
 #include <Standard.hxx>
 #include <Standard_Handle.hxx>
 #include <Standard_Transient.hxx>
+#include <NCollection_Sequence.hxx>
 
 #include <TDF_Label.hxx>
 
 class StdObjMgt_ReadData;
+class StdObjMgt_WriteData;
 class TDocStd_Document;
 class TDF_Attribute;
 class TDF_Data;
@@ -34,6 +36,8 @@ class TCollection_HExtendedString;
 class StdObjMgt_Persistent : public Standard_Transient
 {
 public:
+  Standard_EXPORT StdObjMgt_Persistent();
+
   //! Derived class instance create function.
   typedef Handle(StdObjMgt_Persistent) (*Instantiator)();
 
@@ -45,6 +49,17 @@ public:
   //! Read persistent data from a file.
   Standard_EXPORT virtual void Read (StdObjMgt_ReadData& theReadData) = 0;
 
+  //! Write persistent data to a file.
+  Standard_EXPORT virtual void Write (StdObjMgt_WriteData& theWriteData) const = 0;
+
+  typedef NCollection_Sequence<Handle(StdObjMgt_Persistent)> SequenceOfPersistent;
+
+  //! Gets persistent child objects
+  Standard_EXPORT virtual void PChildren (SequenceOfPersistent&) const = 0;
+
+  //! Returns persistent type name
+  Standard_EXPORT virtual Standard_CString PName() const = 0;
+
   //! Import transient document from the persistent data
   //! (to be overriden by document class;
   //! does nothing by default for other classes).
@@ -80,6 +95,22 @@ public:
   //! (to be overriden by extended string class;
   //! returns a null label by default for other classes).
   Standard_EXPORT virtual TDF_Label Label (const Handle(TDF_Data)& theDF) const;
+
+  //! Returns the assigned persistent type number
+  Standard_Integer TypeNum() const { return myTypeNum; }
+
+  //! Assigns a persistent type number to the object
+  void TypeNum(Standard_Integer theTypeNum) { myTypeNum = theTypeNum; }
+
+  //! Returns the object reference number
+  Standard_Integer RefNum() const { return myRefNum; }
+
+  //! Sets an object reference number
+  void RefNum(Standard_Integer theRefNum) { myRefNum = theRefNum; }
+
+private:
+  Standard_Integer myTypeNum;
+  Standard_Integer myRefNum;
 };
 
 #endif // _StdObjMgt_Persistent_HeaderFile
index 3063f80..8582e14 100644 (file)
@@ -93,6 +93,8 @@ class StdObjMgt_ReadData::Object
 public:
   Object (StdObjMgt_ReadData& theData) : myReadData (&theData)
     { myReadData->myDriver->BeginReadObjectData(); }
+  Object(const StdObjMgt_ReadData::Object& theOther) : myReadData(theOther.myReadData)
+    { myReadData->myDriver->BeginReadObjectData(); }
 
   ~Object()
     { myReadData->myDriver->EndReadObjectData(); }
@@ -106,6 +108,8 @@ public:
 
 private:
   StdObjMgt_ReadData* myReadData;
+
+  StdObjMgt_ReadData::Object& operator = (const StdObjMgt_ReadData::Object&);
 };
 
 Standard_EXPORT StdObjMgt_ReadData& operator >>
index def5f6e..e3750d7 100644 (file)
@@ -15,9 +15,9 @@
 #ifndef _StdObjMgt_SharedObject_HeaderFile
 #define _StdObjMgt_SharedObject_HeaderFile
 
+#include <Standard_NoSuchObject.hxx>
 #include <StdObjMgt_Persistent.hxx>
 
-
 class StdObjMgt_SharedObject
 {
 public:
@@ -28,15 +28,19 @@ public:
     virtual Handle(Transient) Import() const = 0;
   };
 
-  template <class Transient, class Base = StdObjMgt_Persistent>
+  template <class TransientT, class Base = StdObjMgt_Persistent>
   class SharedBase : public Base
   {
   public:
+    //! Changes transient object
+    inline void Transient(const Handle(TransientT)& theTransient)
+      { myTransient = theTransient; }
+
     //! Import transient object from the persistent data.
-    inline const Handle(Transient)& Import()  { return myTransient; }
+    inline const Handle(TransientT)& Import()  { return myTransient; }
 
   protected:
-    Handle(Transient) myTransient;
+    Handle(TransientT) myTransient;
   };
 
   template <class Base,
@@ -52,7 +56,7 @@ public:
     Standard_EXPORT virtual Handle(Transient) Import()
       { return myTransient; }
 
-  protected:
+  public:
     Handle(Transient) myTransient;
   };
 
@@ -65,6 +69,15 @@ public:
     //! Read persistent data from a file.
     Standard_EXPORT virtual void Read (StdObjMgt_ReadData& theReadData)
       { PersistentData().Read (theReadData); }
+    //! Write persistent data to a file.
+    Standard_EXPORT virtual void Write (StdObjMgt_WriteData& theWriteData) const
+      { PersistentData().Write (theWriteData); }
+    //! Gets persistent child objects
+    Standard_EXPORT virtual void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
+      { PersistentData().PChildren(theChildren); }
+    //! Returns persistent type name
+    Standard_EXPORT virtual Standard_CString PName() const
+      { return PersistentData().PName(); }
 
     //! Import transient object from the persistent data.
     Standard_EXPORT virtual Handle(Transient) Import()
@@ -88,7 +101,7 @@ private:
       return Base::myTransient;
     }
 
-  protected:
+  public:
     Handle(typename Base::PersistentBase) myPersistent;
   };
 
@@ -96,6 +109,19 @@ public:
   template <class Base, class Persistent = typename Base::PersistentBase>
   class Delayed : public delayedSubBase<Base>
   {
+  private:
+    template <class T1, class T2>
+    struct DownCast {
+      static Handle(T1) make(const Handle(T2)& theT2)
+        { return Handle(T1)::DownCast(theT2); }
+    };
+
+    template <class T>
+    struct DownCast<T, T> {
+      static Handle(T) make(const Handle(T)& theT)
+        { return theT; }
+    };
+
   public:
     //! Read persistent data from a file.
     Standard_EXPORT virtual void Read (StdObjMgt_ReadData& theReadData)
@@ -104,6 +130,33 @@ public:
       aPersistent->Read (theReadData);
       this->myPersistent = aPersistent;
     }
+    //! Write persistent data to a file.
+    Standard_EXPORT virtual void Write(StdObjMgt_WriteData& theWriteData) const
+    { 
+      Handle(Persistent) aPersistent = 
+        DownCast<Persistent, typename Base::PersistentBase>::make(this->myPersistent);
+      Standard_NoSuchObject_Raise_if(aPersistent.IsNull(), 
+        "StdObjMgt_SharedObject::Delayed::Write - persistent object wasn't set for writing!");
+      aPersistent->Write(theWriteData);
+    }
+    //! Gets persistent child objects
+    Standard_EXPORT virtual void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
+    {
+      Handle(Persistent) aPersistent = 
+        DownCast<Persistent, typename Base::PersistentBase>::make(this->myPersistent);
+      Standard_NoSuchObject_Raise_if(aPersistent.IsNull(), 
+        "StdObjMgt_SharedObject::Delayed::PChildren - persistent object wasn't set for writing!");
+      aPersistent->PChildren(theChildren);
+    }
+    //! Returns persistent type name
+    Standard_EXPORT virtual Standard_CString PName() const 
+    { 
+      Handle(Persistent) aPersistent =
+        DownCast<Persistent, typename Base::PersistentBase>::make(this->myPersistent);
+      Standard_NoSuchObject_Raise_if(aPersistent.IsNull(), 
+        "StdObjMgt_SharedObject::Delayed::PName - persistent object wasn't set for writing!");
+      return aPersistent->PName();
+    }
   };
 };
 
diff --git a/src/StdObjMgt/StdObjMgt_TransientPersistentMap.hxx b/src/StdObjMgt/StdObjMgt_TransientPersistentMap.hxx
new file mode 100644 (file)
index 0000000..9af876d
--- /dev/null
@@ -0,0 +1,12 @@
+
+#ifndef _StdObjMgt_TransientPersistentMap_HeaderFile
+#define _StdObjMgt_TransientPersistentMap_HeaderFile
+
+#include <NCollection_DataMap.hxx>
+
+class Standard_Transient;
+class StdObjMgt_Persistent;
+
+typedef NCollection_DataMap<Handle(Standard_Transient), Handle(StdObjMgt_Persistent)> StdObjMgt_TransientPersistentMap;
+
+#endif // _StdObjMgt_TransientPersistentMap_HeaderFile
diff --git a/src/StdObjMgt/StdObjMgt_WriteData.cxx b/src/StdObjMgt/StdObjMgt_WriteData.cxx
new file mode 100644 (file)
index 0000000..cbd9b4f
--- /dev/null
@@ -0,0 +1,71 @@
+// Copyright (c) 2017 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StdObjMgt_WriteData.hxx>
+#include <StdObjMgt_Persistent.hxx>
+
+#include <Standard_GUID.hxx>
+
+
+StdObjMgt_WriteData::StdObjMgt_WriteData (Storage_BaseDriver& theDriver)
+    : myDriver (&theDriver)
+{
+}
+
+void StdObjMgt_WriteData::WritePersistentObject (const Handle(StdObjMgt_Persistent)& thePersistent)
+{
+  if (thePersistent)
+  {
+    myDriver->WritePersistentObjectHeader(thePersistent->RefNum(), thePersistent->TypeNum());
+    myDriver->BeginWritePersistentObjectData();
+    thePersistent->Write(*this);
+    myDriver->EndWritePersistentObjectData();
+  }
+}
+
+StdObjMgt_WriteData& StdObjMgt_WriteData::operator << (const Handle(StdObjMgt_Persistent)& thePersistent)
+{
+  *myDriver << (thePersistent ? thePersistent->RefNum() : 0);
+  return *this;
+}
+
+//=======================================================================
+//function : operator >>
+//purpose  : Read persistent data from a file
+//=======================================================================
+StdObjMgt_WriteData& operator <<
+  (StdObjMgt_WriteData::Object theWriteData, const Standard_GUID& theGUID)
+{
+  const Standard_UUID anUUID = theGUID.ToUUID();
+
+  Standard_Integer      a32b;
+  Standard_ExtCharacter a16b[3];
+  Standard_Character    a8b [6];
+
+  // see Standard_GUID::Standard_GUID(const Standard_UUID& aWntGuid)
+  a32b    = anUUID.Data1;
+  a16b[0] = anUUID.Data2;
+  a16b[1] = anUUID.Data3;
+  a16b[2] = (anUUID.Data4[0] << 8) | (anUUID.Data4[1]);
+  a8b[0] = anUUID.Data4[2];
+  a8b[1] = anUUID.Data4[3];
+  a8b[2] = anUUID.Data4[4];
+  a8b[3] = anUUID.Data4[5];
+  a8b[4] = anUUID.Data4[6];
+  a8b[5] = anUUID.Data4[7];
+
+  theWriteData << a32b << a16b[0] << a16b[1] << a16b[2];
+  theWriteData << a8b[0] << a8b[1] << a8b[2] << a8b[3] << a8b[4] << a8b[5];
+
+  return theWriteData;
+}
diff --git a/src/StdObjMgt/StdObjMgt_WriteData.hxx b/src/StdObjMgt/StdObjMgt_WriteData.hxx
new file mode 100644 (file)
index 0000000..48d5ea4
--- /dev/null
@@ -0,0 +1,101 @@
+// Copyright (c) 2017 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StdObjMgt_WriteData_HeaderFile
+#define _StdObjMgt_WriteData_HeaderFile
+
+#include <Standard.hxx>
+#include <Storage_BaseDriver.hxx>
+
+class StdObjMgt_Persistent;
+class Standard_GUID;
+
+//! Auxiliary data used to write persistent objects to a file.
+class StdObjMgt_WriteData
+{
+public:
+
+  class Object;
+
+  Standard_EXPORT StdObjMgt_WriteData 
+    (Storage_BaseDriver& theDriver);
+
+  Standard_EXPORT void WritePersistentObject
+    (const Handle(StdObjMgt_Persistent)& thePersistent);
+
+  template <class Persistent>
+  StdObjMgt_WriteData& operator << (const Handle(Persistent)& thePersistent)
+  {
+    *myDriver << (thePersistent ? thePersistent->RefNum() : 0);
+    return *this;
+  }
+
+  Standard_EXPORT StdObjMgt_WriteData& operator << (const Handle(StdObjMgt_Persistent)& thePersistent);
+
+  template <class Type>
+  StdObjMgt_WriteData& WriteValue(const Type& theValue)
+  {
+    *myDriver << theValue;
+    return *this;
+  }
+
+  StdObjMgt_WriteData& operator << (const Standard_Character& theValue)
+    { return WriteValue(theValue); }
+  
+  StdObjMgt_WriteData& operator << (const Standard_ExtCharacter& theValue)
+    { return WriteValue(theValue); }
+  
+  StdObjMgt_WriteData& operator << (const Standard_Integer& theValue)
+   { return WriteValue(theValue); }
+  
+  StdObjMgt_WriteData& operator << (const Standard_Boolean& theValue)
+    { return WriteValue(theValue); }
+  
+  StdObjMgt_WriteData& operator << (const Standard_Real& theValue)
+   { return WriteValue(theValue); }
+  
+  StdObjMgt_WriteData& operator << (const Standard_ShortReal& theValue)
+    { return WriteValue(theValue); }
+
+private:
+  Storage_BaseDriver* myDriver;
+};
+
+class StdObjMgt_WriteData::Object
+{
+public:
+  Object (StdObjMgt_WriteData& theData) : myWriteData(&theData)
+    { myWriteData->myDriver->BeginWriteObjectData(); }
+  Object (const StdObjMgt_WriteData::Object& theOther) : myWriteData(theOther.myWriteData)
+    { myWriteData->myDriver->BeginWriteObjectData(); }
+
+  ~Object()
+    { myWriteData->myDriver->EndWriteObjectData(); }
+
+  operator StdObjMgt_WriteData& ()
+    { return *myWriteData; }
+
+  template <class Data>
+  StdObjMgt_WriteData& operator << (Data& theData)
+    { return *myWriteData << theData; }
+
+private:
+  StdObjMgt_WriteData* myWriteData;
+
+  StdObjMgt_WriteData::Object& operator = (const StdObjMgt_WriteData::Object&);
+};
+
+Standard_EXPORT StdObjMgt_WriteData& operator <<
+  (StdObjMgt_WriteData::Object theWriteData, const Standard_GUID& theGUID);
+
+#endif // _StdObjMgt_WriteData_HeaderFile
index a905d62..974361e 100644 (file)
 #include <StdObject_Location.hxx>
 #include <StdPersistent_TopLoc.hxx>
 
+//=======================================================================
+//function : Translate
+//purpose  : Creates a persistent wrapper object for a location
+//=======================================================================
+StdObject_Location 
+StdObject_Location::Translate (const TopLoc_Location& theLoc,
+                               StdObjMgt_TransientPersistentMap& theMap)
+{
+  StdObject_Location aLoc;
+  if (!theLoc.IsIdentity())
+    aLoc.myData = StdPersistent_TopLoc::Translate(theLoc, theMap);
+  return aLoc;
+}
+
+//=======================================================================
+//function : Location
+//purpose  : Changes current location
+//=======================================================================
+void StdObject_Location::PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
+{
+  theChildren.Append(myData);
+}
 
 //=======================================================================
 //function : Import
index b082b1e..29a0854 100644 (file)
 #define _StdObject_Location_HeaderFile
 
 #include <StdObjMgt_ReadData.hxx>
+#include <StdObjMgt_WriteData.hxx>
+#include <StdObjMgt_Persistent.hxx>
+#include <StdObjMgt_TransientPersistentMap.hxx>
 
 #include <TopLoc_Location.hxx>
 
-
 class StdObject_Location
 {
 public:
+
+  //! Gets persistent child objects
+  Standard_EXPORT void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const;
+
   //! Import transient object from the persistent data.
   TopLoc_Location Import() const;
 
+  //! Creates a persistent wrapper object for a location
+  Standard_EXPORT static StdObject_Location Translate (const TopLoc_Location& theLoc,
+                                                       StdObjMgt_TransientPersistentMap& theMap);
+
 private:
   Handle(StdObjMgt_Persistent) myData;
 
   friend StdObjMgt_ReadData& operator >>
     (StdObjMgt_ReadData::Object, StdObject_Location&);
+  friend StdObjMgt_WriteData& operator <<
+    (StdObjMgt_WriteData::Object, const StdObject_Location&);
 };
 
 //! Read persistent data from a file.
@@ -40,4 +52,11 @@ inline StdObjMgt_ReadData& operator >>
   return theReadData >> theLocation.myData;
 }
 
+//! Write persistent data to a file.
+inline StdObjMgt_WriteData& operator <<
+(StdObjMgt_WriteData::Object theWriteData, const StdObject_Location& theLocation)
+{
+  return theWriteData << theLocation.myData;
+}
+
 #endif
index dad07af..5950fb3 100644 (file)
@@ -31,3 +31,13 @@ TopoDS_Shape StdObject_Shape::Import() const
 
   return aShape;
 }
+
+//=======================================================================
+//function : PChildren
+//purpose  : 
+//=======================================================================
+void StdObject_Shape::PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
+{
+  theChildren.Append(myTShape);
+  myLocation.PChildren(theChildren);
+}
\ No newline at end of file
index a4908f4..58d0111 100644 (file)
@@ -16,6 +16,7 @@
 #define _StdObject_Shape_HeaderFile
 
 #include <StdObjMgt_ReadData.hxx>
+#include <StdObjMgt_WriteData.hxx>
 #include <StdObject_Location.hxx>
 #include <StdPersistent_TopoDS.hxx>
 
 
 class StdObject_Shape
 {
+  friend class ShapePersistent_TopoDS;
+
 public:
   //! Import transient object from the persistent data.
   Standard_EXPORT TopoDS_Shape Import() const;
 
+  Standard_EXPORT void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const;
+
 protected:
   //! Read persistent data from a file.
   inline void read (StdObjMgt_ReadData& theReadData)
     { theReadData >> myTShape >> myLocation >> myOrient; }
 
-private:
+  //! Write persistent data to a file.
+  inline void write (StdObjMgt_WriteData& theWriteData) const
+    { theWriteData << myTShape << myLocation << myOrient; }
+
+protected:
   Handle(StdPersistent_TopoDS::TShape) myTShape;
   StdObject_Location                   myLocation;
   Standard_Integer                     myOrient;
 
   friend StdObjMgt_ReadData& operator >>
     (StdObjMgt_ReadData::Object, StdObject_Shape&);
+  friend StdObjMgt_WriteData& operator <<
+    (StdObjMgt_WriteData::Object, const StdObject_Shape&);
 };
 
 //! Read persistent data from a file.
@@ -50,4 +61,12 @@ inline StdObjMgt_ReadData& operator >>
   return theReadData;
 }
 
+//! Write persistent data to a file.
+inline StdObjMgt_WriteData& operator <<
+  (StdObjMgt_WriteData::Object theWriteData, const StdObject_Shape& theShape)
+{
+  theShape.write (theWriteData);
+  return theWriteData;
+}
+
 #endif
index 44de3aa..f5c78bc 100644 (file)
@@ -35,6 +35,24 @@ inline StdObjMgt_ReadData& operator >>
   return theReadData;
 }
 
+inline StdObjMgt_WriteData& 
+  write (StdObjMgt_WriteData::Object theWriteData, const gp_Ax2d& theAx)
+{
+  const gp_Pnt2d& aLoc = theAx.Location();
+  const gp_Dir2d& aDir = theAx.Direction();
+  theWriteData << aLoc << aDir;
+  return theWriteData;
+}
+
+inline StdObjMgt_WriteData& operator <<
+  (StdObjMgt_WriteData::Object theWriteData, const gp_Ax2d& theAx)
+{
+  const gp_Pnt2d& aLoc = theAx.Location();
+  const gp_Dir2d& aDir = theAx.Direction();
+  theWriteData << aLoc << aDir;
+  return theWriteData;
+}
+
 inline StdObjMgt_ReadData& operator >>
   (StdObjMgt_ReadData::Object theReadData, gp_Ax22d& theAx)
 {
@@ -45,16 +63,44 @@ inline StdObjMgt_ReadData& operator >>
   return theReadData;
 }
 
+inline StdObjMgt_WriteData& operator <<
+  (StdObjMgt_WriteData::Object theWriteData, const gp_Ax22d& theAx)
+{
+  const gp_Pnt2d& aLoc = theAx.Location();
+  const gp_Dir2d& aYDir = theAx.YDirection();
+  const gp_Dir2d& aXDir = theAx.XDirection();
+  theWriteData << aLoc << aYDir << aXDir;
+  return theWriteData;
+}
+
 inline StdObjMgt_ReadData& operator >>
   (StdObjMgt_ReadData::Object theReadData, gp_Ax1& theAx)
 {
-  gp_XYZ aLoc;
+  gp_Pnt aLoc;
   gp_Dir aDir;
   theReadData >> aLoc >> aDir;
   theAx = gp_Ax1 (aLoc, aDir);
   return theReadData;
 }
 
+inline StdObjMgt_WriteData&
+  write(StdObjMgt_WriteData::Object theWriteData, const gp_Ax1& theAx)
+{
+  const gp_Pnt& aLoc = theAx.Location();
+  const gp_Dir& aDir = theAx.Direction();
+  theWriteData << aLoc << aDir;
+  return theWriteData;
+}
+
+inline StdObjMgt_WriteData& operator <<
+  (StdObjMgt_WriteData::Object theWriteData, const gp_Ax1& theAx)
+{
+  const gp_Pnt& aLoc = theAx.Location();
+  const gp_Dir& aDir = theAx.Direction();
+  theWriteData << aLoc << aDir;
+  return theWriteData;
+}
+
 inline StdObjMgt_ReadData& operator >>
   (StdObjMgt_ReadData::Object theReadData, gp_Ax2& theAx)
 {
@@ -65,6 +111,16 @@ inline StdObjMgt_ReadData& operator >>
   return theReadData;
 }
 
+inline StdObjMgt_WriteData& operator <<
+  (StdObjMgt_WriteData::Object theWriteData, const gp_Ax2& theAx)
+{
+  const gp_Ax1& anAx = theAx.Axis();
+  const gp_Dir& aYDir = theAx.YDirection();
+  const gp_Dir& aXDir = theAx.XDirection();
+  theWriteData << anAx << aYDir << aXDir;
+  return theWriteData;
+}
+
 inline StdObjMgt_ReadData& operator >>
   (StdObjMgt_ReadData::Object theReadData, gp_Ax3& theAx)
 {
@@ -77,5 +133,15 @@ inline StdObjMgt_ReadData& operator >>
   return theReadData;
 }
 
+inline StdObjMgt_WriteData& operator <<
+(StdObjMgt_WriteData::Object theWriteData, const gp_Ax3& theAx)
+{
+  const gp_Ax1& anAx = theAx.Axis();
+  const gp_Dir& aYDir = theAx.YDirection();
+  const gp_Dir& aXDir = theAx.XDirection();
+  theWriteData << anAx << aYDir << aXDir;
+  return theWriteData;
+}
+
 
 #endif
index aef2e17..4ea0132 100644 (file)
@@ -31,7 +31,7 @@
 
 
 inline StdObjMgt_ReadData& operator >>
-  (StdObjMgt_ReadData::Object theReadData, gp_Lin2d& theLin)
+  (StdObjMgt_ReadData& theReadData, gp_Lin2d& theLin)
 {
   gp_Ax2d anAx;
   theReadData >> anAx;
@@ -39,8 +39,16 @@ inline StdObjMgt_ReadData& operator >>
   return theReadData;
 }
 
+inline StdObjMgt_WriteData& operator <<
+  (StdObjMgt_WriteData& theWriteData, const gp_Lin2d& theLin)
+{
+  const gp_Ax2d& anAx = theLin.Position();
+  write (theWriteData, anAx);
+  return theWriteData;
+}
+
 inline StdObjMgt_ReadData& operator >>
-  (StdObjMgt_ReadData::Object theReadData, gp_Circ2d& theCirc)
+  (StdObjMgt_ReadData& theReadData, gp_Circ2d& theCirc)
 {
   gp_Ax22d anAx;
   Standard_Real aRadius;
@@ -53,8 +61,17 @@ inline StdObjMgt_ReadData& operator >>
   return theReadData;
 }
 
+inline StdObjMgt_WriteData& operator <<
+  (StdObjMgt_WriteData& theWriteData, const gp_Circ2d& theCirc)
+{
+  const gp_Ax22d& anAx = theCirc.Position();
+  Standard_Real aRadius = theCirc.Radius();
+  theWriteData << anAx << aRadius;
+  return theWriteData;
+}
+
 inline StdObjMgt_ReadData& operator >>
-  (StdObjMgt_ReadData::Object theReadData, gp_Elips2d& theElips)
+  (StdObjMgt_ReadData& theReadData, gp_Elips2d& theElips)
 {
   gp_Ax22d anAx;
   Standard_Real aMajorRadius, aMinorRadius;
@@ -68,8 +85,18 @@ inline StdObjMgt_ReadData& operator >>
   return theReadData;
 }
 
+inline StdObjMgt_WriteData& operator <<
+  (StdObjMgt_WriteData& theWriteData, const gp_Elips2d& theElips)
+{
+  const gp_Ax22d& anAx = theElips.Axis();
+  Standard_Real aMajorRadius = theElips.MajorRadius();
+  Standard_Real aMinorRadius = theElips.MinorRadius();
+  theWriteData << anAx << aMajorRadius << aMinorRadius;
+  return theWriteData;
+}
+
 inline StdObjMgt_ReadData& operator >>
-  (StdObjMgt_ReadData::Object theReadData, gp_Hypr2d& theHypr)
+  (StdObjMgt_ReadData& theReadData, gp_Hypr2d& theHypr)
 {
   gp_Ax22d anAx;
   Standard_Real aMajorRadius, aMinorRadius;
@@ -83,8 +110,18 @@ inline StdObjMgt_ReadData& operator >>
   return theReadData;
 }
 
+inline StdObjMgt_WriteData& operator <<
+  (StdObjMgt_WriteData& theWriteData, const gp_Hypr2d& theHypr)
+{
+  const gp_Ax22d& anAx = theHypr.Axis();
+  Standard_Real aMajorRadius = theHypr.MajorRadius();
+  Standard_Real aMinorRadius = theHypr.MinorRadius();
+  theWriteData << anAx << aMajorRadius << aMinorRadius;
+  return theWriteData;
+}
+
 inline StdObjMgt_ReadData& operator >>
-  (StdObjMgt_ReadData::Object theReadData, gp_Parab2d& theParab)
+  (StdObjMgt_ReadData& theReadData, gp_Parab2d& theParab)
 {
   gp_Ax22d anAx;
   Standard_Real aFocalLength;
@@ -97,8 +134,17 @@ inline StdObjMgt_ReadData& operator >>
   return theReadData;
 }
 
+inline StdObjMgt_WriteData& operator <<
+  (StdObjMgt_WriteData& theWriteData, const gp_Parab2d& theParab)
+{
+  const gp_Ax22d& anAx = theParab.Axis();
+  Standard_Real aFocalLength = theParab.Focal();
+  theWriteData << anAx << aFocalLength;
+  return theWriteData;
+}
+
 inline StdObjMgt_ReadData& operator >>
-  (StdObjMgt_ReadData::Object theReadData, gp_Lin& theLin)
+  (StdObjMgt_ReadData& theReadData, gp_Lin& theLin)
 {
   gp_Ax1 anAx;
   theReadData >> anAx;
@@ -106,8 +152,16 @@ inline StdObjMgt_ReadData& operator >>
   return theReadData;
 }
 
+inline StdObjMgt_WriteData& operator <<
+  (StdObjMgt_WriteData& theWriteData, const gp_Lin& theLin)
+{
+  const gp_Ax1& anAx = theLin.Position();
+  write (theWriteData, anAx);
+  return theWriteData;
+}
+
 inline StdObjMgt_ReadData& operator >>
-  (StdObjMgt_ReadData::Object theReadData, gp_Circ& theCirc)
+  (StdObjMgt_ReadData& theReadData, gp_Circ& theCirc)
 {
   gp_Ax2 anAx;
   Standard_Real aRadius;
@@ -120,8 +174,17 @@ inline StdObjMgt_ReadData& operator >>
   return theReadData;
 }
 
+inline StdObjMgt_WriteData& operator <<
+  (StdObjMgt_WriteData& theWriteData, const gp_Circ& theCirc)
+{
+  const gp_Ax2& anAx = theCirc.Position();
+  Standard_Real aRadius = theCirc.Radius();
+  theWriteData << anAx << aRadius;
+  return theWriteData;
+}
+
 inline StdObjMgt_ReadData& operator >>
-  (StdObjMgt_ReadData::Object theReadData, gp_Elips& theElips)
+  (StdObjMgt_ReadData& theReadData, gp_Elips& theElips)
 {
   gp_Ax2 anAx;
   Standard_Real aMajorRadius, aMinorRadius;
@@ -135,8 +198,18 @@ inline StdObjMgt_ReadData& operator >>
   return theReadData;
 }
 
+inline StdObjMgt_WriteData& operator <<
+  (StdObjMgt_WriteData& theWriteData, const gp_Elips& theElips)
+{
+  const gp_Ax2& anAx = theElips.Position();
+  Standard_Real aMajorRadius = theElips.MajorRadius();
+  Standard_Real aMinorRadius = theElips.MinorRadius();
+  theWriteData << anAx << aMajorRadius << aMinorRadius;
+  return theWriteData;
+}
+
 inline StdObjMgt_ReadData& operator >>
-  (StdObjMgt_ReadData::Object theReadData, gp_Hypr& theHypr)
+  (StdObjMgt_ReadData& theReadData, gp_Hypr& theHypr)
 {
   gp_Ax2 anAx;
   Standard_Real aMajorRadius, aMinorRadius;
@@ -150,8 +223,18 @@ inline StdObjMgt_ReadData& operator >>
   return theReadData;
 }
 
+inline StdObjMgt_WriteData& operator <<
+  (StdObjMgt_WriteData& theWriteData, const gp_Hypr& theHypr)
+{
+  const gp_Ax2& anAx = theHypr.Position();
+  Standard_Real aMajorRadius = theHypr.MajorRadius();
+  Standard_Real aMinorRadius = theHypr.MinorRadius();
+  theWriteData << anAx << aMajorRadius << aMinorRadius;
+  return theWriteData;
+}
+
 inline StdObjMgt_ReadData& operator >>
-  (StdObjMgt_ReadData::Object theReadData, gp_Parab& theParab)
+  (StdObjMgt_ReadData& theReadData, gp_Parab& theParab)
 {
   gp_Ax2 anAx;
   Standard_Real aFocalLength;
@@ -164,5 +247,14 @@ inline StdObjMgt_ReadData& operator >>
   return theReadData;
 }
 
+inline StdObjMgt_WriteData& operator <<
+(StdObjMgt_WriteData& theWriteData, const gp_Parab& theParab)
+{
+  const gp_Ax2& anAx = theParab.Position();
+  Standard_Real aFocalLength = theParab.Focal();
+  theWriteData << anAx << aFocalLength;
+  return theWriteData;
+}
+
 
 #endif
index 074a623..c561ad5 100644 (file)
@@ -25,7 +25,7 @@
 
 
 inline StdObjMgt_ReadData& operator >>
-  (StdObjMgt_ReadData::Object theReadData, gp_Cone& theCone)
+  (StdObjMgt_ReadData& theReadData, gp_Cone& theCone)
 {
   gp_Ax3 anAx;
   Standard_Real aRadius, aSemiAngle;
@@ -39,8 +39,18 @@ inline StdObjMgt_ReadData& operator >>
   return theReadData;
 }
 
+inline StdObjMgt_WriteData& operator <<
+  (StdObjMgt_WriteData& theWriteData, const gp_Cone& theCone)
+{
+  const gp_Ax3& anAx = theCone.Position();
+  Standard_Real aRadius = theCone.RefRadius();
+  Standard_Real aSemiAngle = theCone.SemiAngle();
+  theWriteData << anAx << aRadius << aSemiAngle;
+  return theWriteData;
+}
+
 inline StdObjMgt_ReadData& operator >>
-  (StdObjMgt_ReadData::Object theReadData, gp_Cylinder& theCyl)
+  (StdObjMgt_ReadData& theReadData, gp_Cylinder& theCyl)
 {
   gp_Ax3 anAx;
   Standard_Real aRadius;
@@ -53,8 +63,17 @@ inline StdObjMgt_ReadData& operator >>
   return theReadData;
 }
 
+inline StdObjMgt_WriteData& operator <<
+  (StdObjMgt_WriteData& theWriteData, const gp_Cylinder& theCyl)
+{
+  const gp_Ax3& anAx = theCyl.Position();
+  Standard_Real aRadius = theCyl.Radius();
+  theWriteData << anAx << aRadius;
+  return theWriteData;
+}
+
 inline StdObjMgt_ReadData& operator >>
-  (StdObjMgt_ReadData::Object theReadData, gp_Sphere& theSph)
+  (StdObjMgt_ReadData& theReadData, gp_Sphere& theSph)
 {
   gp_Ax3 anAx;
   Standard_Real aRadius;
@@ -67,8 +86,17 @@ inline StdObjMgt_ReadData& operator >>
   return theReadData;
 }
 
+inline StdObjMgt_WriteData& operator <<
+(StdObjMgt_WriteData& theWriteData, const gp_Sphere& theSph)
+{
+  const gp_Ax3& anAx = theSph.Position();
+  Standard_Real aRadius = theSph.Radius();
+  theWriteData << anAx << aRadius;
+  return theWriteData;
+}
+
 inline StdObjMgt_ReadData& operator >>
-  (StdObjMgt_ReadData::Object theReadData, gp_Torus& theTorus)
+  (StdObjMgt_ReadData& theReadData, gp_Torus& theTorus)
 {
   gp_Ax3 anAx;
   Standard_Real aMajorRadius, aMinorRadius;
@@ -82,5 +110,15 @@ inline StdObjMgt_ReadData& operator >>
   return theReadData;
 }
 
+inline StdObjMgt_WriteData& operator <<
+(StdObjMgt_WriteData& theWriteData, const gp_Torus& theTorus)
+{
+  const gp_Ax3& anAx = theTorus.Position();
+  Standard_Real aMajorRadius = theTorus.MajorRadius();
+  Standard_Real aMinorRadius = theTorus.MinorRadius();
+  theWriteData << anAx << aMajorRadius << aMinorRadius;
+  return theWriteData;
+}
+
 
 #endif
index a8e06bd..54cc6a2 100644 (file)
 inline StdObjMgt_ReadData& operator >>
   (StdObjMgt_ReadData::Object theReadData, gp_Mat2d& theMat)
 {
-  gp_XY aRow1, aRow2;
-  theReadData >> aRow1 >> aRow2;
-  theMat.SetRows (aRow1, aRow2);
+  theReadData
+    >> theMat(1, 1) >> theMat(1, 2)
+    >> theMat(2, 1) >> theMat(2, 2);
   return theReadData;
 }
 
+inline StdObjMgt_WriteData& operator <<
+  (StdObjMgt_WriteData::Object theWriteData, const gp_Mat2d& theMat)
+{
+  theWriteData
+    << theMat(1, 1) << theMat(1, 2)
+    << theMat(2, 1) << theMat(2, 2);
+  return theWriteData;
+}
+
 inline StdObjMgt_ReadData& operator >>
   (StdObjMgt_ReadData::Object theReadData, gp_Mat& theMat)
 {
-  gp_XYZ aRow1, aRow2, aRow3;
-  theReadData >> aRow1 >> aRow2 >> aRow3;
-  theMat.SetRows (aRow1, aRow2, aRow3);
+  theReadData
+    >> theMat(1, 1) >> theMat(1, 2) >> theMat(1, 3)
+    >> theMat(2, 1) >> theMat(2, 2) >> theMat(2, 3)
+    >> theMat(3, 1) >> theMat(3, 2) >> theMat(3, 3);
   return theReadData;
 }
 
+inline StdObjMgt_WriteData& operator <<
+  (StdObjMgt_WriteData::Object theWriteData, const gp_Mat& theMat)
+{
+  theWriteData
+    << theMat(1, 1) << theMat(1, 2) << theMat(1, 3)
+    << theMat(2, 1) << theMat(2, 2) << theMat(2, 3)
+    << theMat(3, 1) << theMat(3, 2) << theMat(3, 3);
+  return theWriteData;
+}
+
 inline StdObjMgt_ReadData& operator >>
   (StdObjMgt_ReadData::Object theReadData, gp_Trsf2d& theTrsf)
 {
@@ -58,6 +78,19 @@ inline StdObjMgt_ReadData& operator >>
   return theReadData;
 }
 
+inline StdObjMgt_WriteData& operator <<
+(StdObjMgt_WriteData::Object theWriteData, const gp_Trsf2d& theTrsf)
+{
+  Standard_Real    aScale = theTrsf.ScaleFactor();
+  Standard_Integer aForm  = theTrsf.Form();
+  const gp_Mat2d&  aMat   = theTrsf.HVectorialPart();
+  const gp_XY&     aLoc   = theTrsf.TranslationPart();
+
+  theWriteData << aScale << aForm << aMat << aLoc;
+
+  return theWriteData;
+}
+
 inline StdObjMgt_ReadData& operator >>
   (StdObjMgt_ReadData::Object theReadData, gp_Trsf& theTrsf)
 {
@@ -76,5 +109,17 @@ inline StdObjMgt_ReadData& operator >>
   return theReadData;
 }
 
+inline StdObjMgt_WriteData& operator <<
+  (StdObjMgt_WriteData::Object theWriteData, const gp_Trsf& theTrsf)
+{
+  Standard_Real    aScale = theTrsf.ScaleFactor();
+  Standard_Integer aForm  = theTrsf.Form();
+  const gp_Mat&    aMat   = theTrsf.HVectorialPart();
+  const gp_XYZ&    aLoc   = theTrsf.TranslationPart();
+
+  theWriteData << aScale << aForm << aMat << aLoc;
+
+  return theWriteData;
+}
 
 #endif
index 3c7a743..4090a25 100644 (file)
@@ -17,6 +17,7 @@
 
 
 #include <StdObjMgt_ReadData.hxx>
+#include <StdObjMgt_WriteData.hxx>
 
 #include <gp_Pnt2d.hxx>
 #include <gp_Vec2d.hxx>
@@ -35,68 +36,126 @@ inline StdObjMgt_ReadData& operator >>
   return theReadData;
 }
 
+inline StdObjMgt_WriteData& operator <<
+  (StdObjMgt_WriteData::Object theWriteData, const gp_XY& theXY)
+{
+  Standard_Real aX = theXY.X(), aY = theXY.Y();
+  theWriteData << aX << aY;
+  return theWriteData;
+}
+
 inline StdObjMgt_ReadData& operator >>
   (StdObjMgt_ReadData::Object theReadData, gp_Pnt2d& thePnt)
 {
-  Standard_Real aX, aY;
-  theReadData >> aX >> aY;
-  thePnt.SetCoord (aX, aY);
+  gp_XY aXY;
+  theReadData >> aXY;
+  thePnt.SetXY (aXY);
   return theReadData;
 }
 
+inline StdObjMgt_WriteData& operator <<
+  (StdObjMgt_WriteData::Object theWriteData, const gp_Pnt2d& thePnt)
+{
+  theWriteData << thePnt.XY();
+  return theWriteData;
+}
+
 inline StdObjMgt_ReadData& operator >>
   (StdObjMgt_ReadData::Object theReadData, gp_Vec2d& theVec)
 {
-  Standard_Real aX, aY;
-  theReadData >> aX >> aY;
-  theVec.SetCoord (aX, aY);
+  gp_XY aXY;
+  theReadData >> aXY;
+  theVec.SetXY (aXY);
   return theReadData;
 }
 
+inline StdObjMgt_WriteData& operator <<
+  (StdObjMgt_WriteData::Object theWriteData, const gp_Vec2d& theVec)
+{
+  theWriteData << theVec.XY();
+  return theWriteData;
+}
+
 inline StdObjMgt_ReadData& operator >>
   (StdObjMgt_ReadData::Object theReadData, gp_Dir2d& theDir)
 {
-  Standard_Real aX, aY;
-  theReadData >> aX >> aY;
-  theDir.SetCoord (aX, aY);
+  gp_XY aXY;
+  theReadData >> aXY;
+  theDir.SetXY (aXY);
   return theReadData;
 }
 
+inline StdObjMgt_WriteData& operator <<
+  (StdObjMgt_WriteData::Object theWriteData, const gp_Dir2d& theDir)
+{
+  theWriteData << theDir.XY();
+  return theWriteData;
+}
+
 inline StdObjMgt_ReadData& operator >>
   (StdObjMgt_ReadData::Object theReadData, gp_XYZ& theXYZ)
 {
   Standard_Real aX, aY, aZ;
   theReadData >> aX >> aY >> aZ;
-  theXYZ.SetCoord (aX, aY, aZ);
+  theXYZ.SetCoord(aX, aY, aZ);
   return theReadData;
 }
 
+inline StdObjMgt_WriteData& operator <<
+  (StdObjMgt_WriteData::Object theWriteData, const gp_XYZ& theXYZ)
+{
+  Standard_Real aX = theXYZ.X(), aY = theXYZ.Y(), aZ = theXYZ.Z();
+  theWriteData << aX << aY << aZ;
+  return theWriteData;
+}
+
 inline StdObjMgt_ReadData& operator >>
   (StdObjMgt_ReadData::Object theReadData, gp_Pnt& thePnt)
 {
-  Standard_Real aX, aY, aZ;
-  theReadData >> aX >> aY >> aZ;
-  thePnt.SetCoord (aX, aY, aZ);
+  gp_XYZ aXYZ;
+  theReadData >> aXYZ;
+  thePnt.SetXYZ (aXYZ);
   return theReadData;
 }
 
+inline StdObjMgt_WriteData& operator <<
+  (StdObjMgt_WriteData::Object theWriteData, const gp_Pnt& thePnt)
+{
+  theWriteData << thePnt.XYZ();
+  return theWriteData;
+}
+
 inline StdObjMgt_ReadData& operator >>
   (StdObjMgt_ReadData::Object theReadData, gp_Vec& theVec)
 {
-  Standard_Real aX, aY, aZ;
-  theReadData >> aX >> aY >> aZ;
-  theVec.SetCoord (aX, aY, aZ);
+  gp_XYZ aXYZ;
+  theReadData >> aXYZ;
+  theVec.SetXYZ (aXYZ);
   return theReadData;
 }
 
+inline StdObjMgt_WriteData& operator <<
+  (StdObjMgt_WriteData::Object theWriteData, const gp_Vec& theVec)
+{
+  theWriteData << theVec.XYZ();
+  return theWriteData;
+}
+
 inline StdObjMgt_ReadData& operator >>
   (StdObjMgt_ReadData::Object theReadData, gp_Dir& theDir)
 {
-  Standard_Real aX, aY, aZ;
-  theReadData >> aX >> aY >> aZ;
-  theDir.SetCoord (aX, aY, aZ);
+  gp_XYZ aXYZ;
+  theReadData >> aXYZ;
+  theDir.SetXYZ(aXYZ);
   return theReadData;
 }
 
+inline StdObjMgt_WriteData& operator <<
+  (StdObjMgt_WriteData::Object theWriteData, const gp_Dir& theDir)
+{
+  theWriteData << theDir.XYZ();
+  return theWriteData;
+}
+
 
 #endif
index 8ca1106..38a6cdb 100644 (file)
@@ -16,7 +16,6 @@
 #define _StdPersistent_HeaderFile
 
 #include <Standard_Macro.hxx>
-
 class StdObjMgt_MapOfInstantiators;
 
 class StdPersistent
index fd4943e..91c4015 100644 (file)
@@ -59,4 +59,34 @@ public:
   };
 };
 
+template<>
+inline Standard_CString StdLPersistent_Void::instance<TDataXtd_Shape>::PName() const
+  { return "PDataXtd_Shape"; }
+
+template<>
+inline Standard_CString StdLPersistent_Void::instance<TDataXtd_Point>::PName() const
+  { return "PDataXtd_Point"; }
+
+template<>
+inline Standard_CString StdLPersistent_Void::instance<TDataXtd_Axis>::PName() const
+  { return "PDataXtd_Axis"; }
+
+template<>
+inline Standard_CString StdLPersistent_Void::instance<TDataXtd_Plane>::PName() const
+  { return "PDataXtd_Plane"; }
+
+template<>
+inline Standard_CString StdLPersistent_Void::instance<TDataXtd_Placement>::PName() const
+  { return "PDataXtd_Placement"; }
+
+template<>
+template<>
+inline Standard_CString StdObjMgt_Attribute<TDataXtd_Geometry>::Simple<Standard_Integer>::PName() const
+  { return "PDataXtd_Geometry"; }
+
+template<>
+template<>
+inline Standard_CString StdObjMgt_Attribute<TDataXtd_Position>::Simple<gp_Pnt>::PName() const
+  { return "PDataXtd_Position"; }
+
 #endif
index b5e1caf..dc3ea36 100644 (file)
@@ -31,6 +31,21 @@ public:
     theReadData >> myType >> myGeometries >> myValue
                 >> myIsReversed >> myIsInverted >> myIsVerified >> myPlane;
   }
+  //! Write persistent data to a file.
+  inline void Write (StdObjMgt_WriteData& theWriteData) const
+  {
+    theWriteData << myType << myGeometries << myValue
+      << myIsReversed << myIsInverted << myIsVerified << myPlane;
+  }
+  //! Gets persistent child objects
+  inline void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const 
+  {
+    theChildren.Append(myGeometries);
+    theChildren.Append(myValue);
+    theChildren.Append(myPlane);
+  }
+  //! Returns persistent type name
+  inline Standard_CString PName() const { return "PDataXtd_Constraint"; }
 
   //! Import transient attribuite from the persistent data.
   void Import (const Handle(TDataXtd_Constraint)& theAttribute) const;
index 08de381..acb1782 100644 (file)
@@ -30,6 +30,25 @@ public:
     theReadData >> mySignature >> myAxis1Reversed >> myAxis2Reversed >>
       myAxis1 >> myAxis2 >> myValue1 >> myValue2 >> myNb1 >> myNb2 >> myMirror;
   }
+  //! Write persistent data to a file.
+  inline void Write(StdObjMgt_WriteData& theWriteData)
+  {
+    theWriteData << mySignature << myAxis1Reversed << myAxis2Reversed <<
+      myAxis1 << myAxis2 << myValue1 << myValue2 << myNb1 << myNb2 << myMirror;
+  }
+  //! Gets persistent child objects
+  inline void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
+  {
+    theChildren.Append(myAxis1);
+    theChildren.Append(myAxis2);
+    theChildren.Append(myValue1);
+    theChildren.Append(myValue2);
+    theChildren.Append(myNb1);
+    theChildren.Append(myNb2);
+    theChildren.Append(myMirror);
+  }
+  //! Returns persistent type name
+  inline Standard_CString PName() const { return "PDataXtd_PatternStd"; }
 
   //! Import transient attribuite from the persistent data.
   void Import (const Handle(TDataXtd_PatternStd)& theAttribute) const;
index aaf009f..a2609df 100644 (file)
@@ -62,6 +62,15 @@ void StdPersistent_Naming::Name::Read (StdObjMgt_ReadData& theReadData)
 }
 
 //=======================================================================
+//function : Write
+//purpose  : Write persistent data to a file
+//=======================================================================
+void StdPersistent_Naming::Name::Write (StdObjMgt_WriteData& theWriteData) const
+{
+  theWriteData << myType << myShapeType << myArgs << myStop << myIndex;
+}
+
+//=======================================================================
 //function : Import
 //purpose  : Import transient object from the persistent data
 //=======================================================================
@@ -105,6 +114,16 @@ void StdPersistent_Naming::Name_1::Read (StdObjMgt_ReadData& theReadData)
 }
 
 //=======================================================================
+//function : Write
+//purpose  : Write persistent data to a file
+//=======================================================================
+void StdPersistent_Naming::Name_1::Write (StdObjMgt_WriteData& theWriteData) const
+{
+  Name::Write (theWriteData);
+  theWriteData << myContextLabel;
+}
+
+//=======================================================================
 //function : Import
 //purpose  : Import transient object from the persistent data
 //=======================================================================
@@ -127,6 +146,16 @@ void StdPersistent_Naming::Name_2::Read (StdObjMgt_ReadData& theReadData)
 }
 
 //=======================================================================
+//function : Write
+//purpose  : Write persistent data to a file
+//=======================================================================
+void StdPersistent_Naming::Name_2::Write (StdObjMgt_WriteData& theWriteData) const
+{
+  Name_1::Write (theWriteData);
+  theWriteData << myOrientation;
+}
+
+//=======================================================================
 //function : Import
 //purpose  : Import transient object from the persistent data
 //=======================================================================
index dbfa8d6..cbd7a1b 100644 (file)
@@ -35,7 +35,18 @@ public:
   public:
     //! Read persistent data from a file.
     inline void Read (StdObjMgt_ReadData& theReadData)
-    { theReadData >> myOldShapes >> myNewShapes >> myShapeStatus >> myVersion; }
+      { theReadData >> myOldShapes >> myNewShapes >> myShapeStatus >> myVersion; }
+    //! Read persistent data from a file.
+    inline void Write (StdObjMgt_WriteData& theWriteData) const
+      { theWriteData << myOldShapes << myNewShapes << myShapeStatus << myVersion; }
+    //! Gets persistent child objects
+    inline void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
+    {
+      if (!myOldShapes.IsNull()) theChildren.Append(myOldShapes);
+      if (!myNewShapes.IsNull()) theChildren.Append(myNewShapes);
+    }
+    //! Returns persistent type name
+    inline Standard_CString PName() const { return "PNaming_NamedShape"; }
 
     //! Import transient attribuite from the persistent data.
     void Import (const Handle(TNaming_NamedShape)& theAttribute) const;
@@ -52,6 +63,16 @@ public:
   public:
     //! Read persistent data from a file.
     Standard_EXPORT virtual void Read (StdObjMgt_ReadData& theReadData);
+    //! Read persistent data from a file.
+    Standard_EXPORT virtual void Write (StdObjMgt_WriteData& theWriteData) const;
+    //! Gets persistent child objects
+    inline void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
+    {
+      if (!myArgs.IsNull()) theChildren.Append(myArgs);
+      if (!myStop.IsNull()) theChildren.Append(myStop);
+    }
+    //! Returns persistent type name
+    inline Standard_CString PName() const { return "PNaming_Name"; }
 
     //! Import transient object from the persistent data.
     Standard_EXPORT virtual void Import
@@ -70,6 +91,16 @@ public:
   public:
     //! Read persistent data from a file.
     Standard_EXPORT virtual void Read (StdObjMgt_ReadData& theReadData);
+    //! Read persistent data from a file.
+    Standard_EXPORT virtual void Write (StdObjMgt_WriteData& theWriteData) const;
+    //! Gets persistent child objects
+    inline void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
+    {
+      Name::PChildren(theChildren);
+      if (!myContextLabel.IsNull()) theChildren.Append(myContextLabel);
+    }
+    //! Returns persistent type name
+    inline Standard_CString PName() const { return "PNaming_Name_1"; }
 
     //! Import transient object from the persistent data.
     Standard_EXPORT virtual void Import
@@ -84,6 +115,13 @@ public:
   public:
     //! Read persistent data from a file.
     Standard_EXPORT virtual void Read (StdObjMgt_ReadData& theReadData);
+    //! Read persistent data from a file.
+    Standard_EXPORT virtual void Write (StdObjMgt_WriteData& theWriteData) const;
+    //! Gets persistent child objects
+    inline void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
+      { Name_1::PChildren(theChildren); }
+    //! Returns persistent type name
+    inline Standard_CString PName() const { return "PNaming_Name_2"; }
 
     //! Import transient object from the persistent data.
     Standard_EXPORT virtual void Import
index 672f9ba..c5664f4 100644 (file)
@@ -32,6 +32,19 @@ public:
       theReadData >> myIsDisplayed >> myDriverGUID
         >> myTransparency >> myColor >> myMaterial >> myWidth;
     }
+    //! Write persistent data to a file.
+    inline void Write (StdObjMgt_WriteData& theWriteData) const
+    {
+      theWriteData << myIsDisplayed << myDriverGUID
+        << myTransparency << myColor << myMaterial << myWidth;
+    }
+    //! Gets persistent child objects
+    inline void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
+    {
+      theChildren.Append(myDriverGUID);
+    }
+    //! Returns persistent type name
+    inline Standard_CString PName() const { return "PPrsStd_AISPresentation"; }
 
     //! Import transient attribuite from the persistent data.
     void Import (const Handle(TDataXtd_Presentation)& theAttribute) const;
@@ -54,6 +67,14 @@ public:
       AISPresentation::Read (theReadData);
       theReadData >> myMode;
     }
+    //! Write persistent data to a file.
+    inline void Write (StdObjMgt_WriteData& theWriteData)
+    {
+      AISPresentation::Write (theWriteData);
+      theWriteData << myMode;
+    }
+    //! Returns persistent type name
+    inline Standard_CString PName() const { return "PPrsStd_AISPresentation_1"; }
 
     //! Import transient attribuite from the persistent data.
     void Import (const Handle(TDataXtd_Presentation)& theAttribute) const;
index 3f26abc..8c020fe 100644 (file)
@@ -13,6 +13,7 @@
 
 #include <StdPersistent_TopLoc.hxx>
 #include <StdObjMgt_ReadData.hxx>
+#include <StdObjMgt_WriteData.hxx>
 #include <StdObject_gp_Trsfs.hxx>
 
 
@@ -27,6 +28,11 @@ void StdPersistent_TopLoc::Datum3D::Read (StdObjMgt_ReadData& theReadData)
   myTransient = new TopLoc_Datum3D (aTrsf);
 }
 
+void StdPersistent_TopLoc::Datum3D::Write(StdObjMgt_WriteData& theWriteData) const
+{
+  theWriteData << myTransient->Transformation();
+}
+
 //=======================================================================
 //function : Read
 //purpose  : Read persistent data from a file
@@ -37,6 +43,26 @@ void StdPersistent_TopLoc::ItemLocation::Read (StdObjMgt_ReadData& theReadData)
 }
 
 //=======================================================================
+//function : Write
+//purpose  : Write persistent data to a file
+//=======================================================================
+void StdPersistent_TopLoc::ItemLocation::Write (StdObjMgt_WriteData& theWriteData) const
+{
+  theWriteData << myDatum << myPower << myNext;
+}
+
+//=======================================================================
+//function : PChildren
+//purpose  : Gets persistent child objects
+//=======================================================================
+void StdPersistent_TopLoc::ItemLocation::PChildren
+  (StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
+{
+  theChildren.Append(myDatum);
+  myNext.PChildren(theChildren);
+}
+
+//=======================================================================
 //function : Import
 //purpose  : Import transient object from the persistent data
 //=======================================================================
@@ -48,3 +74,40 @@ TopLoc_Location StdPersistent_TopLoc::ItemLocation::Import() const
   else
     return aNext;
 }
+
+//=======================================================================
+//function : Translate
+//purpose  : Create a persistent object from a location
+//=======================================================================
+Handle(StdPersistent_TopLoc::ItemLocation) 
+StdPersistent_TopLoc::Translate (const TopLoc_Location& theLoc,
+                                 StdObjMgt_TransientPersistentMap& theMap)
+{
+  Handle(ItemLocation) aPLoc = new ItemLocation;
+  aPLoc->myDatum = Translate(theLoc.FirstDatum(), theMap);
+  aPLoc->myPower = theLoc.FirstPower();
+  aPLoc->myNext = StdObject_Location::Translate(theLoc.NextLocation(), theMap);
+  return aPLoc;
+}
+
+//=======================================================================
+//function : Translate
+//purpose  : Create a persistent object from a location datum
+//=======================================================================
+Handle(StdPersistent_TopLoc::Datum3D) 
+StdPersistent_TopLoc::Translate (const Handle(TopLoc_Datum3D)& theDatum,
+                                 StdObjMgt_TransientPersistentMap& theMap)
+{
+  Handle(Datum3D) aPDatum;
+  if (theMap.IsBound(theDatum))
+  {
+    aPDatum = Handle(Datum3D)::DownCast(theMap.Find(theDatum));
+  }
+  else
+  {
+    aPDatum = new Datum3D;
+    aPDatum->Transient(theDatum);
+    theMap.Bind(theDatum, aPDatum);
+  }
+  return aPDatum;
+}
index 96804d2..d5c815b 100644 (file)
@@ -18,6 +18,7 @@
 #include <StdObjMgt_SharedObject.hxx>
 #include <StdObjMgt_Persistent.hxx>
 #include <StdObject_Location.hxx>
+#include <StdObjMgt_TransientPersistentMap.hxx>
 
 #include <TopLoc_Datum3D.hxx>
 #include <TopLoc_Location.hxx>
@@ -31,13 +32,29 @@ public:
   public:
     //! Read persistent data from a file.
     void Read (StdObjMgt_ReadData& theReadData);
+    //! Write persistent data to a file.
+    void Write (StdObjMgt_WriteData& theWriteData) const;
+    //! Gets persistent child objects
+    Standard_EXPORT virtual void PChildren(SequenceOfPersistent&) const { }
+    //! Returns persistent type name
+    Standard_EXPORT virtual Standard_CString PName () const
+      { return "PTopLoc_Datum3D"; }
   };
 
   class ItemLocation : public StdObjMgt_Persistent
   {
+    friend class StdPersistent_TopLoc;
+
   public:
     //! Read persistent data from a file.
     Standard_EXPORT virtual void Read (StdObjMgt_ReadData& theReadData);
+    //! Write persistent data to a file.
+    Standard_EXPORT virtual void Write (StdObjMgt_WriteData& theWriteData) const;
+    //! Gets persistent child objects
+    Standard_EXPORT virtual void PChildren(SequenceOfPersistent& theChildren) const;
+    //! Returns persistent type name
+    Standard_EXPORT virtual Standard_CString PName () const
+      { return "PTopLoc_ItemLocation"; }
 
     //! Import transient object from the persistent data.
     Standard_EXPORT TopLoc_Location Import() const;
@@ -47,6 +64,12 @@ public:
     Standard_Integer   myPower;
     StdObject_Location myNext;
   };
+
+public:
+  Standard_EXPORT static Handle(ItemLocation) Translate (const TopLoc_Location& theLoc,
+                                                         StdObjMgt_TransientPersistentMap& theMap);
+  Standard_EXPORT static Handle(Datum3D) Translate (const Handle(TopLoc_Datum3D)& theDatum,
+                                                    StdObjMgt_TransientPersistentMap& theMap);
 };
 
 #endif
index 79bf9b9..3062128 100644 (file)
@@ -17,6 +17,7 @@
 
 #include <StdObjMgt_SharedObject.hxx>
 #include <StdObjMgt_ReadData.hxx>
+#include <StdObjMgt_WriteData.hxx>
 
 #include <TopoDS_TShape.hxx>
 
@@ -26,9 +27,19 @@ class StdPersistent_TopoDS : protected StdObjM