n StdDrivers
n StdObject
n StdPersistent
+n StdStorage
n ShapePersistent
n TDF
n TDataStd
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.
- *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
+}
+~~~~
DDocStd::DocumentCommands(theCommands);
DDocStd::ToolsCommands(theCommands);
DDocStd::MTMCommands(theCommands);
+ DDocStd::ShapeSchemaCommands(theCommands);
}
//! 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:
--- /dev/null
+
+#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);
+
+}
DDocStd_DrawDocument.hxx
DDocStd_MTMCommands.cxx
DDocStd_ToolsCommands.cxx
+DDocStd_ShapeSchemaCommands.cxx
IDNames.tcl
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
ShapePersistent_Poly.hxx
ShapePersistent_TopoDS.cxx
ShapePersistent_TopoDS.hxx
+ShapePersistent_TriangleMode.hxx
// 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
{
//=======================================================================
-//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
{
ShapePersistent_BRep::PointRepresentation::import() const
{ return NULL; }
+//=======================================================================
+// PointOnCurve
+//=======================================================================
void ShapePersistent_BRep::PointOnCurve::Read
(StdObjMgt_ReadData& theReadData)
{
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
{
(myParameter, aCurve, myLocation.Import());
}
+//=======================================================================
+// PointsOnSurface
+//=======================================================================
void ShapePersistent_BRep::PointsOnSurface::Read
(StdObjMgt_ReadData& theReadData)
{
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)
{
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
{
(myParameter, aPCurve, aSurface, myLocation.Import());
}
+//=======================================================================
+// PointOnSurface
+//=======================================================================
void ShapePersistent_BRep::PointOnSurface::Read
(StdObjMgt_ReadData& theReadData)
{
theReadData >> myParameter2;
}
+void ShapePersistent_BRep::PointOnSurface::Write
+ (StdObjMgt_WriteData& theWriteData) const
+{
+ PointsOnSurface::Write(theWriteData);
+ theWriteData << myParameter2;
+}
+
Handle(BRep_PointRepresentation)
ShapePersistent_BRep::PointOnSurface::import() const
{
}
//=======================================================================
-//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
{
ShapePersistent_BRep::CurveRepresentation::import() const
{ return NULL; }
+//=======================================================================
+// GCurve
+//=======================================================================
void ShapePersistent_BRep::GCurve::Read
(StdObjMgt_ReadData& theReadData)
{
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)
{
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
{
return aRepresentation;
}
+//=======================================================================
+// CurveOnSurface
+//=======================================================================
void ShapePersistent_BRep::CurveOnSurface::Read
(StdObjMgt_ReadData& theReadData)
{
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
{
return aRepresentation;
}
+//=======================================================================
+// CurveOnClosedSurface
+//=======================================================================
void ShapePersistent_BRep::CurveOnClosedSurface::Read
(StdObjMgt_ReadData& theReadData)
{
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
{
return aRepresentation;
}
+//=======================================================================
+// Polygon3D
+//=======================================================================
void ShapePersistent_BRep::Polygon3D::Read
(StdObjMgt_ReadData& theReadData)
{
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
{
return new BRep_Polygon3D (aPolygon3D, myLocation.Import());
}
+//=======================================================================
+// PolygonOnTriangulation
+//=======================================================================
void ShapePersistent_BRep::PolygonOnTriangulation::Read
(StdObjMgt_ReadData& theReadData)
{
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
{
(aPolygon, aTriangulation, myLocation.Import());
}
+//=======================================================================
+// PolygonOnClosedTriangulation
+//=======================================================================
void ShapePersistent_BRep::PolygonOnClosedTriangulation::Read
(StdObjMgt_ReadData& theReadData)
{
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
{
(aPolygon, aPolygon2, aTriangulation, myLocation.Import());
}
+//=======================================================================
+// PolygonOnSurface
+//=======================================================================
void ShapePersistent_BRep::PolygonOnSurface::Read
(StdObjMgt_ReadData& theReadData)
{
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
{
return new BRep_PolygonOnSurface (aPolygon2D, aSurface, myLocation.Import());
}
+//=======================================================================
+// PolygonOnClosedSurface
+//=======================================================================
void ShapePersistent_BRep::PolygonOnClosedSurface::Read
(StdObjMgt_ReadData& theReadData)
{
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
{
(aPolygon2D, aPolygon2, aSurface, myLocation.Import());
}
+//=======================================================================
+// CurveOn2Surfaces
+//=======================================================================
void ShapePersistent_BRep::CurveOn2Surfaces::Read
(StdObjMgt_ReadData& theReadData)
{
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
{
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;
+}
#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;
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:
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;
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:
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:
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;
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;
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:
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:
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:
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:
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:
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:
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:
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:
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:
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;
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;
class pTFace : public pTBase
{
+ friend class ShapePersistent_BRep;
+
public:
inline void Read (StdObjMgt_ReadData& theReadData)
{
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;
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
// 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;
}
#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>
#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
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
//! 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>
{
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
{
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 "";
}
};
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
--- /dev/null
+
+#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;
+}
#ifndef _ShapePersistent_Geom2d_HeaderFile
#define _ShapePersistent_Geom2d_HeaderFile
+#include <StdObjMgt_TransientPersistentMap.hxx>
#include <ShapePersistent_Geom.hxx>
#include <Geom2d_CartesianPoint.hxx>
#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;
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
// 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>
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;
+}
#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>
#include <gp_Parab2d.hxx>
-class ShapePersistent_Geom2d_Curve : protected ShapePersistent_Geom2d
+class ShapePersistent_Geom2d_Curve : public ShapePersistent_Geom2d
{
typedef Curve::PersistentBase pBase;
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;
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;
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;
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;
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
// 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>
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;
+}
#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>
class gp_Dir;
-
class ShapePersistent_Geom_Curve : private ShapePersistent_Geom
{
typedef Curve::PersistentBase pBase;
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;
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;
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;
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;
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
// 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>
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;
+}
#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>
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;
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;
class pBSpline : public pBounded
{
+ friend class ShapePersistent_Geom_Surface;
+
public:
inline void Read (StdObjMgt_ReadData& theReadData)
{
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;
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;
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;
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
};
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;
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
// 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>
theReadData >> myPreviuos >> myItem >> myNext;
}
+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)
theReadData >> myFirst >> myLast >> mySize;
}
+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
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"; }
#ifndef _ShapePersistent_HSequence_HeaderFile
#define _ShapePersistent_HSequence_HeaderFile
+#include <Standard_NotImplemented.hxx>
+
#include <StdObjMgt_Persistent.hxx>
#include <StdObject_gp_Vectors.hxx>
//! 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; }
//! 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;
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
// 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())
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())
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
{
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)
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;
+}
#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>
{
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;
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;
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;
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;
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;
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
// 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
{
ConvexMask = 64
};
-
//=======================================================================
//function : Read
//purpose : Read persistent data from a file
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
{
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;
+}
#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>
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;
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;
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
--- /dev/null
+
+#ifndef _ShapePersistent_TriangleMode_HeaderFile
+#define _ShapePersistent_TriangleMode_HeaderFile
+
+#include <Standard_PrimitiveTypes.hxx>
+
+
+enum ShapePersistent_TriangleMode
+{
+ ShapePersistent_WithTriangle,
+ ShapePersistent_WithoutTriangle
+};
+
+#endif // _ShapePersistent_TriangleMode_HeaderFile
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;
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);
#include <StdLPersistent_Data.hxx>
#include <StdObjMgt_ReadData.hxx>
+#include <StdObjMgt_WriteData.hxx>
#include <TDF_Data.hxx>
#include <TDF_Attribute.hxx>
theReadData >> myVersion >> myLabels >> myAttributes;
}
+//=======================================================================
+//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
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;
//! 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;
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
#include <StdLPersistent_Document.hxx>
#include <StdLPersistent_Data.hxx>
#include <StdObjMgt_ReadData.hxx>
+#include <StdObjMgt_WriteData.hxx>
#include <TDocStd_Document.hxx>
#include <TDocStd_Owner.hxx>
theReadData >> myData;
}
+//=======================================================================
+//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
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
//! 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
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);
+}
#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>
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;
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
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);
+}
#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>
//! 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;
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;
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
#include <StdLPersistent_HString.hxx>
#include <StdObjMgt_ReadData.hxx>
+#include <StdObjMgt_WriteData.hxx>
#include <TDF_Label.hxx>
#include <TDF_Tool.hxx>
}
}
+//=======================================================================
+//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
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;
public:
//! Get referenced ASCII string.
Standard_EXPORT virtual Handle(TCollection_HAsciiString) AsciiString() const;
+
+ inline Standard_CString PName() const { return "PCollection_HAsciiString"; }
};
class Extended
public:
//! Get referenced extended string.
Standard_EXPORT virtual Handle(TCollection_HExtendedString) ExtString() const;
+
+ inline Standard_CString PName() const { return "PCollection_HExtendedString"; }
};
};
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(); }
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;
//! 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:
theReadData >> myDynamicData->First >> myNext >> myDynamicData->TreeID;
}
+//=======================================================================
+//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
//! 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();
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>
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>
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>
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
//! 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
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() {}
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
//! 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
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
#include <StdObjMgt_Persistent.hxx>
#include <StdObjMgt_ReadData.hxx>
+#include <StdObjMgt_WriteData.hxx>
//! Root class for a temporary persistent object corresponding to an attribute.
//! 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;
//! 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;
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()
+++ /dev/null
-// Copyright (c) 2015 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_MapOfInstantiators.hxx>
#include <StdObjMgt_Persistent.hxx>
+StdObjMgt_Persistent::StdObjMgt_Persistent()
+ : myTypeNum(0)
+ , myRefNum(0)
+{
+
+}
//=======================================================================
//function : ImportDocument
#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;
class StdObjMgt_Persistent : public Standard_Transient
{
public:
+ Standard_EXPORT StdObjMgt_Persistent();
+
//! Derived class instance create function.
typedef Handle(StdObjMgt_Persistent) (*Instantiator)();
//! 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).
//! (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
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(); }
private:
StdObjMgt_ReadData* myReadData;
+
+ StdObjMgt_ReadData::Object& operator = (const StdObjMgt_ReadData::Object&);
};
Standard_EXPORT StdObjMgt_ReadData& operator >>
#ifndef _StdObjMgt_SharedObject_HeaderFile
#define _StdObjMgt_SharedObject_HeaderFile
+#include <Standard_NoSuchObject.hxx>
#include <StdObjMgt_Persistent.hxx>
-
class StdObjMgt_SharedObject
{
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,
Standard_EXPORT virtual Handle(Transient) Import()
{ return myTransient; }
- protected:
+ public:
Handle(Transient) myTransient;
};
//! 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()
return Base::myTransient;
}
- protected:
+ public:
Handle(typename Base::PersistentBase) myPersistent;
};
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)
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();
+ }
};
};
--- /dev/null
+
+#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
--- /dev/null
+// 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;
+}
--- /dev/null
+// 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
#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
#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.
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
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
#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.
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
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)
{
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)
{
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)
{
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
inline StdObjMgt_ReadData& operator >>
- (StdObjMgt_ReadData::Object theReadData, gp_Lin2d& theLin)
+ (StdObjMgt_ReadData& theReadData, gp_Lin2d& theLin)
{
gp_Ax2d anAx;
theReadData >> anAx;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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
inline StdObjMgt_ReadData& operator >>
- (StdObjMgt_ReadData::Object theReadData, gp_Cone& theCone)
+ (StdObjMgt_ReadData& theReadData, gp_Cone& theCone)
{
gp_Ax3 anAx;
Standard_Real aRadius, aSemiAngle;
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;
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;
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;
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
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)
{
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)
{
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
#include <StdObjMgt_ReadData.hxx>
+#include <StdObjMgt_WriteData.hxx>
#include <gp_Pnt2d.hxx>
#include <gp_Vec2d.hxx>
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
#define _StdPersistent_HeaderFile
#include <Standard_Macro.hxx>
-
class StdObjMgt_MapOfInstantiators;
class StdPersistent
};
};
+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
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;
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;
theReadData >> myType >> myShapeType >> myArgs >> myStop >> myIndex;
}
+//=======================================================================
+//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
theReadData >> myContextLabel;
}
+//=======================================================================
+//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
theReadData >> myOrientation;
}
+//=======================================================================
+//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
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;
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
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
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
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;
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;
#include <StdPersistent_TopLoc.hxx>
#include <StdObjMgt_ReadData.hxx>
+#include <StdObjMgt_WriteData.hxx>
#include <StdObject_gp_Trsfs.hxx>
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
theReadData >> myDatum >> myPower >> myNext;
}
+//=======================================================================
+//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
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;
+}
#include <StdObjMgt_SharedObject.hxx>
#include <StdObjMgt_Persistent.hxx>
#include <StdObject_Location.hxx>
+#include <StdObjMgt_TransientPersistentMap.hxx>
#include <TopLoc_Datum3D.hxx>
#include <TopLoc_Location.hxx>
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;
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
#include <StdObjMgt_SharedObject.hxx>
#include <StdObjMgt_ReadData.hxx>
+#include <StdObjMgt_WriteData.hxx>
#include <TopoDS_TShape.hxx>
protected:
class pTShape : public Standard_Transient
{
+ friend class ShapePersistent_TopoDS;
+
+ DEFINE_STANDARD_RTTI_INLINE(pTShape, Standard_Transient)
+
public:
inline void Read (StdObjMgt_ReadData& theReadData)
{ theReadData >> myShapes >> myFlags; }
+ inline void Write (StdObjMgt_WriteData& theWriteData) const
+ { theWriteData << myShapes << myFlags; }
+ inline void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
+ { theChildren.Append(myShapes); }
+ inline Standard_CString PName() const
+ { return "PTopoDS_TShape"; }
protected:
Handle(StdObjMgt_Persistent) myShapes;
--- /dev/null
+StdStorage.cxx
+StdStorage.hxx
+StdStorage_Data.cxx
+StdStorage_Data.hxx
+StdStorage_HeaderData.cxx
+StdStorage_HeaderData.hxx
+StdStorage_Root.cxx
+StdStorage_Root.hxx
+StdStorage_RootData.cxx
+StdStorage_RootData.hxx
+StdStorage_HSequenceOfRoots.hxx
+StdStorage_SequenceOfRoots.hxx
+StdStorage_MapOfRoots.hxx
+StdStorage_TypeData.cxx
+StdStorage_TypeData.hxx
+StdStorage_MapOfTypes.hxx
+StdStorage_BacketOfPersistent.cxx
+StdStorage_BacketOfPersistent.hxx
\ No newline at end of file
--- /dev/null
+// 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 <NCollection_Handle.hxx>
+#include <NCollection_Array1.hxx>
+#include <PCDM.hxx>
+#include <PCDM_BaseDriverPointer.hxx>
+#include <PCDM_ReadWriter.hxx>
+#include <Standard_ErrorHandler.hxx>
+#include <Standard_NullObject.hxx>
+#include <StdObjMgt_Persistent.hxx>
+#include <StdObjMgt_ReadData.hxx>
+#include <StdObjMgt_WriteData.hxx>
+#include <StdStorage.hxx>
+#include <StdStorage_Data.hxx>
+#include <StdStorage_HeaderData.hxx>
+#include <StdStorage_TypeData.hxx>
+#include <StdStorage_RootData.hxx>
+#include <StdStorage_HSequenceOfRoots.hxx>
+#include <StdStorage_BacketOfPersistent.hxx>
+#include <Storage.hxx>
+#include <Storage_BaseDriver.hxx>
+#include <Storage_StreamTypeMismatchError.hxx>
+#include <Storage_StreamFormatError.hxx>
+#include <Storage_StreamWriteError.hxx>
+
+#include <locale.h>
+#include <stdio.h>
+
+//=======================================================================
+// StdStorage::Version
+//=======================================================================
+TCollection_AsciiString StdStorage::Version()
+{
+ TCollection_AsciiString v("1.3");
+ return v;
+}
+
+//=======================================================================
+// StdStorage::Read
+// Reads data from a file
+//=======================================================================
+Storage_Error StdStorage::Read(const TCollection_AsciiString& theFileName,
+ Handle(StdStorage_Data)& theData)
+{
+ // Create a driver appropriate for the given file
+ PCDM_BaseDriverPointer aDriverPtr;
+ if (PCDM::FileDriverType(theFileName, aDriverPtr) == PCDM_TOFD_Unknown)
+ return Storage_VSWrongFileDriver;
+
+ NCollection_Handle<Storage_BaseDriver> aDriver(aDriverPtr);
+
+ // Try to open the file
+ try
+ {
+ OCC_CATCH_SIGNALS
+ PCDM_ReadWriter::Open(*aDriver, theFileName, Storage_VSRead);
+ }
+ catch (Standard_Failure)
+ {
+ return Storage_VSOpenError;
+ }
+
+ return Read(*aDriver, theData);
+}
+
+//=======================================================================
+// StdStorage::Read
+// Reads data from a pre-opened for reading driver
+//=======================================================================
+Storage_Error StdStorage::Read(Storage_BaseDriver& theDriver,
+ Handle(StdStorage_Data)& theData)
+{
+ if (theData.IsNull())
+ theData = new StdStorage_Data;
+ else
+ theData->Clear();
+
+ Handle(StdStorage_HeaderData) aHeaderData = theData->HeaderData();
+ Handle(StdStorage_TypeData) aTypeData = theData->TypeData();
+ Handle(StdStorage_RootData) aRootData = theData->RootData();
+
+ // Read header section
+ if (!aHeaderData->Read(theDriver))
+ return aHeaderData->ErrorStatus();
+
+ // Read types section
+ if (!aTypeData->Read(theDriver))
+ return aTypeData->ErrorStatus();
+
+ // Select instantiators for the used types
+ NCollection_Array1<StdObjMgt_Persistent::Instantiator>
+ anInstantiators(1, aTypeData->NumberOfTypes());
+ for (Standard_Integer i = 1; i <= aTypeData->NumberOfTypes(); i++)
+ {
+ StdObjMgt_Persistent::Instantiator anInstantiator =
+ aTypeData->Instantiator(i);
+ if (anInstantiator)
+ anInstantiators(i) = anInstantiator;
+ else
+ return Storage_VSUnknownType;
+ }
+
+ // Read root section
+ if (!aRootData->Read(theDriver))
+ return aRootData->ErrorStatus();
+
+ Storage_Error anError;
+
+ // Read and parse reference section
+ StdObjMgt_ReadData aReadData(theDriver, aHeaderData->NumberOfObjects());
+
+ anError = theDriver.BeginReadRefSection();
+ if (anError != Storage_VSOk)
+ return anError;
+
+ Standard_Integer aNbRefs = theDriver.RefSectionSize();
+ for (Standard_Integer i = 1; i <= aNbRefs; i++)
+ {
+ Standard_Integer aRef = 0, aType = 0;
+ try
+ {
+ OCC_CATCH_SIGNALS
+ theDriver.ReadReferenceType(aRef, aType);
+ anError = Storage_VSOk;
+ }
+ catch (Storage_StreamTypeMismatchError)
+ {
+ anError = Storage_VSTypeMismatch;
+ }
+
+ if (anError != Storage_VSOk)
+ return anError;
+
+ aReadData.CreatePersistentObject(aRef, anInstantiators(aType));
+ }
+
+ anError = theDriver.EndReadRefSection();
+ if (anError != Storage_VSOk)
+ return anError;
+
+ // Read and parse data section
+ anError = theDriver.BeginReadDataSection();
+ if (anError != Storage_VSOk)
+ return anError;
+
+ for (Standard_Integer i = 1; i <= aHeaderData->NumberOfObjects(); i++)
+ {
+ try
+ {
+ OCC_CATCH_SIGNALS
+ aReadData.ReadPersistentObject(i);
+ anError = Storage_VSOk;
+ }
+ catch (Storage_StreamTypeMismatchError) { anError = Storage_VSTypeMismatch; }
+ catch (Storage_StreamFormatError) { anError = Storage_VSFormatError; }
+ catch (Storage_StreamReadError) { anError = Storage_VSFormatError; }
+
+ if (anError != Storage_VSOk)
+ return anError;
+ }
+
+ anError = theDriver.EndReadDataSection();
+ if (anError != Storage_VSOk)
+ return anError;
+
+ 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();
+ aRoot->SetObject(aReadData.PersistentObject(aRoot->Reference()));
+ }
+ }
+
+ return Storage_VSOk;
+}
+
+//=======================================================================
+// StdStorage::currentDate
+//=======================================================================
+static TCollection_AsciiString currentDate()
+{
+#define SLENGTH 80
+
+ char nowstr[SLENGTH];
+ time_t nowbin;
+ struct tm *nowstruct;
+ if (time(&nowbin) != (time_t)-1)
+ {
+ nowstruct = localtime(&nowbin);
+ strftime(nowstr, SLENGTH, "%m/%d/%Y", nowstruct);
+ }
+ TCollection_AsciiString t(nowstr);
+ return t;
+
+#undef SLENGTH
+}
+
+//=======================================================================
+// StdStorage::Write
+//=======================================================================
+Storage_Error StdStorage::Write(Storage_BaseDriver& theDriver,
+ const Handle(StdStorage_Data)& theData)
+{
+ Standard_NullObject_Raise_if(theData.IsNull(), "Null storage data");
+
+ Handle(StdStorage_HeaderData) aHeaderData = theData->HeaderData();
+ Handle(StdStorage_TypeData) aTypeData = theData->TypeData();
+ Handle(StdStorage_RootData) aRootData = theData->RootData();
+
+ aHeaderData->SetCreationDate(currentDate());
+
+ Handle(StdStorage_HSequenceOfRoots) aRoots = aRootData->Roots();
+
+ StdStorage_BucketOfPersistent aPObjs;
+
+ if (!aRoots.IsNull())
+ {
+ StdObjMgt_Persistent::SequenceOfPersistent aPQueue;
+ for (StdStorage_HSequenceOfRoots::Iterator anIt(*aRoots); anIt.More(); anIt.Next())
+ {
+ Handle(StdStorage_Root) aRoot = anIt.ChangeValue();
+ Handle(StdObjMgt_Persistent) aPObj = aRoot->Object();
+ if (!aPObj.IsNull()) {
+ aPQueue.Append(aPObj);
+ }
+ }
+ while (!aPQueue.IsEmpty())
+ {
+ StdObjMgt_Persistent::SequenceOfPersistent aPQueue1;
+ for (StdObjMgt_Persistent::SequenceOfPersistent::Iterator anIt(aPQueue); anIt.More(); anIt.Next())
+ {
+ Handle(StdObjMgt_Persistent)& aPObj = anIt.ChangeValue();
+ if (!aPObj.IsNull())
+ {
+ if (aPObj->TypeNum() == 0 && aPObj->RefNum() == 0)
+ {
+ aPObj->TypeNum(aTypeData->AddType(aPObj));
+ Standard_Integer anPObjId = aPObjs.Length() + 1;
+ aPObj->RefNum(anPObjId);
+ aPObjs.Append(aPObj);
+ aPObj->PChildren(aPQueue1);
+ }
+ }
+ }
+ aPQueue.Assign(aPQueue1);
+ }
+ }
+
+ aHeaderData->SetStorageVersion(StdStorage::Version());
+ aHeaderData->SetNumberOfObjects(aPObjs.Length());
+
+ try {
+ // Write header section
+ if (!aHeaderData->Write(theDriver))
+ return aHeaderData->ErrorStatus();
+
+ // Write types section
+ if (!aTypeData->Write(theDriver))
+ return aTypeData->ErrorStatus();
+
+ // Write root section
+ if (!aRootData->Write(theDriver))
+ return aRootData->ErrorStatus();
+
+ Storage_Error anError;
+
+ // Write reference section
+ anError = theDriver.BeginWriteRefSection();
+ if (anError != Storage_VSOk)
+ return anError;
+
+ theDriver.SetRefSectionSize(aPObjs.Length());
+ for (StdStorage_BucketIterator anIt(&aPObjs); anIt.More(); anIt.Next())
+ {
+ Handle(StdObjMgt_Persistent) aPObj = anIt.Value();
+ if (!aPObj.IsNull())
+ theDriver.WriteReferenceType(aPObj->RefNum(), aPObj->TypeNum());
+ }
+
+ anError = theDriver.EndWriteRefSection();
+ if (anError != Storage_VSOk)
+ return anError;
+
+ // Write data section
+ anError = theDriver.BeginWriteDataSection();
+ if (anError != Storage_VSOk)
+ return anError;
+
+ StdObjMgt_WriteData aWriteData(theDriver);
+ for (StdStorage_BucketIterator anIt(&aPObjs); anIt.More(); anIt.Next())
+ {
+ Handle(StdObjMgt_Persistent) aPObj = anIt.Value();
+ if (!aPObj.IsNull())
+ aWriteData.WritePersistentObject(aPObj);
+ }
+
+ anError = theDriver.EndWriteDataSection();
+ if (anError != Storage_VSOk)
+ return anError;
+ }
+ catch (Storage_StreamWriteError) {
+ return Storage_VSWriteError;
+ }
+
+ return Storage_VSOk;
+}
--- /dev/null
+// 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 _StdStorage_HeaderFile
+#define _StdStorage_HeaderFile
+
+#include <Standard_Macro.hxx>
+#include <Storage_Error.hxx>
+class StdStorage_Data;
+class Storage_BaseDriver;
+class TCollection_AsciiString;
+
+//! StdStorage package is used to write and read persistent objects.
+//! These objects are read and written by a retrieval or storage
+//! algorithm (compatible with legacy Storage_Schema) in a container
+//! (disk, memory, network ...). Drivers (FSD_File objects) assign a physical
+//! container for data to be stored or retrieved.
+//! The standard procedure for an application in reading a container is
+//! to call one of the Read functions providing either a file path or a driver
+//! opened for reading. Thes function update the instance of the StdStorage_Data
+//! class which contains the data being read.
+//! The standard procedure for an application in writing a container is the following:
+//! - open the driver in writing mode,
+//! - create an instance of the StdStorage_Data class, then
+//! add the persistent data to write with the function AddRoot,
+//! - call the function Write from the storage, setting the driver and the
+//! Storage_Data instance as parameters,
+//! - close the driver.
+class StdStorage
+{
+
+public:
+
+ //! Returns the version of Storage's read/write routines
+ Standard_EXPORT static TCollection_AsciiString Version();
+
+ //! Returns the data read from a file located at theFileName.
+ //! The storage format is compartible with legacy persistent one.
+ //! These data are aggregated in a StdStorage_Data object which may be
+ //! browsed in order to extract the root objects from the container.
+ //! Note: - theData object will be created if it is null or cleared otherwise.
+ Standard_EXPORT static Storage_Error Read(const TCollection_AsciiString& theFileName,
+ Handle(StdStorage_Data)& theData);
+
+ //! Returns the data read from the container defined by theDriver.
+ //! The storage format is compartible with legacy persistent one.
+ //! These data are aggregated in a StdStorage_Data object which may be
+ //! browsed in order to extract the root objects from the container.
+ //! Note: - theData object will be created if it is null or cleared otherwise.
+ Standard_EXPORT static Storage_Error Read(Storage_BaseDriver& theDriver,
+ Handle(StdStorage_Data)& theData);
+
+ //! Writes the data aggregated in theData object into the container defined by
+ //! theDriver. The storage format is compartible with legacy persistent one.
+ //! Note: - theData may aggregate several root objects to be stored together.
+ //! - createion date specified in the srorage header will be overwritten.
+ Standard_EXPORT static Storage_Error Write(Storage_BaseDriver& theDriver,
+ const Handle(StdStorage_Data)& theData);
+
+};
+
+#endif // _StdStorage_HeaderFile
--- /dev/null
+// 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 <StdStorage_BacketOfPersistent.hxx>
+#include <StdObjMgt_Persistent.hxx>
+
+StdStorage_Bucket::~StdStorage_Bucket()
+{
+ Standard::Free(mySpace);
+ mySpace = 0L;
+ mySpaceSize = 0;
+ Clear();
+}
+
+//=======================================================================
+//function : Clear
+//purpose :
+//=======================================================================
+void StdStorage_Bucket::Clear()
+{
+ myCurrentSpace = -1;
+}
+
+//=======================================================================
+//function : Append
+//purpose :
+//=======================================================================
+void StdStorage_Bucket::Append(StdObjMgt_Persistent *sp)
+{
+ ++myCurrentSpace;
+ mySpace[myCurrentSpace] = sp;
+}
+
+//=======================================================================
+//function : Value
+//purpose :
+//=======================================================================
+StdObjMgt_Persistent* StdStorage_Bucket::Value(const Standard_Integer theIndex) const
+{
+ return mySpace[theIndex];
+}
+
+//=======================================================================
+//function : Storage_BucketOfPersistent
+//purpose :
+//=======================================================================
+StdStorage_BucketOfPersistent::StdStorage_BucketOfPersistent
+(const Standard_Integer theBucketSize, const Standard_Integer theBucketNumber)
+: myNumberOfBucket(1), myNumberOfBucketAllocated(theBucketNumber)
+, myBucketSize(theBucketSize)
+{
+ myBuckets = (StdStorage_Bucket**)Standard::Allocate
+ (sizeof(StdStorage_Bucket*) * theBucketNumber);
+ myBuckets[0] = new StdStorage_Bucket(myBucketSize);
+ myCurrentBucket = myBuckets[0];
+ myLength = 0;
+ myCurrentBucketNumber = 0;
+}
+
+//=======================================================================
+//function : Clear
+//purpose :
+//=======================================================================
+void StdStorage_BucketOfPersistent::Clear()
+{
+ if (myBuckets) {
+ Standard_Integer i;
+
+ for (i = 1; i < myNumberOfBucket; i++) delete myBuckets[i];
+ myNumberOfBucket = 1;
+ myCurrentBucket = myBuckets[0];
+ myCurrentBucket->Clear();
+ myCurrentBucketNumber = 0;
+ myLength = 0;
+ }
+}
+
+StdStorage_BucketOfPersistent::~StdStorage_BucketOfPersistent()
+{
+ Clear();
+ delete myBuckets[0];
+ Standard::Free(myBuckets);
+ myBuckets = 0L;
+}
+
+//=======================================================================
+//function : Value
+//purpose :
+//=======================================================================
+StdObjMgt_Persistent* StdStorage_BucketOfPersistent::Value
+ (const Standard_Integer theIndex)
+{
+ Standard_Integer theInd, theCurrentBucketNumber, tecurrentind = theIndex - 1;
+ theCurrentBucketNumber = tecurrentind / myBucketSize;
+ theInd = tecurrentind - (myBucketSize * theCurrentBucketNumber);
+
+ return myBuckets[theCurrentBucketNumber]->mySpace[theInd];
+}
+
+//=======================================================================
+//function : Append
+//purpose :
+//=======================================================================
+void StdStorage_BucketOfPersistent::Append(const Handle(StdObjMgt_Persistent)& sp)
+{
+ myCurrentBucket->myCurrentSpace++;
+
+ if (myCurrentBucket->myCurrentSpace != myBucketSize) {
+ myLength++;
+ myCurrentBucket->mySpace[myCurrentBucket->myCurrentSpace] = sp.operator->();
+ return;
+ }
+
+ myCurrentBucket->myCurrentSpace--;
+ myNumberOfBucket++;
+ myCurrentBucketNumber++;
+
+ if (myNumberOfBucket > myNumberOfBucketAllocated) {
+ Standard_Size e = sizeof(StdStorage_Bucket*) * myNumberOfBucketAllocated;
+ myBuckets = (StdStorage_Bucket**)Standard::Reallocate(myBuckets, e * 2);
+ myNumberOfBucketAllocated *= 2;
+ }
+
+ myBuckets[myCurrentBucketNumber] = new StdStorage_Bucket(myBucketSize);
+ myCurrentBucket = myBuckets[myCurrentBucketNumber];
+ myCurrentBucket->myCurrentSpace++;
+ myLength++;
+ myCurrentBucket->mySpace[myCurrentBucket->myCurrentSpace] = sp.operator->();
+}
+
+//=======================================================================
+//function : Storage_BucketIterator
+//purpose :
+//=======================================================================
+StdStorage_BucketIterator::StdStorage_BucketIterator
+ (StdStorage_BucketOfPersistent* aBucketManager)
+{
+ if (aBucketManager) {
+ myBucket = aBucketManager;
+ myCurrentBucket = myBucket->myBuckets[0];
+ myBucketNumber = aBucketManager->myNumberOfBucket;
+ myCurrentBucketIndex = 0;
+ myCurrentIndex = 0;
+ myMoreObject = Standard_True;
+ }
+ else myMoreObject = Standard_False;
+}
+
+//=======================================================================
+//function : Reset
+//purpose :
+//=======================================================================
+void StdStorage_BucketIterator::Reset()
+{
+ if (myBucket) {
+ myCurrentBucket = myBucket->myBuckets[0];
+ myBucketNumber = myBucket->myNumberOfBucket;
+ myCurrentIndex = 0;
+ myCurrentBucketIndex = 0;
+ myMoreObject = Standard_True;
+ }
+ else myMoreObject = Standard_False;
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+void StdStorage_BucketIterator::Init(StdStorage_BucketOfPersistent* aBucketManager)
+{
+ if (aBucketManager) {
+ myBucket = aBucketManager;
+ myCurrentBucket = myBucket->myBuckets[0];
+ myBucketNumber = aBucketManager->myNumberOfBucket;
+ myCurrentIndex = 0;
+ myCurrentBucketIndex = 0;
+ myMoreObject = Standard_True;
+ }
+ else myMoreObject = Standard_False;
+}
+
+//=======================================================================
+//function : Next
+//purpose :
+//=======================================================================
+void StdStorage_BucketIterator::Next()
+{
+ if (!myMoreObject) return;
+
+ if (myCurrentIndex < myCurrentBucket->myCurrentSpace) {
+ myCurrentIndex++;
+ }
+ else {
+ myCurrentIndex = 0;
+ myCurrentBucketIndex++;
+ if (myCurrentBucketIndex < myBucketNumber) {
+ myCurrentBucket = myBucket->myBuckets[myCurrentBucketIndex];
+ }
+ else {
+ myMoreObject = Standard_False;
+ }
+ }
+}
--- /dev/null
+// 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 _StdStorage_BucketOfPersistent_HeaderFile
+#define _StdStorage_BucketOfPersistent_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_Handle.hxx>
+#include <Standard_Integer.hxx>
+
+class StdStorage_BucketOfPersistent;
+class StdStorage_BucketIterator;
+class StdObjMgt_Persistent;
+
+class StdStorage_Bucket
+{
+ friend class StdStorage_BucketIterator;
+ friend class StdStorage_BucketOfPersistent;
+
+ StdObjMgt_Persistent** mySpace;
+ Standard_Integer mySpaceSize;
+ Standard_Integer myCurrentSpace;
+
+ void Append(StdObjMgt_Persistent *);
+
+ StdObjMgt_Persistent* Value(const Standard_Integer theIndex) const;
+
+public:
+
+ StdStorage_Bucket() : mySpace(0L), mySpaceSize(200000), myCurrentSpace(-1)
+ {
+ mySpace = (StdObjMgt_Persistent**)Standard::Allocate(sizeof(StdObjMgt_Persistent*) * mySpaceSize);
+ }
+
+ StdStorage_Bucket(const Standard_Integer theSpaceSize) : mySpace(0L), mySpaceSize(theSpaceSize), myCurrentSpace(-1)
+ {
+ mySpace = (StdObjMgt_Persistent**)Standard::Allocate(sizeof(StdObjMgt_Persistent*) * mySpaceSize);
+ }
+
+ void Clear();
+
+ ~StdStorage_Bucket();
+};
+
+class StdStorage_BucketOfPersistent
+{
+ friend class StdStorage_BucketIterator;
+ StdStorage_Bucket** myBuckets;
+ Standard_Integer myNumberOfBucket;
+ Standard_Integer myNumberOfBucketAllocated;
+ StdStorage_Bucket* myCurrentBucket;
+ Standard_Integer myCurrentBucketNumber;
+ Standard_Integer myLength;
+ Standard_Integer myBucketSize;
+
+public:
+ StdStorage_BucketOfPersistent(const Standard_Integer theBucketSize = 300000, const Standard_Integer theBucketNumber = 100);
+
+ Standard_Integer Length() const
+ {
+ return myLength;
+ }
+
+ void Append(const Handle(StdObjMgt_Persistent)& sp);
+
+ StdObjMgt_Persistent* Value(const Standard_Integer theIndex);
+
+ void Clear();
+
+ ~StdStorage_BucketOfPersistent();
+};
+
+class StdStorage_BucketIterator
+{
+ StdStorage_BucketOfPersistent *myBucket;
+ StdStorage_Bucket *myCurrentBucket;
+ Standard_Integer myCurrentBucketIndex;
+ Standard_Integer myCurrentIndex;
+ Standard_Integer myBucketNumber;
+ Standard_Boolean myMoreObject;
+
+public:
+ StdStorage_BucketIterator(StdStorage_BucketOfPersistent*);
+
+ void Init(StdStorage_BucketOfPersistent*);
+ void Reset();
+
+ StdObjMgt_Persistent* Value() const
+ {
+ if (myCurrentBucket) {
+ return myCurrentBucket->mySpace[myCurrentIndex];
+ }
+ else return 0L;
+ }
+
+ Standard_Boolean More() const
+ {
+ return myMoreObject;
+ }
+
+ void Next();
+};
+
+#endif // _StdStorage_BucketOfPersistent_HeaderFile
--- /dev/null
+// 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 <StdStorage_Data.hxx>
+#include <StdStorage_HeaderData.hxx>
+#include <StdStorage_TypeData.hxx>
+#include <StdStorage_RootData.hxx>
+
+StdStorage_Data::StdStorage_Data()
+ : myHeaderData(new StdStorage_HeaderData)
+ , myTypeData(new StdStorage_TypeData)
+ , myRootData(new StdStorage_RootData)
+{
+
+}
+
+void StdStorage_Data::Clear()
+{
+ myTypeData->Clear();
+ myRootData->Clear();
+}
--- /dev/null
+// 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 _StdStorage_Data_HeaderFile
+#define _StdStorage_Data_HeaderFile
+
+#include <MMgt_TShared.hxx>
+#include <Standard_Macro.hxx>
+class StdStorage_HeaderData;
+class StdStorage_TypeData;
+class StdStorage_RootData;
+
+//! A picture memorizing the stored in a
+//! container (for example, in a file).
+//! A StdStorage_Data object represents either:
+//! - persistent data to be written into a container,
+//! or
+//! - persistent data which are read from a container.
+//! A StdStorage_Data object is used in both the
+//! storage and retrieval operations:
+//! - Storage mechanism: create an empty
+//! StdStorage_Data object, then add successively
+//! persistent objects (roots) to be stored using
+//! the StdStorage_RootData's function AddRoot. When the set of
+//! data is complete, write it to a container using the
+//! function Write in your StdStorage algorithm.
+//! - Retrieval mechanism: a StdStorage_Data
+//! object is returned by the Read function from
+//! your StdStorage algorithm. Use the StdStorage_RootData's
+//! functions NumberOfRoots and Roots to find the roots which
+//! were stored in the read container.
+//! The roots of a StdStorage_Data object may share
+//! references on objects. The shared internal
+//! references of a StdStorage_Data object are
+//! maintained by the storage/retrieval mechanism.
+//! Note: References shared by objects which are
+//! contained in two distinct StdStorage_Data objects
+//! are not maintained by the storage/retrieval
+//! mechanism: external references are not
+//! supported by Storage_Schema algorithm
+class StdStorage_Data
+ : public MMgt_TShared
+{
+
+public:
+
+ //! Creates an empty set of data.
+ //! You explicitly create a StdStorage_Data object
+ //! when preparing the set of objects to be stored
+ //! together in a container (for example, in a file).
+ //! Then use the function StdStorage_RootData's AddRoot
+ //! to add persistent objects to the set of data.
+ //! A StdStorage_Data object is also returned by the
+ //! Read function of a StdStorage algorithm. Use the
+ //! StdStorage_RootData's functions NumberOfRoots and
+ //! Roots to find the roots which were stored in the
+ //! read container.
+ Standard_EXPORT StdStorage_Data();
+
+ //! Makes the container empty
+ Standard_EXPORT void Clear();
+
+ //! Returns the header data section
+ Handle(StdStorage_HeaderData) HeaderData() { return myHeaderData; }
+
+ //! Returns the type data section
+ Handle(StdStorage_TypeData) TypeData() { return myTypeData; }
+
+ //! Returns the root data section
+ Handle(StdStorage_RootData) RootData() { return myRootData; }
+
+private:
+
+ Handle(StdStorage_HeaderData) myHeaderData;
+ Handle(StdStorage_TypeData) myTypeData;
+ Handle(StdStorage_RootData) myRootData;
+
+};
+
+#endif // _StdStorage_Data_HeaderFile
--- /dev/null
+
+#ifndef StdStorage_HSequenceOfRoots_HeaderFile
+#define StdStorage_HSequenceOfRoots_HeaderFile
+
+#include <StdStorage_Root.hxx>
+#include <StdStorage_SequenceOfRoots.hxx>
+#include <NCollection_DefineHSequence.hxx>
+
+DEFINE_HSEQUENCE(StdStorage_HSequenceOfRoots, StdStorage_SequenceOfRoots)
+
+#endif // StdStorage_HSequenceOfRoots_HeaderFile
--- /dev/null
+// 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 <Standard_ErrorHandler.hxx>
+#include <StdStorage_HeaderData.hxx>
+#include <Storage_BaseDriver.hxx>
+#include <Storage_StreamTypeMismatchError.hxx>
+#include <Storage_StreamExtCharParityError.hxx>
+#include <TCollection_AsciiString.hxx>
+#include <TCollection_ExtendedString.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StdStorage_HeaderData, MMgt_TShared)
+
+StdStorage_HeaderData::StdStorage_HeaderData()
+ : myNBObj(0), myErrorStatus(Storage_VSOk)
+{
+}
+
+Standard_Boolean StdStorage_HeaderData::Read(Storage_BaseDriver& theDriver)
+{
+ // Check driver open mode
+ if (theDriver.OpenMode() != Storage_VSRead
+ && theDriver.OpenMode() != Storage_VSReadWrite)
+ {
+ myErrorStatus = Storage_VSModeError;
+ myErrorStatusExt = "OpenMode";
+ return Standard_False;
+ }
+
+ // Read info section
+ myErrorStatus = theDriver.BeginReadInfoSection();
+ if (myErrorStatus != Storage_VSOk)
+ {
+ myErrorStatusExt = "BeginReadInfoSection";
+ return Standard_False;
+ }
+
+ try
+ {
+ OCC_CATCH_SIGNALS
+ theDriver.ReadInfo(myNBObj,
+ myStorageVersion,
+ myDate,
+ mySchemaName,
+ mySchemaVersion,
+ myApplicationName,
+ myApplicationVersion,
+ myDataType,
+ myUserInfo);
+ }
+ catch (Storage_StreamTypeMismatchError)
+ {
+ myErrorStatus = Storage_VSTypeMismatch;
+ myErrorStatusExt = "ReadInfo";
+ return Standard_False;
+ }
+ catch (Storage_StreamExtCharParityError)
+ {
+ myErrorStatus = Storage_VSExtCharParityError;
+ myErrorStatusExt = "ReadInfo";
+ return Standard_False;
+ }
+
+ myErrorStatus = theDriver.EndReadInfoSection();
+ if (myErrorStatus != Storage_VSOk)
+ {
+ myErrorStatusExt = "EndReadInfoSection";
+ return Standard_False;
+ }
+
+ // Read comment section
+ myErrorStatus = theDriver.BeginReadCommentSection();
+ if (myErrorStatus != Storage_VSOk)
+ {
+ myErrorStatusExt = "BeginReadCommentSection";
+ return Standard_False;
+ }
+
+ try
+ {
+ OCC_CATCH_SIGNALS
+ theDriver.ReadComment(myComments);
+ }
+ catch (Storage_StreamTypeMismatchError)
+ {
+ myErrorStatus = Storage_VSTypeMismatch;
+ myErrorStatusExt = "ReadComment";
+ return Standard_False;
+ }
+ catch (Storage_StreamExtCharParityError)
+ {
+ myErrorStatus = Storage_VSExtCharParityError;
+ myErrorStatusExt = "ReadComment";
+ return Standard_False;
+ }
+
+ myErrorStatus = theDriver.EndReadCommentSection();
+ if (myErrorStatus != Storage_VSOk)
+ {
+ myErrorStatusExt = "EndReadCommentSection";
+ return Standard_False;
+ }
+
+ return Standard_True;
+}
+
+Standard_Boolean StdStorage_HeaderData::Write(Storage_BaseDriver& theDriver)
+{
+ // Check driver open mode
+ if (theDriver.OpenMode() != Storage_VSWrite
+ && theDriver.OpenMode() != Storage_VSReadWrite)
+ {
+ myErrorStatus = Storage_VSModeError;
+ myErrorStatusExt = "OpenMode";
+ return Standard_False;
+ }
+
+ // Write info section
+ myErrorStatus = theDriver.BeginWriteInfoSection();
+ if (myErrorStatus != Storage_VSOk)
+ {
+ myErrorStatusExt = "BeginWriteInfoSection";
+ return Standard_False;
+ }
+
+ try
+ {
+ OCC_CATCH_SIGNALS
+ theDriver.WriteInfo(myNBObj,
+ myStorageVersion,
+ myDate,
+ mySchemaName,
+ mySchemaVersion,
+ myApplicationName,
+ myApplicationVersion,
+ myDataType,
+ myUserInfo);
+ }
+ catch (Storage_StreamTypeMismatchError)
+ {
+ myErrorStatus = Storage_VSTypeMismatch;
+ myErrorStatusExt = "WriteInfo";
+ return Standard_False;
+ }
+ catch (Storage_StreamExtCharParityError)
+ {
+ myErrorStatus = Storage_VSExtCharParityError;
+ myErrorStatusExt = "WriteInfo";
+ return Standard_False;
+ }
+
+ myErrorStatus = theDriver.EndWriteInfoSection();
+ if (myErrorStatus != Storage_VSOk)
+ {
+ myErrorStatusExt = "EndWriteInfoSection";
+ return Standard_False;
+ }
+
+ // Write comment section
+ myErrorStatus = theDriver.BeginWriteCommentSection();
+ if (myErrorStatus != Storage_VSOk)
+ {
+ myErrorStatusExt = "BeginWriteCommentSection";
+ return Standard_False;
+ }
+
+ try
+ {
+ OCC_CATCH_SIGNALS
+ theDriver.WriteComment(myComments);
+ }
+ catch (Storage_StreamTypeMismatchError)
+ {
+ myErrorStatus = Storage_VSTypeMismatch;
+ myErrorStatusExt = "WriteComment";
+ return Standard_False;
+ }
+ catch (Storage_StreamExtCharParityError)
+ {
+ myErrorStatus = Storage_VSExtCharParityError;
+ myErrorStatusExt = "WriteComment";
+ return Standard_False;
+ }
+
+ myErrorStatus = theDriver.EndWriteCommentSection();
+ if (myErrorStatus != Storage_VSOk)
+ {
+ myErrorStatusExt = "EndWriteCommentSection";
+ return Standard_False;
+ }
+
+ return Standard_True;
+}
+
+TCollection_AsciiString StdStorage_HeaderData::CreationDate() const
+{
+ return myDate;
+}
+
+void StdStorage_HeaderData::SetSchemaVersion(const TCollection_AsciiString& aVersion)
+{
+ mySchemaVersion = aVersion;
+}
+
+TCollection_AsciiString StdStorage_HeaderData::SchemaVersion() const
+{
+ return mySchemaVersion;
+}
+
+void StdStorage_HeaderData::SetSchemaName(const TCollection_AsciiString& aSchemaName)
+{
+ mySchemaName = aSchemaName;
+}
+
+void StdStorage_HeaderData::SetApplicationVersion(const TCollection_AsciiString& aVersion)
+{
+ myApplicationVersion = aVersion;
+}
+
+TCollection_AsciiString StdStorage_HeaderData::ApplicationVersion() const
+{
+ return myApplicationVersion;
+}
+
+void StdStorage_HeaderData::SetApplicationName(const TCollection_ExtendedString& aName)
+{
+ myApplicationName = aName;
+}
+
+TCollection_ExtendedString StdStorage_HeaderData::ApplicationName() const
+{
+ return myApplicationName;
+}
+
+void StdStorage_HeaderData::SetDataType(const TCollection_ExtendedString& aName)
+{
+ myDataType = aName;
+}
+
+TCollection_ExtendedString StdStorage_HeaderData::DataType() const
+{
+ return myDataType;
+}
+
+void StdStorage_HeaderData::AddToUserInfo(const TCollection_AsciiString& theUserInfo)
+{
+ myUserInfo.Append(theUserInfo);
+}
+
+const TColStd_SequenceOfAsciiString& StdStorage_HeaderData::UserInfo() const
+{
+ return myUserInfo;
+}
+
+void StdStorage_HeaderData::AddToComments(const TCollection_ExtendedString& aComments)
+{
+ myComments.Append(aComments);
+}
+
+const TColStd_SequenceOfExtendedString& StdStorage_HeaderData::Comments() const
+{
+ return myComments;
+}
+
+Standard_Integer StdStorage_HeaderData::NumberOfObjects() const
+{
+ return myNBObj;
+}
+
+void StdStorage_HeaderData::SetNumberOfObjects(const Standard_Integer anObjectNumber)
+{
+ myNBObj = anObjectNumber;
+}
+
+void StdStorage_HeaderData::SetStorageVersion(const TCollection_AsciiString& v)
+{
+ myStorageVersion = v;
+}
+
+void StdStorage_HeaderData::SetCreationDate(const TCollection_AsciiString& d)
+{
+ myDate = d;
+}
+
+TCollection_AsciiString StdStorage_HeaderData::StorageVersion() const
+{
+ return myStorageVersion;
+}
+
+Storage_Error StdStorage_HeaderData::ErrorStatus() const
+{
+ return myErrorStatus;
+}
+
+void StdStorage_HeaderData::SetErrorStatus(const Storage_Error anError)
+{
+ myErrorStatus = anError;
+}
+
+TCollection_AsciiString StdStorage_HeaderData::ErrorStatusExtension() const
+{
+ return myErrorStatusExt;
+}
+
+void StdStorage_HeaderData::SetErrorStatusExtension(const TCollection_AsciiString& anErrorExt)
+{
+ myErrorStatusExt = anErrorExt;
+}
+
+void StdStorage_HeaderData::ClearErrorStatus()
+{
+ myErrorStatus = Storage_VSOk;
+ myErrorStatusExt.Clear();
+}
--- /dev/null
+// 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 _StdStorage_HeaderData_HeaderFile
+#define _StdStorage_HeaderData_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+
+#include <Standard_Integer.hxx>
+#include <TCollection_AsciiString.hxx>
+#include <TCollection_ExtendedString.hxx>
+#include <TColStd_SequenceOfAsciiString.hxx>
+#include <TColStd_SequenceOfExtendedString.hxx>
+#include <Storage_Error.hxx>
+#include <MMgt_TShared.hxx>
+class Storage_BaseDriver;
+class TCollection_AsciiString;
+class TCollection_ExtendedString;
+
+class StdStorage_HeaderData;
+DEFINE_STANDARD_HANDLE(StdStorage_HeaderData, MMgt_TShared)
+
+//! Storage header data section that contains some
+//! auxiliary information (application name, schema version,
+//! creation date, comments and so on...)
+class StdStorage_HeaderData
+ : public MMgt_TShared
+{
+ friend class StdStorage_Data;
+
+public:
+
+ DEFINE_STANDARD_RTTIEXT(StdStorage_HeaderData, MMgt_TShared)
+
+ //! Reads the header data section from the container defined by theDriver.
+ //! Returns Standard_True in case of success. Otherwise, one need to get
+ //! an error code and description using ErrorStatus and ErrorStatusExtension
+ //! functions correspondingly.
+ Standard_EXPORT Standard_Boolean Read(Storage_BaseDriver& theDriver);
+
+ //! Writes the header data section to the container defined by theDriver.
+ //! Returns Standard_True in case of success. Otherwise, one need to get
+ //! an error code and description using ErrorStatus and ErrorStatusExtension
+ //! functions correspondingly.
+ Standard_EXPORT Standard_Boolean Write(Storage_BaseDriver& theDriver);
+
+ //! Return the creation date
+ Standard_EXPORT TCollection_AsciiString CreationDate() const;
+
+ //! Return the Storage package version
+ Standard_EXPORT TCollection_AsciiString StorageVersion() const;
+
+ //! Get the version of the schema
+ Standard_EXPORT TCollection_AsciiString SchemaVersion() const;
+
+ //! Set the version of the application
+ Standard_EXPORT void SetApplicationVersion(const TCollection_AsciiString& aVersion);
+
+ //! Get the version of the application
+ Standard_EXPORT TCollection_AsciiString ApplicationVersion() const;
+
+ //! Set the name of the application
+ Standard_EXPORT void SetApplicationName(const TCollection_ExtendedString& aName);
+
+ //! Get the name of the application
+ Standard_EXPORT TCollection_ExtendedString ApplicationName() const;
+
+ //! Set the data type
+ Standard_EXPORT void SetDataType(const TCollection_ExtendedString& aType);
+
+ //! Returns data type
+ Standard_EXPORT TCollection_ExtendedString DataType() const;
+
+ //! Add <theUserInfo> to the user informations
+ Standard_EXPORT void AddToUserInfo(const TCollection_AsciiString& theUserInfo);
+
+ //! Return the user informations
+ Standard_EXPORT const TColStd_SequenceOfAsciiString& UserInfo() const;
+
+ //! Add <theUserInfo> to the user informations
+ Standard_EXPORT void AddToComments(const TCollection_ExtendedString& aComment);
+
+ //! Return the user informations
+ Standard_EXPORT const TColStd_SequenceOfExtendedString& Comments() const;
+
+ //! Returns the number of persistent objects
+ Standard_EXPORT Standard_Integer NumberOfObjects() const;
+
+ //! Returns a status of the latest call to Read / Write functions
+ Standard_EXPORT Storage_Error ErrorStatus() const;
+
+ //! Returns an error message if any of the latest call to Read / Write functions
+ Standard_EXPORT TCollection_AsciiString ErrorStatusExtension() const;
+
+ //! Clears error status
+ Standard_EXPORT void ClearErrorStatus();
+
+ Standard_EXPORT void SetNumberOfObjects(const Standard_Integer anObjectNumber);
+
+ Standard_EXPORT void SetStorageVersion(const TCollection_AsciiString& aVersion);
+
+ Standard_EXPORT void SetCreationDate(const TCollection_AsciiString& aDate);
+
+ Standard_EXPORT void SetSchemaVersion(const TCollection_AsciiString& aVersion);
+
+ Standard_EXPORT void SetSchemaName(const TCollection_AsciiString& aName);
+
+private:
+
+ Standard_EXPORT StdStorage_HeaderData();
+
+ Standard_EXPORT void SetErrorStatus(const Storage_Error anError);
+
+ Standard_EXPORT void SetErrorStatusExtension(const TCollection_AsciiString& anErrorExt);
+
+ Standard_Integer myNBObj;
+ TCollection_AsciiString myStorageVersion;
+ TCollection_AsciiString mySchemaVersion;
+ TCollection_AsciiString mySchemaName;
+ TCollection_AsciiString myApplicationVersion;
+ TCollection_ExtendedString myApplicationName;
+ TCollection_ExtendedString myDataType;
+ TCollection_AsciiString myDate;
+ TColStd_SequenceOfAsciiString myUserInfo;
+ TColStd_SequenceOfExtendedString myComments;
+ Storage_Error myErrorStatus;
+ TCollection_AsciiString myErrorStatusExt;
+
+};
+
+#endif // _StdStorage_HeaderData_HeaderFile
--- /dev/null
+
+#ifndef StdStorage_MapOfRoots_HeaderFile
+#define StdStorage_MapOfRoots_HeaderFile
+
+#include <TCollection_AsciiString.hxx>
+#include <StdStorage_Root.hxx>
+#include <TCollection_AsciiString.hxx>
+#include <NCollection_DataMap.hxx>
+
+typedef NCollection_DataMap<TCollection_AsciiString, Handle(StdStorage_Root), TCollection_AsciiString> StdStorage_MapOfRoots;
+typedef NCollection_DataMap<TCollection_AsciiString, Handle(StdStorage_Root), TCollection_AsciiString>::Iterator StdStorage_DataMapIteratorOfMapOfRoots;
+
+#endif // StdStorage_MapOfRoots_HeaderFile
--- /dev/null
+// Created on: 1996-04-30
+// Created by: cle
+// Copyright (c) 1996-1999 Matra Datavision
+// Copyright (c) 1999-2014 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef Storage_PType_HeaderFile
+#define Storage_PType_HeaderFile
+
+#include <TCollection_AsciiString.hxx>
+#include <Standard_Integer.hxx>
+#include <TCollection_AsciiString.hxx>
+#include <NCollection_IndexedDataMap.hxx>
+
+typedef NCollection_IndexedDataMap<TCollection_AsciiString, Standard_Integer, TCollection_AsciiString> StdStorage_MapOfTypes;
+
+
+#endif
--- /dev/null
+// 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_Persistent.hxx>
+#include <Standard_Type.hxx>
+#include <StdStorage_Root.hxx>
+#include <TCollection_AsciiString.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StdStorage_Root, MMgt_TShared)
+
+StdStorage_Root::StdStorage_Root()
+ : myRef(0)
+{
+}
+
+StdStorage_Root::StdStorage_Root(const TCollection_AsciiString& theName,
+ const Handle(StdObjMgt_Persistent)& theObject)
+ : myName(theName)
+ , myType(theObject->PName())
+ , myObject(theObject)
+ , myRef(0)
+{
+}
+
+StdStorage_Root::StdStorage_Root(const TCollection_AsciiString& theName,
+ const Standard_Integer theRef,
+ const TCollection_AsciiString& theType)
+ : myName(theName)
+ , myType(theType)
+ , myRef(theRef)
+{
+}
+
+void StdStorage_Root::SetName(const TCollection_AsciiString& theName)
+{
+ myName = theName;
+}
+
+TCollection_AsciiString StdStorage_Root::Name() const
+{
+ return myName;
+}
+
+void StdStorage_Root::SetObject(const Handle(StdObjMgt_Persistent)& anObject)
+{
+ myObject = anObject;
+}
+
+Handle(StdObjMgt_Persistent) StdStorage_Root::Object() const
+{
+ return myObject;
+}
+
+TCollection_AsciiString StdStorage_Root::Type() const
+{
+ return myType;
+}
+
+void StdStorage_Root::SetReference(const Standard_Integer aRef)
+{
+ myRef = aRef;
+}
+
+Standard_Integer StdStorage_Root::Reference() const
+{
+ return myRef;
+}
+
+void StdStorage_Root::SetType(const TCollection_AsciiString& aType)
+{
+ myType = aType;
+}
--- /dev/null
+// 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 _StdStorage_Root_HeaderFile
+#define _StdStorage_Root_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+
+#include <TCollection_AsciiString.hxx>
+#include <Standard_Integer.hxx>
+#include <MMgt_TShared.hxx>
+class StdObjMgt_Persistent;
+class Storage_Schema;
+class TCollection_AsciiString;
+
+class Storage_Root;
+DEFINE_STANDARD_HANDLE(StdStorage_Root, MMgt_TShared)
+
+//! Describes a named persistent root
+class StdStorage_Root
+ : public MMgt_TShared
+{
+ friend class StdStorage_RootData;
+
+public:
+
+ DEFINE_STANDARD_RTTIEXT(StdStorage_Root, MMgt_TShared)
+
+ //! Creates an empty root
+ Standard_EXPORT StdStorage_Root();
+
+ //! Creates a root for writing
+ Standard_EXPORT StdStorage_Root(const TCollection_AsciiString& theName,
+ const Handle(StdObjMgt_Persistent)& theObject);
+
+ //! Returns a name of the root
+ Standard_EXPORT TCollection_AsciiString Name() const;
+
+ //! Sets a name to the root object
+ Standard_EXPORT void SetName(const TCollection_AsciiString& theName);
+
+ //! Returns a root's persistent object
+ Standard_EXPORT Handle(StdObjMgt_Persistent) Object() const;
+
+ //! Sets a root's persistent object
+ Standard_EXPORT void SetObject(const Handle(StdObjMgt_Persistent)& anObject);
+
+ //! Returns a root's persistent type
+ Standard_EXPORT TCollection_AsciiString Type() const;
+
+ //! Sets a root's persistent type
+ Standard_EXPORT void SetType(const TCollection_AsciiString& aType);
+
+ //! Returns root's position in the root data section
+ Standard_EXPORT Standard_Integer Reference() const;
+
+private:
+
+ Standard_EXPORT StdStorage_Root(const TCollection_AsciiString& theName,
+ const Standard_Integer theRef,
+ const TCollection_AsciiString& theType);
+
+ Standard_EXPORT void SetReference(const Standard_Integer aRef);
+
+ TCollection_AsciiString myName;
+ TCollection_AsciiString myType;
+ Handle(StdObjMgt_Persistent) myObject;
+ Standard_Integer myRef;
+
+};
+
+#endif // _StdStorage_Root_HeaderFile
--- /dev/null
+// 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_Persistent.hxx>
+#include <Standard_ErrorHandler.hxx>
+#include <Standard_NoSuchObject.hxx>
+#include <StdStorage_RootData.hxx>
+#include <StdStorage_Root.hxx>
+#include <Storage_BaseDriver.hxx>
+#include <Storage_StreamTypeMismatchError.hxx>
+#include <Storage_DataMapIteratorOfMapOfPers.hxx>
+#include <TCollection_AsciiString.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StdStorage_RootData, MMgt_TShared)
+
+StdStorage_RootData::StdStorage_RootData()
+ : myErrorStatus(Storage_VSOk)
+{
+}
+
+Standard_Boolean StdStorage_RootData::Read(Storage_BaseDriver& theDriver)
+{
+ // Check driver open mode
+ if (theDriver.OpenMode() != Storage_VSRead
+ && theDriver.OpenMode() != Storage_VSReadWrite)
+ {
+ myErrorStatus = Storage_VSModeError;
+ myErrorStatusExt = "OpenMode";
+ return Standard_False;
+ }
+
+ // Read root section
+ myErrorStatus = theDriver.BeginReadRootSection();
+ if (myErrorStatus != Storage_VSOk)
+ {
+ myErrorStatusExt = "BeginReadRootSection";
+ return Standard_False;
+ }
+
+ TCollection_AsciiString aRootName, aTypeName;
+ Standard_Integer aRef;
+
+ Standard_Integer len = theDriver.RootSectionSize();
+ for (Standard_Integer i = 1; i <= len; i++)
+ {
+ try
+ {
+ OCC_CATCH_SIGNALS
+ theDriver.ReadRoot(aRootName, aRef, aTypeName);
+ }
+ catch (Storage_StreamTypeMismatchError)
+ {
+ myErrorStatus = Storage_VSTypeMismatch;
+ myErrorStatusExt = "ReadRoot";
+ return Standard_False;
+ }
+
+ Handle(StdStorage_Root) aRoot = new StdStorage_Root(aRootName, aRef, aTypeName);
+ myObjects.Bind(aRootName, aRoot);
+ }
+
+ myErrorStatus = theDriver.EndReadRootSection();
+ if (myErrorStatus != Storage_VSOk)
+ {
+ myErrorStatusExt = "EndReadRootSection";
+ return Standard_False;
+ }
+
+ return Standard_True;
+}
+
+Standard_Boolean StdStorage_RootData::Write(Storage_BaseDriver& theDriver)
+{
+ // Check driver open mode
+ if (theDriver.OpenMode() != Storage_VSWrite
+ && theDriver.OpenMode() != Storage_VSReadWrite)
+ {
+ myErrorStatus = Storage_VSModeError;
+ myErrorStatusExt = "OpenMode";
+ return Standard_False;
+ }
+
+ // Write root section
+ myErrorStatus = theDriver.BeginWriteRootSection();
+ if (myErrorStatus != Storage_VSOk)
+ {
+ myErrorStatusExt = "BeginWriteRootSection";
+ return Standard_False;
+ }
+
+ theDriver.SetRootSectionSize(NumberOfRoots());
+ for (StdStorage_MapOfRoots::Iterator anIt(myObjects); anIt.More(); anIt.Next())
+ {
+ const Handle(StdStorage_Root)& aRoot = anIt.Value();
+ try
+ {
+ OCC_CATCH_SIGNALS
+ theDriver.WriteRoot(aRoot->Name(), aRoot->Reference(), aRoot->Type());
+ }
+ catch (Storage_StreamTypeMismatchError)
+ {
+ myErrorStatus = Storage_VSTypeMismatch;
+ myErrorStatusExt = "ReadRoot";
+ return Standard_False;
+ }
+ }
+
+ myErrorStatus = theDriver.EndWriteRootSection();
+ if (myErrorStatus != Storage_VSOk)
+ {
+ myErrorStatusExt = "EndWriteRootSection";
+ return Standard_False;
+ }
+
+ return Standard_True;
+}
+
+Standard_Integer StdStorage_RootData::NumberOfRoots() const
+{
+ return myObjects.Extent();
+}
+
+void StdStorage_RootData::AddRoot(const Handle(StdStorage_Root)& aRoot)
+{
+ myObjects.Bind(aRoot->Name(), aRoot);
+ aRoot->myRef = myObjects.Size();
+}
+
+Handle(StdStorage_HSequenceOfRoots) StdStorage_RootData::Roots() const
+{
+ Handle(StdStorage_HSequenceOfRoots) anObjectsSeq = new StdStorage_HSequenceOfRoots;
+ StdStorage_DataMapIteratorOfMapOfRoots it(myObjects);
+
+ for (; it.More(); it.Next()) {
+ anObjectsSeq->Append(it.Value());
+ }
+
+ return anObjectsSeq;
+}
+
+Handle(StdStorage_Root) StdStorage_RootData::Find(const TCollection_AsciiString& aName) const
+{
+ Handle(StdStorage_Root) p;
+
+ if (myObjects.IsBound(aName)) {
+ p = myObjects.Find(aName);
+ }
+
+ return p;
+}
+
+Standard_Boolean StdStorage_RootData::IsRoot(const TCollection_AsciiString& aName) const
+{
+ return myObjects.IsBound(aName);
+}
+
+void StdStorage_RootData::RemoveRoot(const TCollection_AsciiString& aName)
+{
+ if (myObjects.IsBound(aName)) {
+ myObjects.ChangeFind(aName)->myRef = 0;
+ myObjects.UnBind(aName);
+ Standard_Integer aRef = 1;
+ for (StdStorage_MapOfRoots::Iterator anIt(myObjects); anIt.More(); anIt.Next(), ++aRef)
+ anIt.ChangeValue()->myRef = aRef;
+ }
+}
+
+void StdStorage_RootData::Clear()
+{
+ for (StdStorage_MapOfRoots::Iterator anIt(myObjects); anIt.More(); anIt.Next())
+ anIt.ChangeValue()->myRef = 0;
+
+ myObjects.Clear();
+}
+
+Storage_Error StdStorage_RootData::ErrorStatus() const
+{
+ return myErrorStatus;
+}
+
+void StdStorage_RootData::SetErrorStatus(const Storage_Error anError)
+{
+ myErrorStatus = anError;
+}
+
+void StdStorage_RootData::ClearErrorStatus()
+{
+ myErrorStatus = Storage_VSOk;
+ myErrorStatusExt.Clear();
+}
+
+TCollection_AsciiString StdStorage_RootData::ErrorStatusExtension() const
+{
+ return myErrorStatusExt;
+}
+
+void StdStorage_RootData::SetErrorStatusExtension(const TCollection_AsciiString& anErrorExt)
+{
+ myErrorStatusExt = anErrorExt;
+}
--- /dev/null
+// 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 _StdStorage_RootData_HeaderFile
+#define _StdStorage_RootData_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+
+#include <Storage_Error.hxx>
+#include <TCollection_AsciiString.hxx>
+#include <MMgt_TShared.hxx>
+#include <Standard_Boolean.hxx>
+#include <Standard_Integer.hxx>
+#include <StdStorage_MapOfRoots.hxx>
+#include <StdStorage_HSequenceOfRoots.hxx>
+class Standard_NoSuchObject;
+class Storage_Schema;
+class Storage_BaseDriver;
+class StdStorage_Root;
+class TCollection_AsciiString;
+class StdObjMgt_Persistent;
+
+class StdStorage_RootData;
+DEFINE_STANDARD_HANDLE(StdStorage_RootData, MMgt_TShared)
+
+//! Storage root data section contains root persistent objects
+class StdStorage_RootData
+ : public MMgt_TShared
+{
+ friend class StdStorage_Data;
+
+public:
+
+ DEFINE_STANDARD_RTTIEXT(StdStorage_RootData, MMgt_TShared)
+
+ //! Reads the root data section from the container defined by theDriver.
+ //! Returns Standard_True in case of success. Otherwise, one need to get
+ //! an error code and description using ErrorStatus and ErrorStatusExtension
+ //! functions correspondingly.
+ Standard_EXPORT Standard_Boolean Read(Storage_BaseDriver& theDriver);
+
+ //! Writes the root data section to the container defined by theDriver.
+ //! Returns Standard_True in case of success. Otherwise, one need to get
+ //! an error code and description using ErrorStatus and ErrorStatusExtension
+ //! functions correspondingly.
+ Standard_EXPORT Standard_Boolean Write(Storage_BaseDriver& theDriver);
+
+ //! Returns the number of roots.
+ Standard_EXPORT Standard_Integer NumberOfRoots() const;
+
+ //! Add a root to <me>. If a root with same name is present, it
+ //! will be replaced by <aRoot>.
+ Standard_EXPORT void AddRoot(const Handle(StdStorage_Root)& aRoot);
+
+ //! Returns a sequence of all roots
+ Standard_EXPORT Handle(StdStorage_HSequenceOfRoots) Roots() const;
+
+ //! Finds a root with name <aName>.
+ Standard_EXPORT Handle(StdStorage_Root) Find(const TCollection_AsciiString& aName) const;
+
+ //! Returns Standard_True if <me> contains a root named <aName>
+ Standard_EXPORT Standard_Boolean IsRoot(const TCollection_AsciiString& aName) const;
+
+ //! Removes the root named <aName>.
+ Standard_EXPORT void RemoveRoot(const TCollection_AsciiString& aName);
+
+ //! Returns a status of the latest call to Read / Write functions
+ Standard_EXPORT Storage_Error ErrorStatus() const;
+
+ //! Returns an error message if any of the latest call to Read / Write functions
+ Standard_EXPORT TCollection_AsciiString ErrorStatusExtension() const;
+
+ //! Clears error status
+ Standard_EXPORT void ClearErrorStatus();
+
+ //! Removes all persistent root objects
+ Standard_EXPORT void Clear();
+
+private:
+
+ Standard_EXPORT StdStorage_RootData();
+
+ Standard_EXPORT void SetErrorStatus(const Storage_Error anError);
+
+ Standard_EXPORT void SetErrorStatusExtension(const TCollection_AsciiString& anErrorExt);
+
+ StdStorage_MapOfRoots myObjects;
+ Storage_Error myErrorStatus;
+ TCollection_AsciiString myErrorStatusExt;
+
+};
+
+#endif // _StdStorage_RootData_HeaderFile
--- /dev/null
+
+#ifndef StdStorage_SequenceOfRoots_HeaderFile
+#define StdStorage_SequenceOfRoots_HeaderFile
+
+#include <StdStorage_Root.hxx>
+#include <NCollection_Sequence.hxx>
+
+typedef NCollection_Sequence<Handle(StdStorage_Root)> StdStorage_SequenceOfRoots;
+
+#endif // StdStorage_SequenceOfRoots_HeaderFile
--- /dev/null
+// 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 <Standard_ErrorHandler.hxx>
+#include <Standard_NoSuchObject.hxx>
+#include <StdDrivers.hxx>
+#include <StdStorage_TypeData.hxx>
+#include <Storage_BaseDriver.hxx>
+#include <Storage_StreamTypeMismatchError.hxx>
+#include <TCollection_AsciiString.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StdStorage_TypeData, MMgt_TShared)
+
+StdStorage_TypeData::StdStorage_TypeData()
+: myTypeId(0),
+ myErrorStatus(Storage_VSOk)
+{
+ StdDrivers::BindTypes(myMapOfPInst);
+}
+
+Standard_Boolean StdStorage_TypeData::Read(Storage_BaseDriver& theDriver)
+{
+ // Check driver open mode
+ if (theDriver.OpenMode() != Storage_VSRead
+ && theDriver.OpenMode() != Storage_VSReadWrite)
+ {
+ myErrorStatus = Storage_VSModeError;
+ myErrorStatusExt = "OpenMode";
+ return Standard_False;
+ }
+
+ // Read type section
+ myErrorStatus = theDriver.BeginReadTypeSection();
+ if (myErrorStatus != Storage_VSOk)
+ {
+ myErrorStatusExt = "BeginReadTypeSection";
+ return Standard_False;
+ }
+
+ Standard_Integer aTypeNum;
+ TCollection_AsciiString aTypeName;
+
+ Standard_Integer len = theDriver.TypeSectionSize();
+ for (Standard_Integer i = 1; i <= len; i++)
+ {
+ try
+ {
+ OCC_CATCH_SIGNALS
+ theDriver.ReadTypeInformations (aTypeNum, aTypeName);
+ }
+ catch (Storage_StreamTypeMismatchError)
+ {
+ myErrorStatus = Storage_VSTypeMismatch;
+ myErrorStatusExt = "ReadTypeInformations";
+ return Standard_False;
+ }
+
+ myPt.Add (aTypeName, aTypeNum);
+ }
+
+ myErrorStatus = theDriver.EndReadTypeSection();
+ if (myErrorStatus != Storage_VSOk)
+ {
+ myErrorStatusExt = "EndReadTypeSection";
+ return Standard_False;
+ }
+
+ return Standard_True;
+}
+
+Standard_Boolean StdStorage_TypeData::Write(Storage_BaseDriver& theDriver)
+{
+ // Check driver open mode
+ if (theDriver.OpenMode() != Storage_VSWrite
+ && theDriver.OpenMode() != Storage_VSReadWrite)
+ {
+ myErrorStatus = Storage_VSModeError;
+ myErrorStatusExt = "OpenMode";
+ return Standard_False;
+ }
+
+ // Write type section
+ myErrorStatus = theDriver.BeginWriteTypeSection();
+ if (myErrorStatus != Storage_VSOk)
+ {
+ myErrorStatusExt = "BeginWriteTypeSection";
+ return Standard_False;
+ }
+
+ Standard_Integer len = NumberOfTypes();
+ theDriver.SetTypeSectionSize(len);
+ for (Standard_Integer i = 1; i <= len; i++)
+ {
+ try
+ {
+ OCC_CATCH_SIGNALS
+ theDriver.WriteTypeInformations(i, Type(i));
+ }
+ catch (Storage_StreamTypeMismatchError)
+ {
+ myErrorStatus = Storage_VSTypeMismatch;
+ myErrorStatusExt = "WriteTypeInformations";
+ return Standard_False;
+ }
+ }
+
+ myErrorStatus = theDriver.EndWriteTypeSection();
+ if (myErrorStatus != Storage_VSOk)
+ {
+ myErrorStatusExt = "EndWriteTypeSection";
+ return Standard_False;
+ }
+
+ return Standard_True;
+}
+
+Standard_Integer StdStorage_TypeData::NumberOfTypes() const
+{
+ return myPt.Extent();
+}
+
+Standard_Boolean StdStorage_TypeData::IsType(const TCollection_AsciiString& aName) const
+{
+ return myPt.Contains(aName);
+}
+
+Handle(TColStd_HSequenceOfAsciiString) StdStorage_TypeData::Types() const
+{
+ Handle(TColStd_HSequenceOfAsciiString) r = new TColStd_HSequenceOfAsciiString;
+ Standard_Integer i;
+
+ for (i = 1; i <= myPt.Extent(); i++) {
+ r->Append(myPt.FindKey(i));
+ }
+
+ return r;
+}
+
+void StdStorage_TypeData::AddType(const TCollection_AsciiString& aTypeName, const Standard_Integer aTypeNum)
+{
+ myPt.Add(aTypeName, aTypeNum);
+ myTypeId = Max(aTypeNum, myTypeId);
+}
+
+Standard_Integer StdStorage_TypeData::AddType(const Handle(StdObjMgt_Persistent)& aPObj)
+{
+ TCollection_AsciiString aTypeName = aPObj->PName();
+ if (IsType(aTypeName))
+ return Type(aTypeName);
+
+ if (!myMapOfPInst.IsBound(aTypeName)) {
+ Standard_SStream aSS;
+ aSS << "StdStorage_TypeData::Type " << aTypeName << " isn't registered";
+ throw Standard_NoSuchObject(aSS.str().c_str());
+ }
+
+ Standard_Integer aTypeId = ++myTypeId;
+ AddType(aTypeName, aTypeId);
+
+ return aTypeId;
+}
+
+TCollection_AsciiString StdStorage_TypeData::Type(const Standard_Integer aTypeNum) const
+{
+ TCollection_AsciiString r;
+
+ if (aTypeNum <= myPt.Extent() && aTypeNum > 0)
+ r = myPt.FindKey(aTypeNum);
+ else {
+ Standard_SStream aSS;
+ aSS << "StdStorage_TypeData::Type " << aTypeNum << " not in range";
+ throw Standard_NoSuchObject(aSS.str().c_str());
+ }
+
+ return r;
+}
+
+Standard_Integer StdStorage_TypeData::Type(const TCollection_AsciiString& aTypeName) const
+{
+ Standard_Integer r = 0;
+
+ if (myPt.Contains(aTypeName))
+ r = myPt.FindFromKey(aTypeName);
+ else {
+ Standard_SStream aSS;
+ aSS << "StdStorage_TypeData::Type " << aTypeName << " not found";
+ throw Standard_NoSuchObject(aSS.str().c_str());
+ }
+
+ return r;
+}
+
+StdObjMgt_Persistent::Instantiator
+StdStorage_TypeData::Instantiator(const Standard_Integer aTypeNum) const
+{
+ TCollection_AsciiString aTypeName = Type(aTypeNum);
+ StdObjMgt_Persistent::Instantiator anInstantiator = 0;
+ if (!myMapOfPInst.Find(aTypeName, anInstantiator))
+ return 0;
+ return anInstantiator;
+}
+
+void StdStorage_TypeData::Clear()
+{
+ myPt.Clear();
+}
+
+Storage_Error StdStorage_TypeData::ErrorStatus() const
+{
+ return myErrorStatus;
+}
+
+void StdStorage_TypeData::SetErrorStatus(const Storage_Error anError)
+{
+ myErrorStatus = anError;
+}
+
+void StdStorage_TypeData::ClearErrorStatus()
+{
+ myErrorStatus = Storage_VSOk;
+ myErrorStatusExt.Clear();
+}
+
+TCollection_AsciiString StdStorage_TypeData::ErrorStatusExtension() const
+{
+ return myErrorStatusExt;
+}
+
+void StdStorage_TypeData::SetErrorStatusExtension(const TCollection_AsciiString& anErrorExt)
+{
+ myErrorStatusExt = anErrorExt;
+}
--- /dev/null
+// 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 _StdStorage_TypeData_HeaderFile
+#define _StdStorage_TypeData_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+
+#include <StdStorage_MapOfTypes.hxx>
+#include <Storage_Error.hxx>
+#include <TCollection_AsciiString.hxx>
+#include <MMgt_TShared.hxx>
+#include <Standard_Integer.hxx>
+#include <Standard_Boolean.hxx>
+#include <StdObjMgt_MapOfInstantiators.hxx>
+#include <TColStd_HSequenceOfAsciiString.hxx>
+class Standard_NoSuchObject;
+class Storage_BaseDriver;
+class TCollection_AsciiString;
+
+class StdStorage_TypeData;
+DEFINE_STANDARD_HANDLE(StdStorage_TypeData, MMgt_TShared)
+
+//! Storage type data section keeps association between
+//! persistent textual types and their numbers
+class StdStorage_TypeData
+ : public MMgt_TShared
+{
+ friend class StdStorage_Data;
+
+public:
+
+ DEFINE_STANDARD_RTTIEXT(StdStorage_TypeData, MMgt_TShared)
+
+ //! Reads the type data section from the container defined by theDriver.
+ //! Returns Standard_True in case of success. Otherwise, one need to get
+ //! an error code and description using ErrorStatus and ErrorStatusExtension
+ //! functions correspondingly.
+ Standard_EXPORT Standard_Boolean Read(Storage_BaseDriver& theDriver);
+
+ //! Writes the type data section to the container defined by theDriver.
+ //! Returns Standard_True in case of success. Otherwise, one need to get
+ //! an error code and description using ErrorStatus and ErrorStatusExtension
+ //! functions correspondingly.
+ Standard_EXPORT Standard_Boolean Write(Storage_BaseDriver& theDriver);
+
+ //! Returns the number of registered types
+ Standard_EXPORT Standard_Integer NumberOfTypes() const;
+
+ //! Add a type to the list in case of reading data
+ Standard_EXPORT void AddType (const TCollection_AsciiString& aTypeName, const Standard_Integer aTypeNum);
+
+ //! Add a type of the persistent object in case of writing data
+ Standard_EXPORT Standard_Integer AddType (const Handle(StdObjMgt_Persistent)& aPObj);
+
+ //! Returns the name of the type with number <aTypeNum>
+ Standard_EXPORT TCollection_AsciiString Type (const Standard_Integer aTypeNum) const;
+
+ //! Returns the name of the type with number <aTypeNum>
+ Standard_EXPORT Standard_Integer Type (const TCollection_AsciiString& aTypeName) const;
+
+ //! Returns a persistent object instantiator of <aTypeName>
+ Standard_EXPORT StdObjMgt_Persistent::Instantiator Instantiator(const Standard_Integer aTypeNum) const;
+
+ //! Checks if <aName> is a registered type
+ Standard_EXPORT Standard_Boolean IsType (const TCollection_AsciiString& aName) const;
+
+ //! Returns a sequence of all registered types
+ Standard_EXPORT Handle(TColStd_HSequenceOfAsciiString) Types() const;
+
+ //! Returns a status of the latest call to Read / Write functions
+ Standard_EXPORT Storage_Error ErrorStatus() const;
+
+ //! Returns an error message if any of the latest call to Read / Write functions
+ Standard_EXPORT TCollection_AsciiString ErrorStatusExtension() const;
+
+ //! Clears error status
+ Standard_EXPORT void ClearErrorStatus();
+
+ //! Unregisters all types
+ Standard_EXPORT void Clear();
+
+private:
+
+ Standard_EXPORT StdStorage_TypeData();
+
+ Standard_EXPORT void SetErrorStatus (const Storage_Error anError);
+
+ Standard_EXPORT void SetErrorStatusExtension (const TCollection_AsciiString& anErrorExt);
+
+ Standard_Integer myTypeId;
+ StdObjMgt_MapOfInstantiators myMapOfPInst;
+ StdStorage_MapOfTypes myPt;
+ Storage_Error myErrorStatus;
+ TCollection_AsciiString myErrorStatusExt;
+
+};
+
+#endif // _StdStorage_TypeData_HeaderFile
StdDrivers
StdObject
StdPersistent
+StdStorage
ShapePersistent
--- /dev/null
+# to end a test script
+puts "TEST COMPLETED"
--- /dev/null
+vertex base 0 1 2
+
+check_fsd base bin
+check_fsd base cmp
+check_fsd base gen
--- /dev/null
+plane p 0 0 0 1 0 0
+mkface base p 0 10 0 10
+
+check_fsd base bin
+check_fsd base cmp
+check_fsd base gen
--- /dev/null
+box base 0 0 0 1 2 3
+rotate base 0 0 0 0 1 0 45
+
+check_fsd base bin
+check_fsd base cmp
+check_fsd base gen
--- /dev/null
+cylinder c 5 8 0 3
+trim c c 0 2*pi -1 1
+rotate c 5 5 5 0 1 0 90
+mkface base c
+
+check_fsd base bin
+check_fsd base cmp
+check_fsd base gen
--- /dev/null
+cone c 45 10
+mkface base c 0 1 0 10
+
+check_fsd base bin
+check_fsd base cmp
+check_fsd base gen
--- /dev/null
+sphere s 0 0 0 1
+mkface base s
+
+check_fsd base bin
+check_fsd base cmp
+check_fsd base gen
--- /dev/null
+torus t 1 0.2
+mkface base t
+
+check_fsd base bin
+check_fsd base cmp
+check_fsd base gen
--- /dev/null
+stepread [locate_data_file pr1db.stp] s *
+copy s_1 base
+
+check_fsd base bin
+check_fsd base cmp
+check_fsd base gen
--- /dev/null
+brestore [locate_data_file CTO909_IR2_TuyoPipe20.brep] s1
+brestore [locate_data_file CTO909_IR2_sphere1_20.brep] s2
+brestore [locate_data_file IR2_TuyoPipeBSpline_20_draw2.brep] s3
+brestore [locate_data_file IR2_sphere2_20.brep] s4
+
+compound s1 s2 s3 s4 base
+
+check_fsd base bin
+check_fsd base cmp
+check_fsd base gen
+
\ No newline at end of file
--- /dev/null
+restore [locate_data_file CCV_2_b1_gsu.rle] s1
+restore [locate_data_file CCV_2_c1_gsv.rle] s2
+
+compound s1 s2 base
+
+check_fsd base bin
+check_fsd base cmp
+check_fsd base gen
+
\ No newline at end of file
--- /dev/null
+stepread [locate_data_file bm2_ec_exhaust-A.stp] s *
+copy s_1 base
+
+check_fsd base bin
+check_fsd base cmp
+check_fsd base gen
--- /dev/null
+restore [locate_data_file compsol.brep] base
+
+check_fsd base bin
+check_fsd base cmp
+check_fsd base gen
--- /dev/null
+restore [locate_data_file CTO909_IR2_TuyoPipe20.brep] base
+
+check_fsd base bin
+check_fsd base cmp
+check_fsd base gen
--- /dev/null
+restore [locate_data_file CTS22877.brep] base
+
+check_fsd base bin
+check_fsd base cmp
+check_fsd base gen
--- /dev/null
+restore [locate_data_file cube_ellips.brep] base
+
+check_fsd base bin
+check_fsd base cmp
+check_fsd base gen
--- /dev/null
+restore [locate_data_file OCC12121-CrankArm.brep] base
+
+check_fsd base bin
+check_fsd base cmp
+check_fsd base gen
--- /dev/null
+restore [locate_data_file OCC26387-Paraboloid.brep] base
+
+check_fsd base bin
+check_fsd base cmp
+check_fsd base gen
--- /dev/null
+stepread [locate_data_file bm2_pe_t4-B.stp] s *
+copy s_1 base
+
+check_fsd base bin
+check_fsd base cmp
+check_fsd base gen
--- /dev/null
+stepread [locate_data_file bug21802_as1-oc-214.stp] s *
+copy s_1 base
+
+check_fsd base bin
+check_fsd base cmp
+check_fsd base gen
--- /dev/null
+stepread [locate_data_file bug24595_281390.stp] s *
+copy s_1 base
+
+check_fsd base bin
+check_fsd base cmp
+check_fsd base gen
--- /dev/null
+stepread [locate_data_file ec_soapbox-A.stp] s *
+copy s_1 base
+
+check_fsd base bin
+check_fsd base cmp
+check_fsd base gen
--- /dev/null
+stepread [locate_data_file OCC167.step] s *
+copy s_1 base
+
+check_fsd base bin
+check_fsd base cmp
+check_fsd base gen
--- /dev/null
+stepread [locate_data_file trj4_k1_geo-md-203.stp] s *
+copy s_1 base
+
+check_fsd base bin
+check_fsd base cmp
+check_fsd base gen
--- /dev/null
+restore [locate_data_file bspl-con2.brep] base
+
+check_fsd base bin
+check_fsd base cmp
+check_fsd base gen
--- /dev/null
+restore [locate_data_file case_3_shell.brep] base
+
+check_fsd base bin
+check_fsd base cmp
+check_fsd base gen
--- /dev/null
+pload MODELING OCAF XDE
+
+# check writing shape to FSD archive (old persistence) and reading its back
+proc check_fsd {shape driver {mesher brepmesh}} {
+ # check base shape
+ uplevel #0 checkshape $shape
+
+ # write shape to a file
+ uplevel fsdwrite $shape ${::imagedir}/${::test_image}.$driver ${driver}
+
+ # restore shape from a file
+ uplevel fsdread ${::imagedir}/${::test_image}.$driver result
+
+ # check result shape
+ uplevel checkshape result
+
+ # check the number of subshapes
+ uplevel checknbshapes result -ref \[nbshapes $shape\]
+
+ # check properties
+ uplevel checkprops result -l -equal $shape
+ uplevel checkprops result -s -equal $shape
+ uplevel checkprops result -v -equal $shape
+}
projects / occt.git / commitdiff