OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-04-03 17:56:21 +03:00
Code Packages Releases Activity

0028564: Support of applications using old persistence (ShapeSchema)

Browse Source 
1. Bug fix in reading old persistent data using FSD_File storage driver
2. Persistence compatible with legacy format was restored for shapes
   a. Implemented a storage read / write wrapper for legacy persistence
   b. Added DRAW commands to read / write files in legacy format
   c. Added test cases for reading / writing operations with checking number of sub-shapes and physical properties
   d. Updated related sections of the development guide
This commit is contained in:
snn 2017-03-28 17:13:04 +03:00 committed by bugmaster
parent 632175c3a8
commit ec96437207
124 changed files with 7813 additions and 128 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
adm/UDLIST
View File

@ -247,6 +247,7 @@ n StdObjMgt
n StdDrivers
n StdObject
n StdPersistent
n StdStorage
n ShapePersistent
n TDF
n TDataStd

100
dox/dev_guides/upgrade/upgrade.md
View File

@ -333,6 +333,8 @@ The applications that used these data persistence tools need to be updated to us
The existing data files in standard formats can be converted using OCCT 6.9.1 or a previous version, as follows.
@note Reading / writing custom files capability from OCCT 6.9.1 is restored in OCCT 7.2.0. See details in @ref upgrade_720_persistence section.
#### CSFDB files
Files in *CSFDB* format (usually with extension .csfdb) contain OCCT shape data that can be converted to BRep format.
@ -1248,3 +1250,101 @@ The following Grid management methods within class V3d_Viewer do not implicitly
- *IntTools_Curve::Tolerance()* - returns the valid tolerance for the curve;
- *IntTools_Curve::TangentialTolerance()* - returns the tangential tolerance, which reflects the size of the common between faces.
* 2d tolerance (*IntTools_FaceFace::TolReached2d()*) has been completely removed from the algorithm as unused.
@subsection upgrade_720_persistence Restore OCCT 6.9.1 persistence
Capability of reading / writing files in old format using *Storage_ShapeSchema* functionality from OCCT 6.9.1 has been restored in OCCT 7.2.0.
One can use this functionality in two ways:
- invoke DRAW Test Harness commands fsdread / fsdwrite for shapes
- call *StdStorage* class Read / Write functions in custom code
Code example below demonstrates how to read shapes from a storage driver using *StdStorage* class.
~~~~
// aDriver should be created and opened for reading
Handle(StdStorage_Data) aData;
// Read data from the driver
// StdStorage::Read creates aData instance automatically if it is null
Storage_Error anError = StdStorage::Read(*aDriver, aData);
if (anError != Storage_VSOk)
{
// Error processing
}
// Get root objects
Handle(StdStorage_RootData) aRootData = aData->RootData();
Handle(StdStorage_HSequenceOfRoots) aRoots = aRootData->Roots();
if (!aRoots.IsNull())
{
// Iterator over the sequence of root objects
for (StdStorage_HSequenceOfRoots::Iterator anIt(*aRoots); anIt.More(); anIt.Next())
{
Handle(StdStorage_Root)& aRoot = anIt.ChangeValue();
// Get a persistent root's object
Handle(StdObjMgt_Persistent) aPObject = aRoot->Object();
if (!aPObject.IsNull())
{
Handle(ShapePersistent_TopoDS::HShape) aHShape = Handle(ShapePersistent_TopoDS::HShape)::DownCast(aPObject);
if (aHShape) // Downcast to an expected type to import transient data
{
TopoDS_Shape aShape = aHShape->Import();
shapes.Append(aShape);
}
}
}
}
~~~~
The following code demonstrates how to write shapes in OCCT 7.2.0 using *StdStorage* class.
~~~~
// Create a file driver
NCollection_Handle<Storage_BaseDriver> aFileDriver(new FSD_File());
// Try to open the file driver for writing
try
{
OCC_CATCH_SIGNALS
PCDM_ReadWriter::Open(*aFileDriver, TCollection_ExtendedString(CStringA(filename).GetBuffer()), Storage_VSWrite);
}
catch (Standard_Failure& e)
{
// Error processing
}
// Create a storage data instance
Handle(StdStorage_Data) aData = new StdStorage_Data;
// Set an axiliary application name (optional)
aData->HeaderData()->SetApplicationName(TCollection_ExtendedString("Application"));
// Provide a map to track sharing
StdObjMgt_TransientPersistentMap aMap;
// Iterator over a collection of shapes
for (Standard_Integer i = 1; i <= shapes.Length(); ++i)
{
TopoDS_Shape aShape = shapes.Value(i);
// Translate a shape to a persistent object
Handle(ShapePersistent_TopoDS::HShape) aPShape =
ShapePersistent_TopoDS::Translate(aShape, aMap, ShapePersistent_WithTriangle);
if (aPShape.IsNull())
{
// Error processing
}
// Construct a root name
TCollection_AsciiString aName = "Shape_";
aName += i;
// Add a root to storage data
Handle(StdStorage_Root) aRoot = new StdStorage_Root(aName, aPShape);
aData->RootData()->AddRoot(aRoot);
}
// Write storage data to the driver
Storage_Error anError = StdStorage::Write(*aFileDriver, aData);
if (anError != Storage_VSOk)
{
// Error processing
}
~~~~

1
src/DDocStd/DDocStd.cxx
View File

@ -154,4 +154,5 @@ void DDocStd::AllCommands(Draw_Interpretor& theCommands)
DDocStd::DocumentCommands(theCommands);
DDocStd::ToolsCommands(theCommands);
DDocStd::MTMCommands(theCommands);
DDocStd::ShapeSchemaCommands(theCommands);
}

3
src/DDocStd/DDocStd.hxx
View File

@ -83,7 +83,8 @@ public:
//! Create, Add, Remove, Open, Commit, Undo, Redo, SetNestedMode
Standard_EXPORT static void MTMCommands (Draw_Interpretor& theCommands);
//! ShapeSchema_Read
Standard_EXPORT static void ShapeSchemaCommands(Draw_Interpretor& theCommands);
protected:

221
src/DDocStd/DDocStd_ShapeSchemaCommands.cxx Normal file
View File

@ -0,0 +1,221 @@
#include <DDocStd.hxx>
#include <DBRep.hxx>
#include <FSD_File.hxx>
#include <FSD_CmpFile.hxx>
#include <FSD_BinaryFile.hxx>
#include <BRep_Builder.hxx>
#include <NCollection_Handle.hxx>
#include <TCollection_AsciiString.hxx>
#include <TopTools_SequenceOfShape.hxx>
#include <Storage_BaseDriver.hxx>
#include <StdStorage.hxx>
#include <StdStorage_Data.hxx>
#include <StdStorage_HeaderData.hxx>
#include <StdStorage_RootData.hxx>
#include <StdStorage_TypeData.hxx>
#include <ShapePersistent_TopoDS.hxx>
//=======================================================================
//function : DDocStd_ShapeSchema_Write
//=======================================================================
static Standard_Integer DDocStd_fsdwrite(Draw_Interpretor& theDI,
Standard_Integer theArgNb,
const char** theArgs)
{
if (theArgNb < 3)
{
theDI << "Usage : fsdwrite shapes filename [gen | cmp | bin]\n";
theDI << " Arguments:\n";
theDI << " shapes : list os shape names\n";
theDI << " filename : output file name\n";
theDI << " Storage driver:\n";
theDI << " gen : FSD_File driver (default)\n";
theDI << " cmp : FSD_CmpFile driver\n";
theDI << " bin : FSD_BinaryFile driver\n";
return 1;
}
NCollection_Handle<Storage_BaseDriver> aFileDriver(new FSD_File);
Standard_Boolean hasStorageDriver = Standard_False;
Standard_Integer iArgN = theArgNb - 1;
if (strncmp(theArgs[iArgN], "gen", 3) == 0)
{
aFileDriver = new FSD_File;
hasStorageDriver = Standard_True;
}
else if (strncmp(theArgs[iArgN], "cmp", 3) == 0)
{
aFileDriver = new FSD_CmpFile;
hasStorageDriver = Standard_True;
}
else if (strncmp(theArgs[iArgN], "bin", 3) == 0)
{
aFileDriver = new FSD_BinaryFile;
hasStorageDriver = Standard_True;
}
if (hasStorageDriver) --iArgN;
Storage_Error aStatus = aFileDriver->Open(theArgs[iArgN], Storage_VSWrite);
if (aStatus != Storage_VSOk) {
theDI << "Error : couldn't open file '" << "' for writing (" << aStatus << ")\n";
return 1;
}
TopTools_SequenceOfShape aShapes;
NCollection_DataMap<TCollection_AsciiString, Standard_Integer> aShapeNames;
for (Standard_Integer i = 1; i < iArgN; ++i)
{
TopoDS_Shape aShape = DBRep::Get(theArgs[i]);
if (aShape.IsNull())
{
theDI << "Error : null shape " << theArgs[i] << "\n";
return 1;
}
aShapes.Append(aShape);
if (aShapeNames.IsBound(theArgs[i]))
aShapeNames.ChangeFind(theArgs[i]) += 1;
else
aShapeNames.Bind(theArgs[i], 1);
}
Handle(StdStorage_Data) aData = new StdStorage_Data;
aData->HeaderData()->SetApplicationName(TCollection_ExtendedString("DDocStd_ShapeSchema_Write"));
StdObjMgt_TransientPersistentMap aMap;
for (Standard_Integer i = 1; i <= aShapes.Length(); ++i)
{
TopoDS_Shape aShape = aShapes.Value(i);
Handle(ShapePersistent_TopoDS::HShape) aPShape =
ShapePersistent_TopoDS::Translate(aShape, aMap, ShapePersistent_WithTriangle);
if (aPShape.IsNull())
{
theDI << "Error : couldn't translate shape " << theArgs[i] << "\n";
return 1;
}
TCollection_AsciiString aName = theArgs[i];
if (aShapeNames.IsBound(aName))
{
Standard_Integer n = aShapeNames.Find(theArgs[i]);
if (n > 1)
{
aName += "_";
aName += n;
}
}
Handle(StdStorage_Root) aRoot = new StdStorage_Root(aName, aPShape);
aData->RootData()->AddRoot(aRoot);
}
Storage_Error anError = StdStorage::Write(*aFileDriver, aData);
aFileDriver->Close();
if (anError != Storage_VSOk)
{
theDI << "Error : " << anError << "\n";
return 1;
}
return 0;
}
//=======================================================================
//function : DDocStd_ShapeSchema_Read
//=======================================================================
static Standard_Integer DDocStd_fsdread(Draw_Interpretor& theDI,
Standard_Integer theArgNb,
const char** theArgs)
{
if (theArgNb < 3)
{
theDI << "Usage : fsdread filename shape\n";
theDI << " Arguments:\n";
theDI << " filename : input file name\n";
theDI << " shape : name of an output shape,\n";
theDI << " root shapes will be put into a compound\n";
theDI << " in case of multiple roots in the file\n";
return 1;
}
Handle(StdStorage_Data) aData;
Storage_Error anError = StdStorage::Read(TCollection_AsciiString(theArgs[1]), aData);
if (anError != Storage_VSOk)
{
theDI << "Error : " << anError << "\n";
return 1;
}
TopTools_SequenceOfShape aShapes;
Handle(StdStorage_TypeData) aTypeData = aData->TypeData();
Handle(StdStorage_RootData) aRootData = aData->RootData();
Handle(StdStorage_HSequenceOfRoots) aRoots = aRootData->Roots();
if (!aRoots.IsNull())
{
for (StdStorage_HSequenceOfRoots::Iterator anIt(*aRoots); anIt.More(); anIt.Next())
{
Handle(StdStorage_Root)& aRoot = anIt.ChangeValue();
Handle(StdObjMgt_Persistent) aPObject = aRoot->Object();
if (!aPObject.IsNull())
{
Handle(ShapePersistent_TopoDS::HShape) aHShape = Handle(ShapePersistent_TopoDS::HShape)::DownCast(aPObject);
if (aHShape) // shapes are expected
{
TopoDS_Shape aShape = aHShape->Import();
aShapes.Append(aShape);
}
}
}
}
theDI << "Info : " << aTypeData->NumberOfTypes() << " type(s)\n";
theDI << " " << aRoots->Length() << " root(s)\n";
theDI << " " << aShapes.Length() << " shape(s) translated\n";
if (aShapes.Length() > 1)
{
BRep_Builder aB;
TopoDS_Compound aC;
aB.MakeCompound(aC);
for (Standard_Integer i = 1; i <= aShapes.Length(); ++i)
aB.Add(aC, aShapes.Value(i));
DBRep::Set(theArgs[2], aC);
}
else
DBRep::Set(theArgs[2], aShapes.First());
return 0;
}
//=======================================================================
//function : ShapeSchemaCommands
//purpose : registers shape schema related commands in Draw interpreter
//=======================================================================
void DDocStd::ShapeSchemaCommands(Draw_Interpretor& theCommands)
{
static Standard_Boolean done = Standard_False;
if (done) return;
done = Standard_True;
const char* g = "Shape persistence commands";
theCommands.Add("fsdwrite",
"fsdrite shape filename [driver]",
__FILE__, DDocStd_fsdwrite, g);
theCommands.Add("fsdread",
"fsdread filename shape",
__FILE__, DDocStd_fsdread, g);
}

1
src/DDocStd/FILES
View File

@ -6,4 +6,5 @@ DDocStd_DrawDocument.cxx
DDocStd_DrawDocument.hxx
DDocStd_MTMCommands.cxx
DDocStd_ToolsCommands.cxx
DDocStd_ShapeSchemaCommands.cxx
IDNames.tcl

2
src/ShapePersistent/FILES
View File

@ -9,6 +9,7 @@ ShapePersistent_Geom_Curve.hxx
ShapePersistent_Geom_Surface.cxx
ShapePersistent_Geom_Surface.hxx
ShapePersistent_Geom2d.hxx
ShapePersistent_Geom2d.cxx
ShapePersistent_Geom2d_Curve.cxx
ShapePersistent_Geom2d_Curve.hxx
ShapePersistent_HArray1.hxx
@ -19,3 +20,4 @@ ShapePersistent_Poly.cxx
ShapePersistent_Poly.hxx
ShapePersistent_TopoDS.cxx
ShapePersistent_TopoDS.hxx
ShapePersistent_TriangleMode.hxx

738
src/ShapePersistent/ShapePersistent_BRep.cxx
View File

@ -11,6 +11,8 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Standard_NullObject.hxx>
#include <ShapePersistent_BRep.hxx>
#include <BRep_PointOnCurve.hxx>
@ -30,6 +32,16 @@
#include <BRep_TEdge.hxx>
#include <BRep_TFace.hxx>
#include <Geom_Surface.hxx>
#include <TopoDS_Vertex.hxx>
#include <TopoDS_Edge.hxx>
#include <TopoDS_Face.hxx>
#include <Poly_Polygon2D.hxx>
#include <Poly_Polygon3D.hxx>
#include <Poly_PolygonOnTriangulation.hxx>
#include <Poly_Triangulation.hxx>
enum
{
@ -40,17 +52,23 @@ enum
//=======================================================================
//function : Read
//purpose : Read persistent data from a file
// PointRepresentation
//=======================================================================
void ShapePersistent_BRep::PointRepresentation::Read
(StdObjMgt_ReadData& theReadData)
{ theReadData >> myLocation >> myParameter >> myNext; }
//=======================================================================
//function : Import
//purpose : Import transient object from the persistent data
//=======================================================================
void ShapePersistent_BRep::PointRepresentation::Write
(StdObjMgt_WriteData& theWriteData) const
{ theWriteData << myLocation << myParameter << myNext; }
void ShapePersistent_BRep::PointRepresentation::PChildren
(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
{
myLocation.PChildren(theChildren);
theChildren.Append(myNext);
}
void ShapePersistent_BRep::PointRepresentation::Import
(BRep_ListOfPointRepresentation& thePoints) const
{
@ -64,6 +82,9 @@ Handle(BRep_PointRepresentation)
ShapePersistent_BRep::PointRepresentation::import() const
{ return NULL; }
//=======================================================================
// PointOnCurve
//=======================================================================
void ShapePersistent_BRep::PointOnCurve::Read
(StdObjMgt_ReadData& theReadData)
{
@ -71,6 +92,20 @@ void ShapePersistent_BRep::PointOnCurve::Read
theReadData >> myCurve;
}
void ShapePersistent_BRep::PointOnCurve::Write
(StdObjMgt_WriteData& theWriteData) const
{
PointRepresentation::Write (theWriteData);
theWriteData << myCurve;
}
void ShapePersistent_BRep::PointOnCurve::PChildren
(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
{
PointRepresentation::PChildren(theChildren);
theChildren.Append(myCurve);
}
Handle(BRep_PointRepresentation)
ShapePersistent_BRep::PointOnCurve::import() const
{
@ -82,6 +117,9 @@ Handle(BRep_PointRepresentation)
(myParameter, aCurve, myLocation.Import());
}
//=======================================================================
// PointsOnSurface
//=======================================================================
void ShapePersistent_BRep::PointsOnSurface::Read
(StdObjMgt_ReadData& theReadData)
{
@ -89,6 +127,23 @@ void ShapePersistent_BRep::PointsOnSurface::Read
theReadData >> mySurface;
}
void ShapePersistent_BRep::PointsOnSurface::Write
(StdObjMgt_WriteData& theWriteData) const
{
PointRepresentation::Write (theWriteData);
theWriteData << mySurface;
}
void ShapePersistent_BRep::PointsOnSurface::PChildren
(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
{
PointRepresentation::PChildren(theChildren);
theChildren.Append(mySurface);
}
//=======================================================================
// PointOnCurveOnSurface
//=======================================================================
void ShapePersistent_BRep::PointOnCurveOnSurface::Read
(StdObjMgt_ReadData& theReadData)
{
@ -96,6 +151,20 @@ void ShapePersistent_BRep::PointOnCurveOnSurface::Read
theReadData >> myPCurve;
}
void ShapePersistent_BRep::PointOnCurveOnSurface::Write
(StdObjMgt_WriteData& theWriteData) const
{
PointsOnSurface::Write (theWriteData);
theWriteData << myPCurve;
}
void ShapePersistent_BRep::PointOnCurveOnSurface::PChildren
(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
{
PointRepresentation::PChildren(theChildren);
theChildren.Append(myPCurve);
}
Handle(BRep_PointRepresentation)
ShapePersistent_BRep::PointOnCurveOnSurface::import() const
{
@ -111,6 +180,9 @@ Handle(BRep_PointRepresentation)
(myParameter, aPCurve, aSurface, myLocation.Import());
}
//=======================================================================
// PointOnSurface
//=======================================================================
void ShapePersistent_BRep::PointOnSurface::Read
(StdObjMgt_ReadData& theReadData)
{
@ -118,6 +190,13 @@ void ShapePersistent_BRep::PointOnSurface::Read
theReadData >> myParameter2;
}
void ShapePersistent_BRep::PointOnSurface::Write
(StdObjMgt_WriteData& theWriteData) const
{
PointsOnSurface::Write(theWriteData);
theWriteData << myParameter2;
}
Handle(BRep_PointRepresentation)
ShapePersistent_BRep::PointOnSurface::import() const
{
@ -130,17 +209,23 @@ Handle(BRep_PointRepresentation)
}
//=======================================================================
//function : Read
//purpose : Read persistent data from a file
// CurveRepresentation
//=======================================================================
void ShapePersistent_BRep::CurveRepresentation::Read
(StdObjMgt_ReadData& theReadData)
{ theReadData >> myLocation >> myNext; }
//=======================================================================
//function : Import
//purpose : Import transient object from the persistent data
//=======================================================================
void ShapePersistent_BRep::CurveRepresentation::Write
(StdObjMgt_WriteData& theWriteData) const
{ theWriteData << myLocation << myNext; }
void ShapePersistent_BRep::CurveRepresentation::PChildren
(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
{
myLocation.PChildren(theChildren);
theChildren.Append(myNext);
}
void ShapePersistent_BRep::CurveRepresentation::Import
(BRep_ListOfCurveRepresentation& theCurves) const
{
@ -154,6 +239,9 @@ Handle(BRep_CurveRepresentation)
ShapePersistent_BRep::CurveRepresentation::import() const
{ return NULL; }
//=======================================================================
// GCurve
//=======================================================================
void ShapePersistent_BRep::GCurve::Read
(StdObjMgt_ReadData& theReadData)
{
@ -161,6 +249,16 @@ void ShapePersistent_BRep::GCurve::Read
theReadData >> myFirst >> myLast;
}
void ShapePersistent_BRep::GCurve::Write
(StdObjMgt_WriteData& theWriteData) const
{
CurveRepresentation::Write(theWriteData);
theWriteData << myFirst << myLast;
}
//=======================================================================
// Curve3D
//=======================================================================
void ShapePersistent_BRep::Curve3D::Read
(StdObjMgt_ReadData& theReadData)
{
@ -168,6 +266,20 @@ void ShapePersistent_BRep::Curve3D::Read
theReadData >> myCurve3D;
}
void ShapePersistent_BRep::Curve3D::Write
(StdObjMgt_WriteData& theWriteData) const
{
GCurve::Write (theWriteData);
theWriteData << myCurve3D;
}
void ShapePersistent_BRep::Curve3D::PChildren
(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
{
GCurve::PChildren(theChildren);
theChildren.Append(myCurve3D);
}
Handle(BRep_CurveRepresentation)
ShapePersistent_BRep::Curve3D::import() const
{
@ -182,6 +294,9 @@ Handle(BRep_CurveRepresentation)
return aRepresentation;
}
//=======================================================================
// CurveOnSurface
//=======================================================================
void ShapePersistent_BRep::CurveOnSurface::Read
(StdObjMgt_ReadData& theReadData)
{
@ -189,6 +304,21 @@ void ShapePersistent_BRep::CurveOnSurface::Read
theReadData >> myPCurve >> mySurface >> myUV1 >> myUV2;
}
void ShapePersistent_BRep::CurveOnSurface::Write
(StdObjMgt_WriteData& theWriteData) const
{
GCurve::Write (theWriteData);
theWriteData << myPCurve << mySurface << myUV1 << myUV2;
}
void ShapePersistent_BRep::CurveOnSurface::PChildren
(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
{
GCurve::PChildren(theChildren);
theChildren.Append(myPCurve);
theChildren.Append(mySurface);
}
Handle(BRep_CurveRepresentation)
ShapePersistent_BRep::CurveOnSurface::import() const
{
@ -209,6 +339,9 @@ Handle(BRep_CurveRepresentation)
return aRepresentation;
}
//=======================================================================
// CurveOnClosedSurface
//=======================================================================
void ShapePersistent_BRep::CurveOnClosedSurface::Read
(StdObjMgt_ReadData& theReadData)
{
@ -216,6 +349,20 @@ void ShapePersistent_BRep::CurveOnClosedSurface::Read
theReadData >> myPCurve2 >> myContinuity >> myUV21 >> myUV22;
}
void ShapePersistent_BRep::CurveOnClosedSurface::Write
(StdObjMgt_WriteData& theWriteData) const
{
CurveOnSurface::Write (theWriteData);
theWriteData << myPCurve2 << myContinuity << myUV21 << myUV22;
}
void ShapePersistent_BRep::CurveOnClosedSurface::PChildren
(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
{
CurveOnSurface::PChildren(theChildren);
theChildren.Append(myPCurve2);
}
Handle(BRep_CurveRepresentation)
ShapePersistent_BRep::CurveOnClosedSurface::import() const
{
@ -244,6 +391,9 @@ Handle(BRep_CurveRepresentation)
return aRepresentation;
}
//=======================================================================
// Polygon3D
//=======================================================================
void ShapePersistent_BRep::Polygon3D::Read
(StdObjMgt_ReadData& theReadData)
{
@ -251,6 +401,20 @@ void ShapePersistent_BRep::Polygon3D::Read
theReadData >> myPolygon3D;
}
void ShapePersistent_BRep::Polygon3D::Write
(StdObjMgt_WriteData& theWriteData) const
{
CurveRepresentation::Write (theWriteData);
theWriteData << myPolygon3D;
}
void ShapePersistent_BRep::Polygon3D::PChildren
(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
{
CurveRepresentation::PChildren(theChildren);
theChildren.Append(myPolygon3D);
}
Handle(BRep_CurveRepresentation)
ShapePersistent_BRep::Polygon3D::import() const
{
@ -261,6 +425,9 @@ Handle(BRep_CurveRepresentation)
return new BRep_Polygon3D (aPolygon3D, myLocation.Import());
}
//=======================================================================
// PolygonOnTriangulation
//=======================================================================
void ShapePersistent_BRep::PolygonOnTriangulation::Read
(StdObjMgt_ReadData& theReadData)
{
@ -268,6 +435,21 @@ void ShapePersistent_BRep::PolygonOnTriangulation::Read
theReadData >> myPolygon >> myTriangulation;
}
void ShapePersistent_BRep::PolygonOnTriangulation::Write
(StdObjMgt_WriteData& theWriteData) const
{
CurveRepresentation::Write (theWriteData);
theWriteData << myPolygon << myTriangulation;
}
void ShapePersistent_BRep::PolygonOnTriangulation::PChildren
(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
{
CurveRepresentation::PChildren(theChildren);
theChildren.Append(myPolygon);
theChildren.Append(myTriangulation);
}
Handle(BRep_CurveRepresentation)
ShapePersistent_BRep::PolygonOnTriangulation::import() const
{
@ -283,6 +465,9 @@ Handle(BRep_CurveRepresentation)
(aPolygon, aTriangulation, myLocation.Import());
}
//=======================================================================
// PolygonOnClosedTriangulation
//=======================================================================
void ShapePersistent_BRep::PolygonOnClosedTriangulation::Read
(StdObjMgt_ReadData& theReadData)
{
@ -290,6 +475,20 @@ void ShapePersistent_BRep::PolygonOnClosedTriangulation::Read
theReadData >> myPolygon2;
}
void ShapePersistent_BRep::PolygonOnClosedTriangulation::Write
(StdObjMgt_WriteData& theWriteData) const
{
PolygonOnTriangulation::Write (theWriteData);
theWriteData << myPolygon2;
}
void ShapePersistent_BRep::PolygonOnClosedTriangulation::PChildren
(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
{
PolygonOnTriangulation::PChildren(theChildren);
theChildren.Append(myPolygon2);
}
Handle(BRep_CurveRepresentation)
ShapePersistent_BRep::PolygonOnClosedTriangulation::import() const
{
@ -309,6 +508,9 @@ Handle(BRep_CurveRepresentation)
(aPolygon, aPolygon2, aTriangulation, myLocation.Import());
}
//=======================================================================
// PolygonOnSurface
//=======================================================================
void ShapePersistent_BRep::PolygonOnSurface::Read
(StdObjMgt_ReadData& theReadData)
{
@ -316,6 +518,21 @@ void ShapePersistent_BRep::PolygonOnSurface::Read
theReadData >> myPolygon2D >> mySurface;
}
void ShapePersistent_BRep::PolygonOnSurface::Write
(StdObjMgt_WriteData& theWriteData) const
{
CurveRepresentation::Write (theWriteData);
theWriteData << myPolygon2D << mySurface;
}
void ShapePersistent_BRep::PolygonOnSurface::PChildren
(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
{
CurveRepresentation::PChildren(theChildren);
theChildren.Append(myPolygon2D);
theChildren.Append(mySurface);
}
Handle(BRep_CurveRepresentation)
ShapePersistent_BRep::PolygonOnSurface::import() const
{
@ -330,6 +547,9 @@ Handle(BRep_CurveRepresentation)
return new BRep_PolygonOnSurface (aPolygon2D, aSurface, myLocation.Import());
}
//=======================================================================
// PolygonOnClosedSurface
//=======================================================================
void ShapePersistent_BRep::PolygonOnClosedSurface::Read
(StdObjMgt_ReadData& theReadData)
{
@ -337,6 +557,20 @@ void ShapePersistent_BRep::PolygonOnClosedSurface::Read
theReadData >> myPolygon2;
}
void ShapePersistent_BRep::PolygonOnClosedSurface::Write
(StdObjMgt_WriteData& theWriteData) const
{
PolygonOnSurface::Write (theWriteData);
theWriteData << myPolygon2;
}
void ShapePersistent_BRep::PolygonOnClosedSurface::PChildren
(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
{
PolygonOnSurface::PChildren(theChildren);
theChildren.Append(myPolygon2);
}
Handle(BRep_CurveRepresentation)
ShapePersistent_BRep::PolygonOnClosedSurface::import() const
{
@ -356,6 +590,9 @@ Handle(BRep_CurveRepresentation)
(aPolygon2D, aPolygon2, aSurface, myLocation.Import());
}
//=======================================================================
// CurveOn2Surfaces
//=======================================================================
void ShapePersistent_BRep::CurveOn2Surfaces::Read
(StdObjMgt_ReadData& theReadData)
{
@ -363,6 +600,22 @@ void ShapePersistent_BRep::CurveOn2Surfaces::Read
theReadData >> mySurface >> mySurface2 >> myLocation2 >> myContinuity;
}
void ShapePersistent_BRep::CurveOn2Surfaces::Write
(StdObjMgt_WriteData& theWriteData) const
{
CurveRepresentation::Write (theWriteData);
theWriteData << mySurface << mySurface2 << myLocation2 << myContinuity;
}
void ShapePersistent_BRep::CurveOn2Surfaces::PChildren
(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
{
CurveRepresentation::PChildren(theChildren);
theChildren.Append(mySurface);
theChildren.Append(mySurface2);
myLocation2.PChildren(theChildren);
}
Handle(BRep_CurveRepresentation)
ShapePersistent_BRep::CurveOn2Surfaces::import() const
{
@ -434,3 +687,464 @@ Handle(TopoDS_TShape) ShapePersistent_BRep::pTFace::createTShape() const
return aTFace;
}
//=======================================================================
//function : Translate
//purpose : Translates a shape to its persistent avatar
//=======================================================================
Handle(ShapePersistent_BRep::TVertex::pTObjectT)
ShapePersistent_BRep::Translate (const TopoDS_Vertex& theVertex,
StdObjMgt_TransientPersistentMap& theMap)
{
Handle(BRep_TVertex) TTV = Handle(BRep_TVertex)::DownCast (theVertex.TShape());
Handle(TVertex::pTObjectT) PTV = new TVertex::pTObjectT;
PTV->myPnt = TTV->Pnt();
PTV->myTolerance = TTV->Tolerance();
BRep_ListIteratorOfListOfPointRepresentation anItPR(TTV->Points());
Handle(PointRepresentation) PPR, CPPR;
while (anItPR.More())
{
const Handle(BRep_PointRepresentation)& PR = anItPR.Value();
if (PR->IsPointOnCurve()) {
Handle(PointOnCurve) POC = Translate(PR->Parameter(),
PR->Curve(),
PR->Location(),
theMap);
CPPR = POC;
}
else if (PR->IsPointOnCurveOnSurface()) {
Handle(PointOnCurveOnSurface) POCS = Translate(PR->Parameter(),
PR->PCurve(),
PR->Surface(),
PR->Location(),
theMap);
CPPR = POCS;
}
else if (PR->IsPointOnSurface()) {
Handle(PointOnSurface) POS = Translate(PR->Parameter(),
PR->Parameter2(),
PR->Surface(),
PR->Location(),
theMap);
CPPR = POS;
}
CPPR->myNext = PPR;
PPR = CPPR;
anItPR.Next();
}
PTV->myPoints = PPR;
return PTV;
}
//=======================================================================
//function : Translate
//purpose : Translates a shape to its persistent avatar
//=======================================================================
Handle(ShapePersistent_BRep::TEdge::pTObjectT)
ShapePersistent_BRep::Translate (const TopoDS_Edge& theEdge,
StdObjMgt_TransientPersistentMap& theMap,
ShapePersistent_TriangleMode theTriangleMode)
{
Handle(BRep_TEdge) TTE = Handle(BRep_TEdge)::DownCast (theEdge.TShape());
Handle(TEdge::pTObjectT) PTE = new TEdge::pTObjectT;
PTE->myTolerance = TTE->Tolerance();
if (TTE->SameParameter()) PTE->myFlags |= ParameterMask;
if (TTE->SameRange()) PTE->myFlags |= RangeMask;
if (TTE->Degenerated()) PTE->myFlags |= DegeneratedMask;
// Representations
BRep_ListIteratorOfListOfCurveRepresentation itcr(TTE->Curves());
Handle(CurveRepresentation) PCR, CPCR;
Handle(BRep_GCurve) GC;
Standard_Real f, l;
while (itcr.More())
{
const Handle(BRep_CurveRepresentation)& CR = itcr.Value();
GC = Handle(BRep_GCurve)::DownCast(CR);
if (!GC.IsNull())
{
GC->Range(f, l);
// CurveRepresentation is Curve3D
if (CR->IsCurve3D()) {
Handle(Curve3D) C3D = Translate(CR->Curve3D(), f, l, CR->Location(), theMap);
CPCR = C3D;
}
// CurveRepresentation is CurveOnSurface
else if (CR->IsCurveOnSurface())
{
Handle(BRep_CurveOnSurface)& theCOS = (Handle(BRep_CurveOnSurface)&) CR;
Handle(CurveOnSurface) COS;
// CurveRepresentation is CurveOnSurface
if (!CR->IsCurveOnClosedSurface())
{
COS = Translate(CR->PCurve(), f, l, CR->Surface(), CR->Location(), theMap);
}
// CurveRepresentation is CurveOnClosedSurface
else
{
// get UVPoints for the CurveOnClosedSurface definition.
Handle(BRep_CurveOnClosedSurface)& theCOCS =
(Handle(BRep_CurveOnClosedSurface)&) CR;
gp_Pnt2d Pnt21, Pnt22;
theCOCS->UVPoints2(Pnt21, Pnt22);
Handle(CurveOnClosedSurface) COCS = Translate(CR->PCurve(), CR->PCurve2(),
f, l, CR->Surface(),
CR->Location(), CR->Continuity(),
theMap);
COCS->myUV21 = Pnt21;
COCS->myUV22 = Pnt22;
COS = COCS;
}
// get UVPoints for the CurveOnSurface definition.
gp_Pnt2d Pnt1, Pnt2;
theCOS->UVPoints(Pnt1, Pnt2);
COS->myUV1 = Pnt1;
COS->myUV2 = Pnt2;
CPCR = COS;
}
}
// CurveRepresentation is CurveOn2Surfaces
else if (CR->IsRegularity())
{
Handle(CurveOn2Surfaces) R = Translate(CR->Surface(), CR->Surface2(),
CR->Location(), CR->Location2(),
CR->Continuity(),
theMap);
CPCR = R;
}
// CurveRepresentation is Polygon or Triangulation
else if (theTriangleMode == ShapePersistent_WithTriangle) {
// CurveRepresentation is Polygon3D
if (CR->IsPolygon3D()) {
Handle(Polygon3D) P3D = Translate(CR->Polygon3D(), CR->Location(), theMap);
CPCR = P3D;
}
// CurveRepresentation is PolygonOnSurface
else if (CR->IsPolygonOnSurface())
{
// CurveRepresentation is PolygonOnClosedSurface
if (CR->IsPolygonOnClosedSurface()) {
Handle(PolygonOnClosedSurface) PolOCS = Translate(CR->Polygon(), CR->Polygon2(),
CR->Surface(), CR->Location(),
theMap);
CPCR = PolOCS;
}
// CurveRepresentation is PolygonOnSurface
else
{
Handle(PolygonOnSurface) PolOS = Translate(CR->Polygon(), CR->Surface(),
CR->Location(), theMap);
CPCR = PolOS;
}
}
// CurveRepresentation is PolygonOnTriangulation
else if (CR->IsPolygonOnTriangulation())
{
// CurveRepresentation is PolygonOnClosedTriangulation
if (CR->IsPolygonOnClosedTriangulation())
{
Handle(PolygonOnClosedTriangulation) PolOCT = Translate(CR->PolygonOnTriangulation(),
CR->PolygonOnTriangulation2(),
CR->Triangulation(),
CR->Location(),
theMap);
CPCR = PolOCT;
}
// CurveRepresentation is PolygonOnTriangulation
else
{
Handle(PolygonOnTriangulation) PolOT = Translate(CR->PolygonOnTriangulation(),
CR->Triangulation(),
CR->Location(),
theMap);
CPCR = PolOT;
}
}
}
else
{
// jumps the curve representation
itcr.Next();
continue;
}
Standard_NullObject_Raise_if(CPCR.IsNull(), "Null CurveRepresentation");
CPCR->myNext = PCR;
PCR = CPCR;
itcr.Next();
}
// set
PTE->myCurves = PCR;
return PTE;
}
//=======================================================================
//function : Translate
//purpose : Translates a shape to its persistent avatar
//=======================================================================
Handle(ShapePersistent_BRep::TFace::pTObjectT)
ShapePersistent_BRep::Translate (const TopoDS_Face& theFace,
StdObjMgt_TransientPersistentMap& theMap,
ShapePersistent_TriangleMode theTriangleMode)
{
Handle(BRep_TFace) TTF = Handle(BRep_TFace)::DownCast (theFace.TShape());
Handle(TFace::pTObjectT) PTF = new TFace::pTObjectT;
PTF->myTolerance = TTF->Tolerance();
PTF->myLocation = StdObject_Location::Translate(TTF->Location(), theMap);
PTF->myNaturalRestriction = TTF->NaturalRestriction();
// Surface
PTF->mySurface = ShapePersistent_Geom::Translate(TTF->Surface(), theMap);
// Triangulation
if (theTriangleMode == ShapePersistent_WithTriangle) {
PTF->myTriangulation = ShapePersistent_Poly::Translate(TTF->Triangulation(), theMap);
}
return PTF;
}
//=======================================================================
//function : Translate
//purpose : Translates a shape to its persistent avatar
//=======================================================================
Handle(ShapePersistent_BRep::PointOnCurve)
ShapePersistent_BRep::Translate (Standard_Real theParam,
const Handle(Geom_Curve)& theCurve,
const TopLoc_Location& theLoc,
StdObjMgt_TransientPersistentMap& theMap)
{
Handle(PointOnCurve) aPPonC = new PointOnCurve;
aPPonC->myParameter = theParam;
aPPonC->myCurve = ShapePersistent_Geom::Translate(theCurve, theMap);
aPPonC->myLocation = StdObject_Location::Translate(theLoc, theMap);
return aPPonC;
}
//=======================================================================
//function : Translate
//purpose : Translates a shape to its persistent avatar
//=======================================================================
Handle(ShapePersistent_BRep::PointOnCurveOnSurface)
ShapePersistent_BRep::Translate(Standard_Real theParam,
const Handle(Geom2d_Curve)& theCurve,
const Handle(Geom_Surface)& theSurf,
const TopLoc_Location& theLoc,
StdObjMgt_TransientPersistentMap& theMap)
{
Handle(PointOnCurveOnSurface) aPPonConS = new PointOnCurveOnSurface;
aPPonConS->myParameter = theParam;
aPPonConS->myPCurve = ShapePersistent_Geom2d::Translate(theCurve, theMap);
aPPonConS->mySurface = ShapePersistent_Geom::Translate(theSurf, theMap);
aPPonConS->myLocation = StdObject_Location::Translate(theLoc, theMap);
return aPPonConS;
}
//=======================================================================
//function : Translate
//purpose : Translates a shape to its persistent avatar
//=======================================================================
Handle(ShapePersistent_BRep::PointOnSurface)
ShapePersistent_BRep::Translate(Standard_Real theParam,
Standard_Real theParam2,
const Handle(Geom_Surface)& theSurf,
const TopLoc_Location& theLoc,
StdObjMgt_TransientPersistentMap& theMap)
{
Handle(PointOnSurface) aPonS = new PointOnSurface;
aPonS->myParameter = theParam;
aPonS->myParameter2 = theParam2;
aPonS->mySurface = ShapePersistent_Geom::Translate(theSurf, theMap);
aPonS->myLocation = StdObject_Location::Translate(theLoc, theMap);
return aPonS;
}
//=======================================================================
//function : Translate
//purpose : Translates a shape to its persistent avatar
//=======================================================================
Handle(ShapePersistent_BRep::CurveOnSurface)
ShapePersistent_BRep::Translate(const Handle(Geom2d_Curve)& theCurve,
const Standard_Real theFirstParam,
const Standard_Real theLastParam,
const Handle(Geom_Surface)& theSurf,
const TopLoc_Location& theLoc,
StdObjMgt_TransientPersistentMap& theMap)
{
Handle(CurveOnSurface) aPConS = new CurveOnSurface;
aPConS->myPCurve = ShapePersistent_Geom2d::Translate(theCurve, theMap);
aPConS->myFirst = theFirstParam;
aPConS->myLast = theLastParam;
aPConS->mySurface = ShapePersistent_Geom::Translate(theSurf, theMap);
aPConS->myLocation = StdObject_Location::Translate(theLoc, theMap);
return aPConS;
}
//=======================================================================
//function : Translate
//purpose : Translates a shape to its persistent avatar
//=======================================================================
Handle(ShapePersistent_BRep::CurveOnClosedSurface)
ShapePersistent_BRep::Translate(const Handle(Geom2d_Curve)& theCurve,
const Handle(Geom2d_Curve)& theCurve2,
const Standard_Real theFirstParam,
const Standard_Real theLastParam,
const Handle(Geom_Surface)& theSurf,
const TopLoc_Location& theLoc,
const GeomAbs_Shape theContinuity,
StdObjMgt_TransientPersistentMap& theMap)
{
Handle(CurveOnClosedSurface) aPConCS = new CurveOnClosedSurface;
aPConCS->myPCurve = ShapePersistent_Geom2d::Translate(theCurve, theMap);
aPConCS->myPCurve2 = ShapePersistent_Geom2d::Translate(theCurve2, theMap);
aPConCS->myFirst = theFirstParam;
aPConCS->myLast = theLastParam;
aPConCS->mySurface = ShapePersistent_Geom::Translate(theSurf, theMap);
aPConCS->myLocation = StdObject_Location::Translate(theLoc, theMap);
aPConCS->myContinuity = theContinuity;
return aPConCS;
}
//=======================================================================
//function : Translate
//purpose : Translates a shape to its persistent avatar
//=======================================================================
Handle(ShapePersistent_BRep::CurveOn2Surfaces)
ShapePersistent_BRep::Translate(const Handle(Geom_Surface)& theSurf,
const Handle(Geom_Surface)& theSurf2,
const TopLoc_Location& theLoc,
const TopLoc_Location& theLoc2,
const GeomAbs_Shape theContinuity,
StdObjMgt_TransientPersistentMap& theMap)
{
Handle(CurveOn2Surfaces) aPCon2S = new CurveOn2Surfaces;
aPCon2S->mySurface = ShapePersistent_Geom::Translate(theSurf, theMap);
aPCon2S->mySurface2 = ShapePersistent_Geom::Translate(theSurf2, theMap);
aPCon2S->myLocation = StdObject_Location::Translate(theLoc, theMap);
aPCon2S->myLocation2 = StdObject_Location::Translate(theLoc2, theMap);
aPCon2S->myContinuity = theContinuity;
return aPCon2S;
}
//=======================================================================
//function : Translate
//purpose : Translates a shape to its persistent avatar
//=======================================================================
Handle(ShapePersistent_BRep::Curve3D)
ShapePersistent_BRep::Translate (const Handle(Geom_Curve)& theCurve,
const Standard_Real theFirstParam,
const Standard_Real theLastParam,
const TopLoc_Location& theLoc,
StdObjMgt_TransientPersistentMap& theMap)
{
Handle(Curve3D) aPCurve3D = new Curve3D;
aPCurve3D->myCurve3D = ShapePersistent_Geom::Translate(theCurve, theMap);
aPCurve3D->myLocation = StdObject_Location::Translate(theLoc, theMap);
aPCurve3D->myFirst = theFirstParam;
aPCurve3D->myLast = theLastParam;
return aPCurve3D;
}
//=======================================================================
//function : Translate
//purpose : Translates a shape to its persistent avatar
//=======================================================================
Handle(ShapePersistent_BRep::Polygon3D)
ShapePersistent_BRep::Translate(const Handle(Poly_Polygon3D)& thePoly,
const TopLoc_Location& theLoc,
StdObjMgt_TransientPersistentMap& theMap)
{
Handle(Polygon3D) aPPoly = new Polygon3D;
aPPoly->myPolygon3D = ShapePersistent_Poly::Translate(thePoly, theMap);
aPPoly->myLocation = StdObject_Location::Translate(theLoc, theMap);
return aPPoly;
}
//=======================================================================
//function : Translate
//purpose : Translates a shape to its persistent avatar
//=======================================================================
Handle(ShapePersistent_BRep::PolygonOnClosedSurface)
ShapePersistent_BRep::Translate(const Handle(Poly_Polygon2D)& thePoly,
const Handle(Poly_Polygon2D)& thePoly2,
const Handle(Geom_Surface)& theSurf,
const TopLoc_Location& theLoc,
StdObjMgt_TransientPersistentMap& theMap)
{
Handle(PolygonOnClosedSurface) aPPonCS = new PolygonOnClosedSurface;
aPPonCS->myPolygon2D = ShapePersistent_Poly::Translate(thePoly, theMap);
aPPonCS->myPolygon2 = ShapePersistent_Poly::Translate(thePoly2, theMap);
aPPonCS->mySurface = ShapePersistent_Geom::Translate(theSurf, theMap);
aPPonCS->myLocation = StdObject_Location::Translate(theLoc, theMap);
return aPPonCS;
}
//=======================================================================
//function : Translate
//purpose : Translates a shape to its persistent avatar
//=======================================================================
Handle(ShapePersistent_BRep::PolygonOnSurface)
ShapePersistent_BRep::Translate(const Handle(Poly_Polygon2D)& thePoly,
const Handle(Geom_Surface)& theSurf,
const TopLoc_Location& theLoc,
StdObjMgt_TransientPersistentMap& theMap)
{
Handle(PolygonOnSurface) aPPonS = new PolygonOnSurface;
aPPonS->myPolygon2D = ShapePersistent_Poly::Translate(thePoly, theMap);
aPPonS->mySurface = ShapePersistent_Geom::Translate(theSurf, theMap);
aPPonS->myLocation = StdObject_Location::Translate(theLoc, theMap);
return aPPonS;
}
//=======================================================================
//function : Translate
//purpose : Translates a shape to its persistent avatar
//=======================================================================
Handle(ShapePersistent_BRep::PolygonOnClosedTriangulation)
ShapePersistent_BRep::Translate(const Handle(Poly_PolygonOnTriangulation)& thePolyOnTriang,
const Handle(Poly_PolygonOnTriangulation)& thePolyOnTriang2,
const Handle(Poly_Triangulation)& thePolyTriang,
const TopLoc_Location& theLoc,
StdObjMgt_TransientPersistentMap& theMap)
{
Handle(PolygonOnClosedTriangulation) aPPonCS = new PolygonOnClosedTriangulation;
aPPonCS->myPolygon = ShapePersistent_Poly::Translate(thePolyOnTriang, theMap);
aPPonCS->myPolygon2 = ShapePersistent_Poly::Translate(thePolyOnTriang2, theMap);
aPPonCS->myTriangulation = ShapePersistent_Poly::Translate(thePolyTriang, theMap);
aPPonCS->myLocation = StdObject_Location::Translate(theLoc, theMap);
return aPPonCS;
}
//=======================================================================
//function : Translate
//purpose : Translates a shape to its persistent avatar
//=======================================================================
Handle(ShapePersistent_BRep::PolygonOnTriangulation)
ShapePersistent_BRep::Translate(const Handle(Poly_PolygonOnTriangulation)& thePolyOnTriang,
const Handle(Poly_Triangulation)& thePolyTriang,
const TopLoc_Location& theLoc,
StdObjMgt_TransientPersistentMap& theMap)
{
Handle(PolygonOnTriangulation) aPPonT = new PolygonOnTriangulation;
aPPonT->myPolygon = ShapePersistent_Poly::Translate(thePolyOnTriang, theMap);
aPPonT->myTriangulation = ShapePersistent_Poly::Translate(thePolyTriang, theMap);
aPPonT->myLocation = StdObject_Location::Translate(theLoc, theMap);
return aPPonT;
}

227
src/ShapePersistent/ShapePersistent_BRep.hxx
View File

@ -19,6 +19,7 @@
#include <ShapePersistent_Geom.hxx>
#include <ShapePersistent_Geom2d.hxx>
#include <ShapePersistent_Poly.hxx>
#include <StdObjMgt_TransientPersistentMap.hxx>
#include <StdObject_Location.hxx>
#include <StdObject_gp_Vectors.hxx>
@ -30,20 +31,28 @@
class BRep_PointRepresentation;
class BRep_CurveRepresentation;
class TopoDS_Vertex;
class TopoDS_Edge;
class TopoDS_Face;
class ShapePersistent_BRep : public ShapePersistent_TopoDS
{
public:
class PointRepresentation : public StdObjMgt_Persistent
{
friend class ShapePersistent_BRep;
public:
//! Read persistent data from a file.
Standard_EXPORT virtual void Read (StdObjMgt_ReadData& theReadData);
//! Write persistent data to a file.
Standard_EXPORT virtual void Write(StdObjMgt_WriteData& theWriteData) const;
//! Gets persistent child objects
virtual void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const;
//! Returns persistent type name
virtual Standard_CString PName() const { return "PBRep_PointRepresentation"; }
//! Import transient object from the persistent data.
Standard_EXPORT void Import (BRep_ListOfPointRepresentation& thePoints)
const;
Standard_EXPORT void Import (BRep_ListOfPointRepresentation& thePoints) const;
protected:
virtual Handle(BRep_PointRepresentation) import() const;
@ -58,8 +67,13 @@ public:
class PointOnCurve : public PointRepresentation
{
friend class ShapePersistent_BRep;
public:
virtual void Read (StdObjMgt_ReadData& theReadData);
virtual void Write (StdObjMgt_WriteData& theWriteData) const;
virtual void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const;
virtual Standard_CString PName() const { return "PBRep_PointOnCurve"; }
virtual Handle(BRep_PointRepresentation) import() const;
private:
@ -68,8 +82,13 @@ public:
class PointsOnSurface : public PointRepresentation
{
friend class ShapePersistent_BRep;
public:
virtual void Read (StdObjMgt_ReadData& theReadData);
virtual void Write (StdObjMgt_WriteData& theWriteData) const;
virtual void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const;
virtual Standard_CString PName() const { return "PBRep_PointsOnSurface"; }
protected:
Handle(ShapePersistent_Geom::Surface) mySurface;
@ -77,8 +96,13 @@ public:
class PointOnCurveOnSurface : public PointsOnSurface
{
friend class ShapePersistent_BRep;
public:
virtual void Read (StdObjMgt_ReadData& theReadData);
virtual void Write (StdObjMgt_WriteData& theWriteData) const;
virtual void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const;
virtual Standard_CString PName() const { return "PBRep_PointOnCurveOnSurface"; }
virtual Handle(BRep_PointRepresentation) import() const;
private:
@ -87,8 +111,12 @@ public:
class PointOnSurface : public PointsOnSurface
{
friend class ShapePersistent_BRep;
public:
virtual void Read (StdObjMgt_ReadData& theReadData);
virtual void Write (StdObjMgt_WriteData& theWriteData) const;
virtual Standard_CString PName() const { return "PBRep_PointOnSurface"; }
virtual Handle(BRep_PointRepresentation) import() const;
private:
@ -97,13 +125,19 @@ public:
class CurveRepresentation : public StdObjMgt_Persistent
{
friend class ShapePersistent_BRep;
public:
//! Read persistent data from a file.
Standard_EXPORT virtual void Read (StdObjMgt_ReadData& theReadData);
//! Write persistent data from a file.
Standard_EXPORT virtual void Write (StdObjMgt_WriteData& theWriteData) const;
//! Gets persistent child objects
virtual void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const;
//! Returns persistent type name
virtual Standard_CString PName() const { return "PBRep_CurveRepresentation"; }
//! Import transient object from the persistent data.
Standard_EXPORT void Import (BRep_ListOfCurveRepresentation& theCurves)
const;
Standard_EXPORT void Import (BRep_ListOfCurveRepresentation& theCurves) const;
protected:
virtual Handle(BRep_CurveRepresentation) import() const;
@ -117,8 +151,12 @@ public:
class GCurve : public CurveRepresentation
{
friend class ShapePersistent_BRep;
public:
virtual void Read (StdObjMgt_ReadData& theReadData);
virtual void Write (StdObjMgt_WriteData& theWriteData) const;
virtual Standard_CString PName() const { return "PBRep_GCurve"; }
protected:
Standard_Real myFirst;
@ -127,8 +165,13 @@ public:
class Curve3D : public GCurve
{
friend class ShapePersistent_BRep;
public:
virtual void Read (StdObjMgt_ReadData& theReadData);
virtual void Write (StdObjMgt_WriteData& theWriteData) const;
virtual void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const;
virtual Standard_CString PName() const { return "PBRep_Curve3D"; }
virtual Handle(BRep_CurveRepresentation) import() const;
private:
@ -137,8 +180,13 @@ public:
class CurveOnSurface : public GCurve
{
friend class ShapePersistent_BRep;
public:
virtual void Read (StdObjMgt_ReadData& theReadData);
virtual void Write (StdObjMgt_WriteData& theWriteData) const;
virtual void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const;
virtual Standard_CString PName() const { return "PBRep_CurveOnSurface"; }
virtual Handle(BRep_CurveRepresentation) import() const;
protected:
@ -150,8 +198,13 @@ public:
class CurveOnClosedSurface : public CurveOnSurface
{
friend class ShapePersistent_BRep;
public:
virtual void Read (StdObjMgt_ReadData& theReadData);
virtual void Write (StdObjMgt_WriteData& theWriteData) const;
virtual void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const;
virtual Standard_CString PName() const { return "PBRep_CurveOnClosedSurface"; }
virtual Handle(BRep_CurveRepresentation) import() const;
private:
@ -163,8 +216,13 @@ public:
class Polygon3D : public CurveRepresentation
{
friend class ShapePersistent_BRep;
public:
virtual void Read (StdObjMgt_ReadData& theReadData);
virtual void Write (StdObjMgt_WriteData& theWriteData) const;
virtual void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const;
virtual Standard_CString PName() const { return "PBRep_Polygon3D"; }
virtual Handle(BRep_CurveRepresentation) import() const;
private:
@ -173,8 +231,13 @@ public:
class PolygonOnTriangulation : public CurveRepresentation
{
friend class ShapePersistent_BRep;
public:
virtual void Read (StdObjMgt_ReadData& theReadData);
virtual void Write (StdObjMgt_WriteData& theWriteData) const;
virtual void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const;
virtual Standard_CString PName() const { return "PBRep_PolygonOnTriangulation"; }
virtual Handle(BRep_CurveRepresentation) import() const;
protected:
@ -184,8 +247,13 @@ public:
class PolygonOnClosedTriangulation : public PolygonOnTriangulation
{
friend class ShapePersistent_BRep;
public:
virtual void Read (StdObjMgt_ReadData& theReadData);
virtual void Write (StdObjMgt_WriteData& theWriteData) const;
virtual void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const;
virtual Standard_CString PName() const { return "PBRep_PolygonOnClosedTriangulation"; }
virtual Handle(BRep_CurveRepresentation) import() const;
private:
@ -194,8 +262,13 @@ public:
class PolygonOnSurface : public CurveRepresentation
{
friend class ShapePersistent_BRep;
public:
virtual void Read (StdObjMgt_ReadData& theReadData);
virtual void Write (StdObjMgt_WriteData& theWriteData) const;
virtual void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const;
virtual Standard_CString PName() const { return "PBRep_PolygonOnSurface"; }
virtual Handle(BRep_CurveRepresentation) import() const;
protected:
@ -205,8 +278,13 @@ public:
class PolygonOnClosedSurface : public PolygonOnSurface
{
friend class ShapePersistent_BRep;
public:
virtual void Read (StdObjMgt_ReadData& theReadData);
virtual void Write (StdObjMgt_WriteData& theWriteData) const;
virtual void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const;
virtual Standard_CString PName() const { return "PBRep_PolygonOnClosedSurface"; }
virtual Handle(BRep_CurveRepresentation) import() const;
private:
@ -215,8 +293,13 @@ public:
class CurveOn2Surfaces : public CurveRepresentation
{
friend class ShapePersistent_BRep;
public:
virtual void Read (StdObjMgt_ReadData& theReadData);
virtual void Write (StdObjMgt_WriteData& theWriteData) const;
virtual void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const;
virtual Standard_CString PName() const { return "PBRep_CurveOn2Surfaces"; }
virtual Handle(BRep_CurveRepresentation) import() const;
private:
@ -229,12 +312,26 @@ public:
private:
class pTVertex : public pTBase
{
friend class ShapePersistent_BRep;
public:
inline void Read (StdObjMgt_ReadData& theReadData)
{
pTBase::Read (theReadData);
theReadData >> myTolerance >> myPnt >> myPoints;
}
inline void Write (StdObjMgt_WriteData& theWriteData) const
{
pTBase::Write (theWriteData);
theWriteData << myTolerance << myPnt << myPoints;
}
inline void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
{
pTBase::PChildren(theChildren);
theChildren.Append(myPoints);
}
inline Standard_CString PName() const
{ return "PBRep_TVertex"; }
private:
virtual Handle(TopoDS_TShape) createTShape() const;
@ -247,12 +344,26 @@ private:
class pTEdge : public pTBase
{
friend class ShapePersistent_BRep;
public:
inline void Read (StdObjMgt_ReadData& theReadData)
{
pTBase::Read (theReadData);
theReadData >> myTolerance >> myFlags >> myCurves;
}
inline void Write (StdObjMgt_WriteData& theWriteData) const
{
pTBase::Write (theWriteData);
theWriteData << myTolerance << myFlags << myCurves;
}
inline void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
{
pTBase::PChildren(theChildren);
theChildren.Append(myCurves);
}
inline Standard_CString PName() const
{ return "PBRep_TEdge"; }
private:
virtual Handle(TopoDS_TShape) createTShape() const;
@ -265,6 +376,8 @@ private:
class pTFace : public pTBase
{
friend class ShapePersistent_BRep;
public:
inline void Read (StdObjMgt_ReadData& theReadData)
{
@ -272,6 +385,21 @@ private:
theReadData >> mySurface >> myTriangulation >> myLocation;
theReadData >> myTolerance >> myNaturalRestriction;
}
inline void Write (StdObjMgt_WriteData& theWriteData) const
{
pTBase::Write (theWriteData);
theWriteData << mySurface << myTriangulation << myLocation;
theWriteData << myTolerance << myNaturalRestriction;
}
inline void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
{
pTBase::PChildren(theChildren);
theChildren.Append(mySurface);
theChildren.Append(myTriangulation);
myLocation.PChildren(theChildren);
}
inline Standard_CString PName() const
{ return "PBRep_TFace"; }
private:
virtual Handle(TopoDS_TShape) createTShape() const;
@ -292,6 +420,91 @@ public:
typedef tObject1 <pTVertex> TVertex1;
typedef tObject1 <pTEdge> TEdge1;
typedef tObject1 <pTFace> TFace1;
public:
//! Create a persistent object for a vertex
Standard_EXPORT static Handle(TVertex::pTObjectT) Translate (const TopoDS_Vertex& theVertex,
StdObjMgt_TransientPersistentMap& theMap);
//! Create a persistent object for an edge
Standard_EXPORT static Handle(TEdge::pTObjectT) Translate (const TopoDS_Edge& theEdge,
StdObjMgt_TransientPersistentMap& theMap,
ShapePersistent_TriangleMode theTriangleMode);
//! Create a persistent object for a face
Standard_EXPORT static Handle(TFace::pTObjectT) Translate (const TopoDS_Face& theFace,
StdObjMgt_TransientPersistentMap& theMap,
ShapePersistent_TriangleMode theTriangleMode);
//! Create a persistent object for a point on a 3D curve
Standard_EXPORT static Handle(PointOnCurve) Translate(Standard_Real theParam,
const Handle(Geom_Curve)& theCurve,
const TopLoc_Location& theLoc,
StdObjMgt_TransientPersistentMap& theMap);
//! Create a persistent object for a point on a 3D curve on a surface
Standard_EXPORT static Handle(PointOnCurveOnSurface) Translate (Standard_Real theParam,
const Handle(Geom2d_Curve)& theCurve,
const Handle(Geom_Surface)& theSurf,
const TopLoc_Location& theLoc,
StdObjMgt_TransientPersistentMap& theMap);
//! Create a persistent object for a point on a surface
Standard_EXPORT static Handle(PointOnSurface) Translate (Standard_Real theParam,
Standard_Real theParam2,
const Handle(Geom_Surface)& theSurf,
const TopLoc_Location& theLoc,
StdObjMgt_TransientPersistentMap& theMap);
//! Create a persistent object for a curve on a surface
Standard_EXPORT static Handle(CurveOnSurface) Translate (const Handle(Geom2d_Curve)& theCurve,
const Standard_Real theFirstParam,
const Standard_Real theLastParam,
const Handle(Geom_Surface)& theSurf,
const TopLoc_Location& theLoc,
StdObjMgt_TransientPersistentMap& theMap);
//! Create a persistent object for a curve on a closed surface
Standard_EXPORT static Handle(CurveOnClosedSurface) Translate (const Handle(Geom2d_Curve)& theCurve,
const Handle(Geom2d_Curve)& theCurve2,
const Standard_Real theFirstParam,
const Standard_Real theLastParam,
const Handle(Geom_Surface)& theSurf,
const TopLoc_Location& theLoc,
const GeomAbs_Shape theContinuity,
StdObjMgt_TransientPersistentMap& theMap);
//! Create a persistent object for a curve on two surfaces
Standard_EXPORT static Handle(CurveOn2Surfaces) Translate (const Handle(Geom_Surface)& theSurf,
const Handle(Geom_Surface)& theSurf2,
const TopLoc_Location& theLoc,
const TopLoc_Location& theLoc2,
const GeomAbs_Shape theContinuity,
StdObjMgt_TransientPersistentMap& theMap);
//! Create a persistent object for a 3D curve
Standard_EXPORT static Handle(Curve3D) Translate (const Handle(Geom_Curve)& theCurve,
const Standard_Real theFirstParam,
const Standard_Real theLastParam,
const TopLoc_Location& theLoc,
StdObjMgt_TransientPersistentMap& theMap);
//! Create a persistent object for a 3D polygon
Standard_EXPORT static Handle(Polygon3D) Translate (const Handle(Poly_Polygon3D)& thePoly,
const TopLoc_Location& theLoc,
StdObjMgt_TransientPersistentMap& theMap);
//! Create a persistent object for a polygon on a closed surface
Standard_EXPORT static Handle(PolygonOnClosedSurface) Translate (const Handle(Poly_Polygon2D)& thePoly,
const Handle(Poly_Polygon2D)& thePoly2,
const Handle(Geom_Surface)& theSurf,
const TopLoc_Location& theLoc,
StdObjMgt_TransientPersistentMap& theMap);
//! Create a persistent object for a polygon on a surface
Standard_EXPORT static Handle(PolygonOnSurface) Translate (const Handle(Poly_Polygon2D)& thePoly,
const Handle(Geom_Surface)& theSurf,
const TopLoc_Location& theLoc,
StdObjMgt_TransientPersistentMap& theMap);
//! Create a persistent object for a polygon on a surface
Standard_EXPORT static Handle(PolygonOnClosedTriangulation) Translate (const Handle(Poly_PolygonOnTriangulation)& thePolyOnTriang,
const Handle(Poly_PolygonOnTriangulation)& thePolyOnTriang2,
const Handle(Poly_Triangulation)& thePolyTriang,
const TopLoc_Location& theLoc,
StdObjMgt_TransientPersistentMap& theMap);
//! Create a persistent object for a polygon on a surface
Standard_EXPORT static Handle(PolygonOnTriangulation) Translate (const Handle(Poly_PolygonOnTriangulation)& thePolyOnTriang,
const Handle(Poly_Triangulation)& thePolyTriang,
const TopLoc_Location& theLoc,
StdObjMgt_TransientPersistentMap& theMap);
};
#endif

137
src/ShapePersistent/ShapePersistent_Geom.cxx
View File

@ -11,7 +11,11 @@
// 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>
@ -23,20 +27,125 @@
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;
myTransient = new Geom_Axis2Placement (anAxis.Location(),
anAxis.Direction(),
anXDirection);
//=======================================================================
//function : PChildren
//purpose : Gets persistent objects
//=======================================================================
void ShapePersistent_Geom::Geometry::PChildren (SequenceOfPersistent&) const
{
}
//=======================================================================
//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;
}

280
src/ShapePersistent/ShapePersistent_Geom.hxx
View File

@ -15,7 +15,12 @@
#ifndef _ShapePersistent_Geom_HeaderFile
#define _ShapePersistent_Geom_HeaderFile
#include <Standard_NotImplemented.hxx>
#include <Standard_NullObject.hxx>
#include <StdObjMgt_WriteData.hxx>
#include <StdObjMgt_SharedObject.hxx>
#include <StdObjMgt_TransientPersistentMap.hxx>
#include <StdObject_gp_Vectors.hxx>
#include <StdObject_gp_Axes.hxx>
@ -32,8 +37,7 @@
#include <Geom_Curve.hxx>
#include <Geom_Surface.hxx>
class ShapePersistent_Geom : protected StdObjMgt_SharedObject
class ShapePersistent_Geom : public StdObjMgt_SharedObject
{
public:
class Geometry : public StdObjMgt_Persistent
@ -41,11 +45,32 @@ public:
public:
//! Read persistent data from a file.
Standard_EXPORT virtual void Read (StdObjMgt_ReadData& theReadData);
//! Write persistent data to a file.
Standard_EXPORT virtual void Write (StdObjMgt_WriteData& theWriteData) const;
//! Gets persistent objects
Standard_EXPORT virtual void PChildren(SequenceOfPersistent& theChildren) const;
//! Returns persistent type name
Standard_EXPORT virtual Standard_CString PName() const { return "PGeom_Geometry"; }
};
protected:
template <class Transient>
struct geometryBase : DelayedBase<Geometry, Transient> {};
struct geometryBase : public DelayedBase<Geometry, Transient>
{
//! Write persistent data to a file.
Standard_EXPORT virtual void Write (StdObjMgt_WriteData&) const
{
Standard_NotImplemented::Raise("ShapePersistent_Geom::geometryBase::Write - not implemented");
}
//! Gets persistent child objects
Standard_EXPORT virtual void PChildren (StdObjMgt_Persistent::SequenceOfPersistent&) const { }
//! Returns persistent type name
Standard_EXPORT virtual Standard_CString PName() const
{
Standard_NotImplemented::Raise("ShapePersistent_Geom::geometryBase::PName - not implemented");
return "";
}
};
template <class Base, class PData>
class subBase : public Base
@ -54,6 +79,20 @@ protected:
//! Read persistent data from a file.
Standard_EXPORT virtual void Read (StdObjMgt_ReadData& theReadData)
{ PData().Read (theReadData); }
//! Write persistent data to a file.
Standard_EXPORT virtual void Write (StdObjMgt_WriteData& theWriteData) const
{ PData().Write(theWriteData); }
//! Gets persistent child objects
Standard_EXPORT virtual void PChildren (StdObjMgt_Persistent::SequenceOfPersistent&) const
{
Standard_NotImplemented::Raise("ShapePersistent_Geom::subBase::PChildren - not implemented");
}
//! Returns persistent type name
Standard_EXPORT virtual Standard_CString PName() const
{
Standard_NotImplemented::Raise("ShapePersistent_Geom::subBase::PName - not implemented");
return "";
}
};
template <class Base, class GpData>
@ -61,15 +100,29 @@ protected:
{
public:
//! Read persistent data from a file.
Standard_EXPORT virtual void Read (StdObjMgt_ReadData& theReadData)
Standard_EXPORT virtual void Read (StdObjMgt_ReadData&) { }
//! Write persistent data to a file.
Standard_EXPORT virtual void Write (StdObjMgt_WriteData&) const { }
//! Gets persistent child objects
Standard_EXPORT virtual void PChildren (StdObjMgt_Persistent::SequenceOfPersistent&) const { }
//! Returns persistent type name
Standard_EXPORT virtual Standard_CString PName() const
{
GpData aData;
theReadData >> aData;
Standard_NotImplemented::Raise("ShapePersistent_Geom::subBase_gp::PName - not implemented");
return "";
}
};
template <class Base>
struct subBase_empty : Base {};
struct subBase_empty : Base
{
//! Returns persistent type name
Standard_EXPORT virtual Standard_CString PName() const
{
Standard_NotImplemented::Raise("ShapePersistent_Geom::subBase_empty::PName - not implemented");
return "";
}
};
template <class Base, class Target, class Data = void>
class instance : public Base
@ -80,7 +133,20 @@ protected:
{
Data aData;
theReadData >> aData;
this->myTransient = new Target (aData);
this->myTransient = new Target(aData);
}
//! Gets persistent child objects
Standard_EXPORT virtual void PChildren(StdObjMgt_Persistent::SequenceOfPersistent&) const { }
//! Write persistent data to a file.
Standard_EXPORT virtual void Write(StdObjMgt_WriteData&) const
{
Standard_NotImplemented::Raise("ShapePersistent_Geom::instance::Write - not implemented");
}
//! Returns persistent type name
Standard_EXPORT virtual Standard_CString PName() const
{
Standard_NotImplemented::Raise("ShapePersistent_Geom::instance::PName - not implemented");
return "";
}
};
@ -105,11 +171,203 @@ public:
typedef geometryBase<Geom_Curve> Curve;
typedef geometryBase<Geom_Surface> Surface;
public:
//! Create a persistent object for a curve
Standard_EXPORT static Handle(Curve) Translate (const Handle(Geom_Curve)& theCurve,
StdObjMgt_TransientPersistentMap& theMap);
//! Create a persistent object for a curve
Standard_EXPORT static Handle(Surface) Translate (const Handle(Geom_Surface)& theSurf,
StdObjMgt_TransientPersistentMap& theMap);
};
//=======================================================================
// Point
//=======================================================================
template<>
void ShapePersistent_Geom::instance<ShapePersistent_Geom::AxisPlacement,
Geom_Axis2Placement>
::Read (StdObjMgt_ReadData& theReadData);
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<>
inline Standard_CString ShapePersistent_Geom::geometryBase<Geom_Surface>
::PName() const { return "PGeom_Surface"; }
#endif

185
src/ShapePersistent/ShapePersistent_Geom2d.cxx Normal file
View File

@ -0,0 +1,185 @@
#include <Standard_NullObject.hxx>
#include <ShapePersistent_Geom2d.hxx>
#include <ShapePersistent_Geom2d_Curve.hxx>
#include <Geom2d_BezierCurve.hxx>
#include <Geom2d_BSplineCurve.hxx>
#include <Geom2d_TrimmedCurve.hxx>
#include <Geom2d_OffsetCurve.hxx>
//=======================================================================
// Geometry
//=======================================================================
template<>
Standard_CString ShapePersistent_Geom::geometryBase<Geom2d_Geometry>
::PName() const { return "PGeom2d_Geometry"; }
//=======================================================================
// Point
//=======================================================================
template<>
Standard_CString ShapePersistent_Geom::subBase_empty<ShapePersistent_Geom2d::geometryBase<Geom2d_Geometry> >
::PName() const { return "PGeom2d_Point"; }
//=======================================================================
// CartesianPoint
//=======================================================================
template<>
Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom2d::Point,
Geom2d_CartesianPoint,
gp_Pnt2d>
::PName() const { return "PGeom2d_CartesianPoint"; }
template<>
void ShapePersistent_Geom::instance<ShapePersistent_Geom2d::Point,
Geom2d_CartesianPoint,
gp_Pnt2d>
::Write(StdObjMgt_WriteData& theWriteData) const
{
Handle(Geom2d_CartesianPoint) aMyGeom =
Handle(Geom2d_CartesianPoint)::DownCast(myTransient);
theWriteData << aMyGeom->Pnt2d();
}
//=======================================================================
// Direction
//=======================================================================
template<>
Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom2d::Direction,
Geom2d_Direction,
gp_Dir2d>
::PName() const { return "PGeom2d_Direction"; }
template<>
void ShapePersistent_Geom::instance<ShapePersistent_Geom2d::Direction,
Geom2d_Direction,
gp_Dir2d>
::Write(StdObjMgt_WriteData& theWriteData) const
{
Handle(Geom2d_Direction) aMyGeom =
Handle(Geom2d_Direction)::DownCast(myTransient);
theWriteData << aMyGeom->Dir2d();
}
//=======================================================================
// VectorWithMagnitude
//=======================================================================
template<>
Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom2d::VectorWithMagnitude,
Geom2d_VectorWithMagnitude,
gp_Vec2d>
::PName() const { return "PGeom2d_VectorWithMagnitude"; }
template<>
void ShapePersistent_Geom::instance<ShapePersistent_Geom2d::VectorWithMagnitude,
Geom2d_VectorWithMagnitude,
gp_Vec2d>
::Write(StdObjMgt_WriteData& theWriteData) const
{
Handle(Geom2d_VectorWithMagnitude) aMyGeom =
Handle(Geom2d_VectorWithMagnitude)::DownCast(myTransient);
theWriteData << aMyGeom->Vec2d();
}
//=======================================================================
// AxisPlacement
//=======================================================================
template<>
Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom2d::AxisPlacement,
Geom2d_AxisPlacement,
gp_Ax2d>
::PName() const { return "PGeom2d_AxisPlacement"; }
template<>
void ShapePersistent_Geom::instance<ShapePersistent_Geom2d::AxisPlacement,
Geom2d_AxisPlacement,
gp_Ax2d>
::Write(StdObjMgt_WriteData& theWriteData) const
{
Handle(Geom2d_AxisPlacement) aMyGeom =
Handle(Geom2d_AxisPlacement)::DownCast(myTransient);
write(theWriteData, aMyGeom->Ax2d());
}
//=======================================================================
// Transformation
//=======================================================================
template<>
Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom2d::Transformation,
Geom2d_Transformation,
gp_Trsf2d>
::PName() const { return "PGeom2d_Transformation"; }
template<>
void ShapePersistent_Geom::instance<ShapePersistent_Geom2d::Transformation,
Geom2d_Transformation,
gp_Trsf2d>
::PChildren(StdObjMgt_Persistent::SequenceOfPersistent&) const
{
}
template<>
void ShapePersistent_Geom2d::instance<ShapePersistent_Geom2d::Transformation,
Geom2d_Transformation,
gp_Trsf2d>
::Write(StdObjMgt_WriteData& theWriteData) const
{
theWriteData << myTransient->Trsf2d();
}
//=======================================================================
// Curve
//=======================================================================
template<>
Standard_CString ShapePersistent_Geom::geometryBase<Geom2d_Curve>
::PName() const { return "PGeom2d_Curve"; }
Handle(ShapePersistent_Geom2d::Curve)
ShapePersistent_Geom2d::Translate(const Handle(Geom2d_Curve)& theCurve,
StdObjMgt_TransientPersistentMap& theMap)
{
Handle(ShapePersistent_Geom2d::Curve) aPC;
if (!theCurve.IsNull())
{
if (theMap.IsBound(theCurve))
aPC = Handle(ShapePersistent_Geom2d::Curve)::DownCast(theMap.Find(theCurve));
else
{
Handle(Standard_Type) aCT = theCurve->DynamicType();
if (aCT == STANDARD_TYPE(Geom2d_Line)) {
aPC = ShapePersistent_Geom2d_Curve::Translate(Handle(Geom2d_Line)::DownCast(theCurve), theMap);
}
else if (aCT == STANDARD_TYPE(Geom2d_Circle)) {
aPC = ShapePersistent_Geom2d_Curve::Translate(Handle(Geom2d_Circle)::DownCast(theCurve), theMap);
}
else if (aCT == STANDARD_TYPE(Geom2d_Ellipse)) {
aPC = ShapePersistent_Geom2d_Curve::Translate(Handle(Geom2d_Ellipse)::DownCast(theCurve), theMap);
}
else if (aCT == STANDARD_TYPE(Geom2d_Hyperbola)) {
aPC = ShapePersistent_Geom2d_Curve::Translate(Handle(Geom2d_Hyperbola)::DownCast(theCurve), theMap);
}
else if (aCT == STANDARD_TYPE(Geom2d_Parabola)) {
aPC = ShapePersistent_Geom2d_Curve::Translate(Handle(Geom2d_Parabola)::DownCast(theCurve), theMap);
}
else if (aCT == STANDARD_TYPE(Geom2d_BezierCurve)) {
aPC = ShapePersistent_Geom2d_Curve::Translate(Handle(Geom2d_BezierCurve)::DownCast(theCurve), theMap);
}
else if (aCT == STANDARD_TYPE(Geom2d_BSplineCurve)) {
aPC = ShapePersistent_Geom2d_Curve::Translate(Handle(Geom2d_BSplineCurve)::DownCast(theCurve), theMap);
}
else if (aCT == STANDARD_TYPE(Geom2d_TrimmedCurve)) {
aPC = ShapePersistent_Geom2d_Curve::Translate(Handle(Geom2d_TrimmedCurve)::DownCast(theCurve), theMap);
}
else if (aCT == STANDARD_TYPE(Geom2d_OffsetCurve)) {
aPC = ShapePersistent_Geom2d_Curve::Translate(Handle(Geom2d_OffsetCurve)::DownCast(theCurve), theMap);
}
else {
Standard_NullObject::Raise("No mapping for the current Transient Curve");
}
theMap.Bind(theCurve, aPC);
}
}
return aPC;
}

112
src/ShapePersistent/ShapePersistent_Geom2d.hxx
View File

@ -15,6 +15,7 @@
#ifndef _ShapePersistent_Geom2d_HeaderFile
#define _ShapePersistent_Geom2d_HeaderFile
#include <StdObjMgt_TransientPersistentMap.hxx>
#include <ShapePersistent_Geom.hxx>
#include <Geom2d_CartesianPoint.hxx>
@ -24,8 +25,7 @@
#include <Geom2d_Transformation.hxx>
#include <Geom2d_Curve.hxx>
class ShapePersistent_Geom2d : protected ShapePersistent_Geom
class ShapePersistent_Geom2d : public ShapePersistent_Geom
{
typedef geometryBase<Geom2d_Geometry> basic;
@ -46,6 +46,114 @@ public:
gp_Trsf2d> Transformation;
typedef geometryBase<Geom2d_Curve> Curve;
public:
//! Create a persistent object for a curve
Standard_EXPORT static Handle(Curve) Translate (const Handle(Geom2d_Curve)& theCurve,
StdObjMgt_TransientPersistentMap& theMap);
};
//=======================================================================
// Geometry
//=======================================================================
template<>
Standard_CString ShapePersistent_Geom::geometryBase<Geom2d_Geometry>
::PName() const;
//=======================================================================
// Point
//=======================================================================
template<>
Standard_CString ShapePersistent_Geom::subBase_empty<
ShapePersistent_Geom2d::geometryBase<Geom2d_Geometry> >
::PName() const;
//=======================================================================
// CartesianPoint
//=======================================================================
template<>
Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom2d::Point,
Geom2d_CartesianPoint,
gp_Pnt2d>
::PName() const;
template<>
void ShapePersistent_Geom::instance<ShapePersistent_Geom2d::Point,
Geom2d_CartesianPoint,
gp_Pnt2d>
::Write(StdObjMgt_WriteData& theWriteData) const;
//=======================================================================
// Direction
//=======================================================================
template<>
Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom2d::Direction,
Geom2d_Direction,
gp_Dir2d>
::PName() const;
template<>
void ShapePersistent_Geom::instance<ShapePersistent_Geom2d::Direction,
Geom2d_Direction,
gp_Dir2d>
::Write(StdObjMgt_WriteData& theWriteData) const;
//=======================================================================
// VectorWithMagnitude
//=======================================================================
template<>
Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom2d::VectorWithMagnitude,
Geom2d_VectorWithMagnitude,
gp_Vec2d>
::PName() const;
template<>
void ShapePersistent_Geom::instance<ShapePersistent_Geom2d::VectorWithMagnitude,
Geom2d_VectorWithMagnitude,
gp_Vec2d>
::Write(StdObjMgt_WriteData& theWriteData) const;
//=======================================================================
// AxisPlacement
//=======================================================================
template<>
Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom2d::AxisPlacement,
Geom2d_AxisPlacement,
gp_Ax2d>
::PName() const;
template<>
void ShapePersistent_Geom::instance<ShapePersistent_Geom2d::AxisPlacement,
Geom2d_AxisPlacement,
gp_Ax2d>
::Write(StdObjMgt_WriteData& theWriteData) const;
//=======================================================================
// Transformation
//=======================================================================
template<>
Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom2d::Transformation,
Geom2d_Transformation,
gp_Trsf2d>
::PName() const;
template<>
void ShapePersistent_Geom::instance<ShapePersistent_Geom2d::Transformation,
Geom2d_Transformation,
gp_Trsf2d>
::PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const;
template<>
void ShapePersistent_Geom::instance<ShapePersistent_Geom2d::Transformation,
Geom2d_Transformation,
gp_Trsf2d>
::Write(StdObjMgt_WriteData& theWriteData) const;
//=======================================================================
// Curve
//=======================================================================
template<>
Standard_CString ShapePersistent_Geom2d::geometryBase<Geom2d_Curve>
::PName() const;
#endif

307
src/ShapePersistent/ShapePersistent_Geom2d_Curve.cxx
View File

@ -11,6 +11,8 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Standard_NullObject.hxx>
#include <ShapePersistent_Geom2d_Curve.hxx>
#include <Geom2d_BezierCurve.hxx>
@ -74,3 +76,308 @@ Handle(Geom2d_Curve) ShapePersistent_Geom2d_Curve::pOffset::Import() const
return new Geom2d_OffsetCurve (myBasisCurve->Import(), myOffsetValue);
}
//=======================================================================
// Line
//=======================================================================
template<>
Standard_CString ShapePersistent_Geom2d_Curve::instance<ShapePersistent_Geom2d::Curve,
Geom2d_Line,
gp_Ax2d>
::PName() const { return "PGeom2d_Line"; }
template<>
void ShapePersistent_Geom2d_Curve::instance<ShapePersistent_Geom2d::Curve,
Geom2d_Line,
gp_Ax2d>
::Write(StdObjMgt_WriteData& theWriteData) const
{
Handle(Geom2d_Line) aMyGeom =
Handle(Geom2d_Line)::DownCast(myTransient);
write(theWriteData, aMyGeom->Position());
}
Handle(ShapePersistent_Geom2d::Curve)
ShapePersistent_Geom2d_Curve::Translate(const Handle(Geom2d_Line)& theCurve,
StdObjMgt_TransientPersistentMap& theMap)
{
Handle(ShapePersistent_Geom2d::Curve) aPC;
if (!theCurve.IsNull())
{
if (theMap.IsBound(theCurve))
aPC = Handle(ShapePersistent_Geom2d::Curve)::DownCast(theMap.Find(theCurve));
else {
Handle(Line) aPT = new Line;
aPT->myTransient = theCurve;
aPC = aPT;
}
}
return aPC;
}
//=======================================================================
// Conic
//=======================================================================
template<>
Standard_CString ShapePersistent_Geom2d_Curve::subBase_gp<ShapePersistent_Geom2d::Curve,
gp_Ax22d>
::PName() const { return "PGeom2d_Conic"; }
//=======================================================================
// Circle
//=======================================================================
template<>
Standard_CString ShapePersistent_Geom2d_Curve::instance<ShapePersistent_Geom2d_Curve::Conic,
Geom2d_Circle,
gp_Circ2d>
::PName() const { return "PGeom2d_Circle"; }
template<>
void ShapePersistent_Geom2d_Curve::instance<ShapePersistent_Geom2d_Curve::Conic,
Geom2d_Circle,
gp_Circ2d>
::Write(StdObjMgt_WriteData& theWriteData) const
{
Handle(Geom2d_Circle) aMyGeom =
Handle(Geom2d_Circle)::DownCast(myTransient);
theWriteData << aMyGeom->Circ2d();
}
Handle(ShapePersistent_Geom2d::Curve)
ShapePersistent_Geom2d_Curve::Translate(const Handle(Geom2d_Circle)& theCurve,
StdObjMgt_TransientPersistentMap& theMap)
{
Handle(ShapePersistent_Geom2d::Curve) aPC;
if (!theCurve.IsNull())
{
if (theMap.IsBound(theCurve))
aPC = Handle(ShapePersistent_Geom2d::Curve)::DownCast(theMap.Find(theCurve));
else {
Handle(Circle) aPT = new Circle;
aPT->myTransient = theCurve;
aPC = aPT;
}
}
return aPC;
}
//=======================================================================
// Ellipse
//=======================================================================
template<>
Standard_CString ShapePersistent_Geom2d_Curve::instance<ShapePersistent_Geom2d_Curve::Conic,
Geom2d_Ellipse,
gp_Elips2d>
::PName() const { return "PGeom2d_Ellipse"; }
template<>
void ShapePersistent_Geom2d_Curve::instance<ShapePersistent_Geom2d_Curve::Conic,
Geom2d_Ellipse,
gp_Elips2d>
::Write(StdObjMgt_WriteData& theWriteData) const
{
Handle(Geom2d_Ellipse) aMyGeom =
Handle(Geom2d_Ellipse)::DownCast(myTransient);
theWriteData << aMyGeom->Elips2d();
}
Handle(ShapePersistent_Geom2d::Curve)
ShapePersistent_Geom2d_Curve::Translate(const Handle(Geom2d_Ellipse)& theCurve,
StdObjMgt_TransientPersistentMap& theMap)
{
Handle(ShapePersistent_Geom2d::Curve) aPC;
if (!theCurve.IsNull())
{
if (theMap.IsBound(theCurve))
aPC = Handle(ShapePersistent_Geom2d::Curve)::DownCast(theMap.Find(theCurve));
else {
Handle(Ellipse) aPT = new Ellipse;
aPT->myTransient = theCurve;
aPC = aPT;
}
}
return aPC;
}
//=======================================================================
// Hyperbola
//=======================================================================
template<>
Standard_CString ShapePersistent_Geom2d_Curve::instance<ShapePersistent_Geom2d_Curve::Conic,
Geom2d_Hyperbola,
gp_Hypr2d>
::PName() const { return "PGeom2d_Hyperbola"; }
template<>
void ShapePersistent_Geom2d_Curve::instance<ShapePersistent_Geom2d_Curve::Conic,
Geom2d_Hyperbola,
gp_Hypr2d>
::Write(StdObjMgt_WriteData& theWriteData) const
{
Handle(Geom2d_Hyperbola) aMyGeom =
Handle(Geom2d_Hyperbola)::DownCast(myTransient);
theWriteData << aMyGeom->Hypr2d();
}
Handle(ShapePersistent_Geom2d::Curve)
ShapePersistent_Geom2d_Curve::Translate(const Handle(Geom2d_Hyperbola)& theCurve,
StdObjMgt_TransientPersistentMap& theMap)
{
Handle(ShapePersistent_Geom2d::Curve) aPC;
if (!theCurve.IsNull())
{
if (theMap.IsBound(theCurve))
aPC = Handle(ShapePersistent_Geom2d::Curve)::DownCast(theMap.Find(theCurve));
else {
Handle(Hyperbola) aPT = new Hyperbola;
aPT->myTransient = theCurve;
aPC = aPT;
}
}
return aPC;
}
//=======================================================================
// Parabola
//=======================================================================
template<>
Standard_CString ShapePersistent_Geom2d_Curve::instance<ShapePersistent_Geom2d_Curve::Conic,
Geom2d_Parabola,
gp_Parab2d>
::PName() const { return "PGeom2d_Hyperbola"; }
template<>
void ShapePersistent_Geom2d_Curve::instance<ShapePersistent_Geom2d_Curve::Conic,
Geom2d_Parabola,
gp_Parab2d>
::Write(StdObjMgt_WriteData& theWriteData) const
{
Handle(Geom2d_Parabola) aMyGeom =
Handle(Geom2d_Parabola)::DownCast(myTransient);
theWriteData << aMyGeom->Parab2d();
}
Handle(ShapePersistent_Geom2d::Curve)
ShapePersistent_Geom2d_Curve::Translate(const Handle(Geom2d_Parabola)& theCurve,
StdObjMgt_TransientPersistentMap& theMap)
{
Handle(ShapePersistent_Geom2d::Curve) aPC;
if (!theCurve.IsNull())
{
if (theMap.IsBound(theCurve))
aPC = Handle(ShapePersistent_Geom2d::Curve)::DownCast(theMap.Find(theCurve));
else {
Handle(Parabola) aPT = new Parabola;
aPT->myTransient = theCurve;
aPC = aPT;
}
}
return aPC;
}
//=======================================================================
// BezierCurve
//=======================================================================
Handle(ShapePersistent_Geom2d::Curve)
ShapePersistent_Geom2d_Curve::Translate(const Handle(Geom2d_BezierCurve)& theCurve,
StdObjMgt_TransientPersistentMap& theMap)
{
Handle(ShapePersistent_Geom2d::Curve) aPC;
if (!theCurve.IsNull())
{
if (theMap.IsBound(theCurve))
aPC = Handle(ShapePersistent_Geom2d::Curve)::DownCast(theMap.Find(theCurve));
else {
Handle(Bezier) aPBC = new Bezier;
Handle(pBezier) aPpBC = new pBezier;
aPpBC->myRational = theCurve->IsRational();
aPpBC->myPoles = StdLPersistent_HArray1::Translate<TColgp_HArray1OfPnt2d>("PColgp_HArray1OfPnt2d", theCurve->Poles());
if (theCurve->IsRational()) {
aPpBC->myWeights = StdLPersistent_HArray1::Translate<TColStd_HArray1OfReal>(*theCurve->Weights());
}
aPBC->myPersistent = aPpBC;
aPC = aPBC;
}
}
return aPC;
}
//=======================================================================
// BSplineCurve
//=======================================================================
Handle(ShapePersistent_Geom2d::Curve)
ShapePersistent_Geom2d_Curve::Translate(const Handle(Geom2d_BSplineCurve)& theCurve,
StdObjMgt_TransientPersistentMap& theMap)
{
Handle(ShapePersistent_Geom2d::Curve) aPC;
if (!theCurve.IsNull())
{
if (theMap.IsBound(theCurve))
aPC = Handle(ShapePersistent_Geom2d::Curve)::DownCast(theMap.Find(theCurve));
else {
Handle(BSpline) aPBSC = new BSpline;
Handle(pBSpline) aPpBSC = new pBSpline;
aPpBSC->myRational = theCurve->IsRational();
aPpBSC->myPeriodic = theCurve->IsPeriodic();
aPpBSC->mySpineDegree = theCurve->Degree();
aPpBSC->myPoles = StdLPersistent_HArray1::Translate<TColgp_HArray1OfPnt2d>("PColgp_HArray1OfPnt2d", theCurve->Poles());
if (theCurve->IsRational()) {
aPpBSC->myWeights = StdLPersistent_HArray1::Translate<TColStd_HArray1OfReal>(*theCurve->Weights());
}
aPpBSC->myKnots = StdLPersistent_HArray1::Translate<TColStd_HArray1OfReal>(theCurve->Knots());
aPpBSC->myMultiplicities = StdLPersistent_HArray1::Translate<TColStd_HArray1OfInteger>(theCurve->Multiplicities());
aPBSC->myPersistent = aPpBSC;
aPC = aPBSC;
}
}
return aPC;
}
//=======================================================================
// TrimmedCurve
//=======================================================================
Handle(ShapePersistent_Geom2d::Curve)
ShapePersistent_Geom2d_Curve::Translate(const Handle(Geom2d_TrimmedCurve)& theCurve,
StdObjMgt_TransientPersistentMap& theMap)
{
Handle(ShapePersistent_Geom2d::Curve) aPC = new Trimmed;
if (!theCurve.IsNull())
{
if (theMap.IsBound(theCurve))
aPC = Handle(ShapePersistent_Geom2d::Curve)::DownCast(theMap.Find(theCurve));
else {
Handle(Trimmed) aPTC = new Trimmed;
Handle(pTrimmed) aPpTC = new pTrimmed;
aPpTC->myFirstU = theCurve->FirstParameter();
aPpTC->myLastU = theCurve->LastParameter();
aPpTC->myBasisCurve = ShapePersistent_Geom2d::Translate(theCurve->BasisCurve(), theMap);
aPTC->myPersistent = aPpTC;
aPC = aPTC;
}
}
return aPC;
}
//=======================================================================
// OffsetCurve
//=======================================================================
Handle(ShapePersistent_Geom2d::Curve)
ShapePersistent_Geom2d_Curve::Translate(const Handle(Geom2d_OffsetCurve)& theCurve,
StdObjMgt_TransientPersistentMap& theMap)
{
Handle(ShapePersistent_Geom2d::Curve) aPC = new Offset;
if (!theCurve.IsNull())
{
if (theMap.IsBound(theCurve))
aPC = Handle(ShapePersistent_Geom2d::Curve)::DownCast(theMap.Find(theCurve));
else {
Handle(Offset) aPOC = new Offset;
Handle(pOffset) aPpOC = new pOffset;
aPpOC->myOffsetValue = theCurve->Offset();
aPpOC->myBasisCurve = ShapePersistent_Geom2d::Translate(theCurve->BasisCurve(), theMap);
aPOC->myPersistent = aPpOC;
aPC = aPOC;
}
}
return aPC;
}

163
src/ShapePersistent/ShapePersistent_Geom2d_Curve.hxx
View File

@ -15,6 +15,8 @@
#ifndef _ShapePersistent_Geom2d_Curve_HeaderFile
#define _ShapePersistent_Geom2d_Curve_HeaderFile
#include <StdObjMgt_TransientPersistentMap.hxx>
#include <ShapePersistent_Geom2d.hxx>
#include <ShapePersistent_HArray1.hxx>
#include <StdLPersistent_HArray1.hxx>
@ -24,6 +26,10 @@
#include <Geom2d_Ellipse.hxx>
#include <Geom2d_Hyperbola.hxx>
#include <Geom2d_Parabola.hxx>
#include <Geom2d_BezierCurve.hxx>
#include <Geom2d_BSplineCurve.hxx>
#include <Geom2d_TrimmedCurve.hxx>
#include <Geom2d_OffsetCurve.hxx>
#include <gp_Circ2d.hxx>
#include <gp_Elips2d.hxx>
@ -31,7 +37,7 @@
#include <gp_Parab2d.hxx>
class ShapePersistent_Geom2d_Curve : protected ShapePersistent_Geom2d
class ShapePersistent_Geom2d_Curve : public ShapePersistent_Geom2d
{
typedef Curve::PersistentBase pBase;
@ -39,9 +45,20 @@ class ShapePersistent_Geom2d_Curve : protected ShapePersistent_Geom2d
class pBezier : public pBounded
{
friend class ShapePersistent_Geom2d_Curve;
public:
inline void Read (StdObjMgt_ReadData& theReadData)
{ theReadData >> myRational >> myPoles >> myWeights; }
inline void Write (StdObjMgt_WriteData& theWriteData) const
{ theWriteData << myRational << myPoles << myWeights; }
inline void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
{
theChildren.Append(myPoles);
theChildren.Append(myWeights);
}
inline Standard_CString PName() const
{ return "PGeom2d_BezierCurve"; }
virtual Handle(Geom2d_Curve) Import() const;
@ -53,12 +70,28 @@ class ShapePersistent_Geom2d_Curve : protected ShapePersistent_Geom2d
class pBSpline : public pBounded
{
friend class ShapePersistent_Geom2d_Curve;
public:
inline void Read (StdObjMgt_ReadData& theReadData)
{
theReadData >> myRational >> myPeriodic >> mySpineDegree;
theReadData >> myPoles >> myWeights >> myKnots >> myMultiplicities;
}
inline void Write (StdObjMgt_WriteData& theWriteData) const
{
theWriteData << myRational << myPeriodic << mySpineDegree;
theWriteData << myPoles << myWeights << myKnots << myMultiplicities;
}
inline void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
{
theChildren.Append(myPoles);
theChildren.Append(myWeights);
theChildren.Append(myKnots);
theChildren.Append(myMultiplicities);
}
inline Standard_CString PName() const
{ return "PGeom2d_BSplineCurve"; }
virtual Handle(Geom2d_Curve) Import() const;
@ -74,9 +107,17 @@ class ShapePersistent_Geom2d_Curve : protected ShapePersistent_Geom2d
class pTrimmed : public pBounded
{
friend class ShapePersistent_Geom2d_Curve;
public:
inline void Read (StdObjMgt_ReadData& theReadData)
{ theReadData >> myBasisCurve >> myFirstU >> myLastU; }
inline void Write (StdObjMgt_WriteData& theWriteData) const
{ theWriteData << myBasisCurve << myFirstU << myLastU; }
inline void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
{ theChildren.Append(myBasisCurve); }
inline Standard_CString PName() const
{ return "PGeom2d_TrimmedCurve"; }
virtual Handle(Geom2d_Curve) Import() const;
@ -88,9 +129,17 @@ class ShapePersistent_Geom2d_Curve : protected ShapePersistent_Geom2d
class pOffset : public pBase
{
friend class ShapePersistent_Geom2d_Curve;
public:
inline void Read (StdObjMgt_ReadData& theReadData)
{ theReadData >> myBasisCurve >> myOffsetValue; }
inline void Write (StdObjMgt_WriteData& theWriteData) const
{ theWriteData << myBasisCurve << myOffsetValue; }
inline void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
{ theChildren.Append(myBasisCurve); }
inline Standard_CString PName() const
{ return "PGeom2d_OffsetCurve"; }
virtual Handle(Geom2d_Curve) Import() const;
@ -114,6 +163,118 @@ public:
typedef Delayed<Bounded, pTrimmed> Trimmed;
typedef Delayed<Curve, pOffset> Offset;
public:
//! Create a persistent object for a line
Standard_EXPORT static Handle(Curve) Translate (const Handle(Geom2d_Line)& theCurve,
StdObjMgt_TransientPersistentMap& theMap);
//! Create a persistent object for a circle
Standard_EXPORT static Handle(Curve) Translate (const Handle(Geom2d_Circle)& theCurve,
StdObjMgt_TransientPersistentMap& theMap);
//! Create a persistent object for a ellipse
Standard_EXPORT static Handle(Curve) Translate (const Handle(Geom2d_Ellipse)& theCurve,
StdObjMgt_TransientPersistentMap& theMap);
//! Create a persistent object for a hyperbola
Standard_EXPORT static Handle(Curve) Translate (const Handle(Geom2d_Hyperbola)& theCurve,
StdObjMgt_TransientPersistentMap& theMap);
//! Create a persistent object for a parabola
Standard_EXPORT static Handle(Curve) Translate (const Handle(Geom2d_Parabola)& theCurve,
StdObjMgt_TransientPersistentMap& theMap);
//! Create a persistent object for a Bezier curve
Standard_EXPORT static Handle(Curve) Translate (const Handle(Geom2d_BezierCurve)& theCurve,
StdObjMgt_TransientPersistentMap& theMap);
//! Create a persistent object for a BSpline curve
Standard_EXPORT static Handle(Curve) Translate (const Handle(Geom2d_BSplineCurve)& theCurve,
StdObjMgt_TransientPersistentMap& theMap);
//! Create a persistent object for a trimmed curve
Standard_EXPORT static Handle(Curve) Translate (const Handle(Geom2d_TrimmedCurve)& theCurve,
StdObjMgt_TransientPersistentMap& theMap);
//! Create a persistent object for an offset curve
Standard_EXPORT static Handle(Curve) Translate (const Handle(Geom2d_OffsetCurve)& theCurve,
StdObjMgt_TransientPersistentMap& theMap);
};
//=======================================================================
// Line
//=======================================================================
template<>
Standard_CString ShapePersistent_Geom2d_Curve::instance<ShapePersistent_Geom2d::Curve,
Geom2d_Line,
gp_Ax2d>
::PName() const;
template<>
void ShapePersistent_Geom2d_Curve::instance<ShapePersistent_Geom2d::Curve,
Geom2d_Line,
gp_Ax2d>
::Write(StdObjMgt_WriteData& theWriteData) const;
//=======================================================================
// Conic
//=======================================================================
template<>
Standard_CString ShapePersistent_Geom2d_Curve::subBase_gp<ShapePersistent_Geom2d::Curve,
gp_Ax22d>
::PName() const;
//=======================================================================
// Circle
//=======================================================================
template<>
Standard_CString ShapePersistent_Geom2d_Curve::instance<ShapePersistent_Geom2d_Curve::Conic,
Geom2d_Circle,
gp_Circ2d>
::PName() const;
template<>
void ShapePersistent_Geom2d_Curve::instance<ShapePersistent_Geom2d_Curve::Conic,
Geom2d_Circle,
gp_Circ2d>
::Write(StdObjMgt_WriteData& theWriteData) const;
//=======================================================================
// Ellipse
//=======================================================================
template<>
Standard_CString ShapePersistent_Geom2d_Curve::instance<ShapePersistent_Geom2d_Curve::Conic,
Geom2d_Ellipse,
gp_Elips2d>
::PName() const;
template<>
void ShapePersistent_Geom2d_Curve::instance<ShapePersistent_Geom2d_Curve::Conic,
Geom2d_Ellipse,
gp_Elips2d>
::Write(StdObjMgt_WriteData& theWriteData) const;
//=======================================================================
// Hyperbola
//=======================================================================
template<>
Standard_CString ShapePersistent_Geom2d_Curve::instance<ShapePersistent_Geom2d_Curve::Conic,
Geom2d_Hyperbola,
gp_Hypr2d>
::PName() const;
template<>
void ShapePersistent_Geom2d_Curve::instance<ShapePersistent_Geom2d_Curve::Conic,
Geom2d_Hyperbola,
gp_Hypr2d>
::Write(StdObjMgt_WriteData& theWriteData) const;
//=======================================================================
// Parabola
//=======================================================================
template<>
Standard_CString ShapePersistent_Geom2d_Curve::instance<ShapePersistent_Geom2d_Curve::Conic,
Geom2d_Parabola,
gp_Parab2d>
::PName() const;
template<>
void ShapePersistent_Geom2d_Curve::instance<ShapePersistent_Geom2d_Curve::Conic,
Geom2d_Parabola,
gp_Parab2d>
::Write(StdObjMgt_WriteData& theWriteData) const;
#endif

308
src/ShapePersistent/ShapePersistent_Geom_Curve.cxx
View File

@ -11,6 +11,8 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Standard_NullObject.hxx>
#include <ShapePersistent_Geom_Curve.hxx>
#include <Geom_BezierCurve.hxx>
@ -75,3 +77,309 @@ Handle(Geom_Curve) ShapePersistent_Geom_Curve::pOffset::Import() const
return new Geom_OffsetCurve
(myBasisCurve->Import(), myOffsetValue, myOffsetDirection);
}
//=======================================================================
// Line
//=======================================================================
template<>
Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom::Curve,
Geom_Line,
gp_Ax1>
::PName() const { return "PGeom_Line"; }
template<>
void ShapePersistent_Geom::instance<ShapePersistent_Geom::Curve,
Geom_Line,
gp_Ax1>
::Write(StdObjMgt_WriteData& theWriteData) const
{
Handle(Geom_Line) aMyGeom =
Handle(Geom_Line)::DownCast(myTransient);
write(theWriteData, aMyGeom->Position());
}
Handle(ShapePersistent_Geom::Curve)
ShapePersistent_Geom_Curve::Translate(const Handle(Geom_Line)& theCurve,
StdObjMgt_TransientPersistentMap& theMap)
{
Handle(ShapePersistent_Geom::Curve) aPC;
if (!theCurve.IsNull())
{
if (theMap.IsBound(theCurve))
aPC = Handle(ShapePersistent_Geom::Curve)::DownCast(theMap.Find(theCurve));
else {
Handle(Line) aPT = new Line;
aPT->myTransient = theCurve;
aPC = aPT;
}
}
return aPC;
}
//=======================================================================
// Conic
//=======================================================================
template<>
Standard_CString ShapePersistent_Geom::subBase_gp<ShapePersistent_Geom::Curve,
gp_Ax2>
::PName() const { return "PGeom_Conic"; }
//=======================================================================
// Circle
//=======================================================================
template<>
Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom_Curve::Conic,
Geom_Circle,
gp_Circ>
::PName() const { return "PGeom_Circle"; }
template<>
void ShapePersistent_Geom::instance<ShapePersistent_Geom_Curve::Conic,
Geom_Circle,
gp_Circ>
::Write(StdObjMgt_WriteData& theWriteData) const
{
Handle(Geom_Circle) aMyGeom =
Handle(Geom_Circle)::DownCast(myTransient);
theWriteData << aMyGeom->Circ();
}
Handle(ShapePersistent_Geom::Curve)
ShapePersistent_Geom_Curve::Translate(const Handle(Geom_Circle)& theCurve,
StdObjMgt_TransientPersistentMap& theMap)
{
Handle(ShapePersistent_Geom::Curve) aPC;
if (!theCurve.IsNull())
{
if (theMap.IsBound(theCurve))
aPC = Handle(ShapePersistent_Geom::Curve)::DownCast(theMap.Find(theCurve));
else {
Handle(Circle) aPT = new Circle;
aPT->myTransient = theCurve;
aPC = aPT;
}
}
return aPC;
}
//=======================================================================
// Ellipse
//=======================================================================
template<>
Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom_Curve::Conic,
Geom_Ellipse,
gp_Elips>
::PName() const { return "PGeom_Ellipse"; }
template<>
void ShapePersistent_Geom::instance<ShapePersistent_Geom_Curve::Conic,
Geom_Ellipse,
gp_Elips>
::Write(StdObjMgt_WriteData& theWriteData) const
{
Handle(Geom_Ellipse) aMyGeom =
Handle(Geom_Ellipse)::DownCast(myTransient);
theWriteData << aMyGeom->Elips();
}
Handle(ShapePersistent_Geom::Curve)
ShapePersistent_Geom_Curve::Translate(const Handle(Geom_Ellipse)& theCurve,
StdObjMgt_TransientPersistentMap& theMap)
{
Handle(ShapePersistent_Geom::Curve) aPC;
if (!theCurve.IsNull())
{
if (theMap.IsBound(theCurve))
aPC = Handle(ShapePersistent_Geom::Curve)::DownCast(theMap.Find(theCurve));
else {
Handle(Ellipse) aPT = new Ellipse;
aPT->myTransient = theCurve;
aPC = aPT;
}
}
return aPC;
}
//=======================================================================
// Hyperbola
//=======================================================================
template<>
Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom_Curve::Conic,
Geom_Hyperbola,
gp_Hypr>
::PName() const { return "PGeom_Hyperbola"; }
template<>
void ShapePersistent_Geom::instance<ShapePersistent_Geom_Curve::Conic,
Geom_Hyperbola,
gp_Hypr>
::Write(StdObjMgt_WriteData& theWriteData) const
{
Handle(Geom_Hyperbola) aMyGeom =
Handle(Geom_Hyperbola)::DownCast(myTransient);
theWriteData << aMyGeom->Hypr();
}
Handle(ShapePersistent_Geom::Curve)
ShapePersistent_Geom_Curve::Translate(const Handle(Geom_Hyperbola)& theCurve,
StdObjMgt_TransientPersistentMap& theMap)
{
Handle(ShapePersistent_Geom::Curve) aPC;
if (!theCurve.IsNull())
{
if (theMap.IsBound(theCurve))
aPC = Handle(ShapePersistent_Geom::Curve)::DownCast(theMap.Find(theCurve));
else {
Handle(Hyperbola) aPT = new Hyperbola;
aPT->myTransient = theCurve;
aPC = aPT;
}
}
return aPC;
}
//=======================================================================
// Parabola
//=======================================================================
template<>
Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom_Curve::Conic,
Geom_Parabola,
gp_Parab>
::PName() const { return "PGeom_Parabola"; }
template<>
void ShapePersistent_Geom::instance<ShapePersistent_Geom_Curve::Conic,
Geom_Parabola,
gp_Parab>
::Write(StdObjMgt_WriteData& theWriteData) const
{
Handle(Geom_Parabola) aMyGeom =
Handle(Geom_Parabola)::DownCast(myTransient);
theWriteData << aMyGeom->Parab();
}
Handle(ShapePersistent_Geom::Curve)
ShapePersistent_Geom_Curve::Translate(const Handle(Geom_Parabola)& theCurve,
StdObjMgt_TransientPersistentMap& theMap)
{
Handle(ShapePersistent_Geom::Curve) aPC;
if (!theCurve.IsNull())
{
if (theMap.IsBound(theCurve))
aPC = Handle(ShapePersistent_Geom::Curve)::DownCast(theMap.Find(theCurve));
else {
Handle(Parabola) aPT = new Parabola;
aPT->myTransient = theCurve;
aPC = aPT;
}
}
return aPC;
}
//=======================================================================
// BezierCurve
//=======================================================================
Handle(ShapePersistent_Geom::Curve)
ShapePersistent_Geom_Curve::Translate(const Handle(Geom_BezierCurve)& theCurve,
StdObjMgt_TransientPersistentMap& theMap)
{
Handle(ShapePersistent_Geom::Curve) aPC;
if (!theCurve.IsNull())
{
if (theMap.IsBound(theCurve))
aPC = Handle(ShapePersistent_Geom::Curve)::DownCast(theMap.Find(theCurve));
else {
Handle(Bezier) aPBC = new Bezier;
Handle(pBezier) aPpBC = new pBezier;
aPpBC->myRational = theCurve->IsRational();
aPpBC->myPoles = StdLPersistent_HArray1::Translate<TColgp_HArray1OfPnt>("PColgp_HArray1OfPnt", theCurve->Poles());
if (theCurve->IsRational()) {
aPpBC->myWeights = StdLPersistent_HArray1::Translate<TColStd_HArray1OfReal>(*theCurve->Weights());
}
aPBC->myPersistent = aPpBC;
aPC = aPBC;
}
}
return aPC;
}
//=======================================================================
// BSplineCurve
//=======================================================================
Handle(ShapePersistent_Geom::Curve)
ShapePersistent_Geom_Curve::Translate(const Handle(Geom_BSplineCurve)& theCurve,
StdObjMgt_TransientPersistentMap& theMap)
{
Handle(ShapePersistent_Geom::Curve) aPC;
if (!theCurve.IsNull())
{
if (theMap.IsBound(theCurve))
aPC = Handle(ShapePersistent_Geom::Curve)::DownCast(theMap.Find(theCurve));
else {
Handle(BSpline) aPBSC = new BSpline;
Handle(pBSpline) aPpBSC = new pBSpline;
aPpBSC->myRational = theCurve->IsRational();
aPpBSC->myPeriodic = theCurve->IsPeriodic();
aPpBSC->mySpineDegree = theCurve->Degree();
aPpBSC->myPoles = StdLPersistent_HArray1::Translate<TColgp_HArray1OfPnt>("PColgp_HArray1OfPnt", theCurve->Poles());
if (theCurve->IsRational()) {
aPpBSC->myWeights = StdLPersistent_HArray1::Translate<TColStd_HArray1OfReal>(*theCurve->Weights());
}
aPpBSC->myKnots = StdLPersistent_HArray1::Translate<TColStd_HArray1OfReal>(theCurve->Knots());
aPpBSC->myMultiplicities = StdLPersistent_HArray1::Translate<TColStd_HArray1OfInteger>(theCurve->Multiplicities());
aPBSC->myPersistent = aPpBSC;
aPC = aPBSC;
}
}
return aPC;
}
//=======================================================================
// TrimmedCurve
//=======================================================================
Handle(ShapePersistent_Geom::Curve)
ShapePersistent_Geom_Curve::Translate(const Handle(Geom_TrimmedCurve)& theCurve,
StdObjMgt_TransientPersistentMap& theMap)
{
Handle(ShapePersistent_Geom::Curve) aPC;
if (!theCurve.IsNull())
{
if (theMap.IsBound(theCurve))
aPC = Handle(ShapePersistent_Geom::Curve)::DownCast(theMap.Find(theCurve));
else {
Handle(Trimmed) aPTC = new Trimmed;
Handle(pTrimmed) aPpTC = new pTrimmed;
aPpTC->myFirstU = theCurve->FirstParameter();
aPpTC->myLastU = theCurve->LastParameter();
aPpTC->myBasisCurve = ShapePersistent_Geom::Translate(theCurve->BasisCurve(), theMap);
aPTC->myPersistent = aPpTC;
aPC = aPTC;
}
}
return aPC;
}
//=======================================================================
// OffsetCurve
//=======================================================================
Handle(ShapePersistent_Geom::Curve)
ShapePersistent_Geom_Curve::Translate(const Handle(Geom_OffsetCurve)& theCurve,
StdObjMgt_TransientPersistentMap& theMap)
{
Handle(ShapePersistent_Geom::Curve) aPC;
if (!theCurve.IsNull())
{
if (theMap.IsBound(theCurve))
aPC = Handle(ShapePersistent_Geom::Curve)::DownCast(theMap.Find(theCurve));
else {
Handle(Offset) aPOC = new Offset;
Handle(pOffset) aPpOC = new pOffset;
aPpOC->myOffsetDirection = theCurve->Direction();
aPpOC->myOffsetValue = theCurve->Offset();
aPpOC->myBasisCurve = ShapePersistent_Geom::Translate(theCurve->BasisCurve(), theMap);
aPOC->myPersistent = aPpOC;
aPC = aPOC;
}
}
return aPC;
}

158
src/ShapePersistent/ShapePersistent_Geom_Curve.hxx
View File

@ -15,6 +15,8 @@
#ifndef _ShapePersistent_Geom_Curve_HeaderFile
#define _ShapePersistent_Geom_Curve_HeaderFile
#include <StdObjMgt_TransientPersistentMap.hxx>
#include <ShapePersistent_Geom.hxx>
#include <ShapePersistent_HArray1.hxx>
#include <StdLPersistent_HArray1.hxx>
@ -24,6 +26,10 @@
#include <Geom_Ellipse.hxx>
#include <Geom_Hyperbola.hxx>
#include <Geom_Parabola.hxx>
#include <Geom_BezierCurve.hxx>
#include <Geom_BSplineCurve.hxx>
#include <Geom_TrimmedCurve.hxx>
#include <Geom_OffsetCurve.hxx>
#include <gp_Circ.hxx>
#include <gp_Elips.hxx>
@ -32,7 +38,6 @@
class gp_Dir;
class ShapePersistent_Geom_Curve : private ShapePersistent_Geom
{
typedef Curve::PersistentBase pBase;
@ -41,9 +46,19 @@ class ShapePersistent_Geom_Curve : private ShapePersistent_Geom
class pBezier : public pBounded
{
friend class ShapePersistent_Geom_Curve;
public:
inline void Read (StdObjMgt_ReadData& theReadData)
{ theReadData >> myRational >> myPoles >> myWeights; }
inline void Write(StdObjMgt_WriteData& theWriteData)
{ theWriteData << myRational << myPoles << myWeights; }
inline void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
{
theChildren.Append(myPoles);
theChildren.Append(myWeights);
}
inline Standard_CString PName() const { return "PGeom_BezierCurve"; }
virtual Handle(Geom_Curve) Import() const;
@ -55,12 +70,27 @@ class ShapePersistent_Geom_Curve : private ShapePersistent_Geom
class pBSpline : public pBounded
{
friend class ShapePersistent_Geom_Curve;
public:
inline void Read (StdObjMgt_ReadData& theReadData)
{
theReadData >> myRational >> myPeriodic >> mySpineDegree;
theReadData >> myPoles >> myWeights >> myKnots >> myMultiplicities;
}
inline void Write (StdObjMgt_WriteData& theWriteData) const
{
theWriteData << myRational << myPeriodic << mySpineDegree;
theWriteData << myPoles << myWeights << myKnots << myMultiplicities;
}
inline void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
{
theChildren.Append(myPoles);
theChildren.Append(myWeights);
theChildren.Append(myKnots);
theChildren.Append(myMultiplicities);
}
inline Standard_CString PName() const { return "PGeom_BSplineCurve"; }
virtual Handle(Geom_Curve) Import() const;
@ -76,9 +106,16 @@ class ShapePersistent_Geom_Curve : private ShapePersistent_Geom
class pTrimmed : public pBounded
{
friend class ShapePersistent_Geom_Curve;
public:
inline void Read (StdObjMgt_ReadData& theReadData)
{ theReadData >> myBasisCurve >> myFirstU >> myLastU; }
inline void Write (StdObjMgt_WriteData& theWriteData) const
{ theWriteData << myBasisCurve << myFirstU << myLastU; }
inline void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
{ theChildren.Append(myBasisCurve); }
inline Standard_CString PName() const { return "PGeom_TrimmedCurve"; }
virtual Handle(Geom_Curve) Import() const;
@ -90,9 +127,16 @@ class ShapePersistent_Geom_Curve : private ShapePersistent_Geom
class pOffset : public pBase
{
friend class ShapePersistent_Geom_Curve;
public:
inline void Read (StdObjMgt_ReadData& theReadData)
{ theReadData >> myBasisCurve >> myOffsetDirection >> myOffsetValue; }
inline void Write (StdObjMgt_WriteData& theWriteData) const
{ theWriteData << myBasisCurve << myOffsetDirection << myOffsetValue; }
inline void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
{ theChildren.Append(myBasisCurve); }
inline Standard_CString PName() const { return "PGeom_OffsetCurve"; }
virtual Handle(Geom_Curve) Import() const;
@ -117,6 +161,118 @@ public:
typedef Delayed<Bounded, pTrimmed> Trimmed;
typedef Delayed<Curve, pOffset> Offset;
public:
//! Create a persistent object for a line
Standard_EXPORT static Handle(Curve) Translate (const Handle(Geom_Line)& theCurve,
StdObjMgt_TransientPersistentMap& theMap);
//! Create a persistent object for a circle
Standard_EXPORT static Handle(Curve) Translate (const Handle(Geom_Circle)& theCurve,
StdObjMgt_TransientPersistentMap& theMap);
//! Create a persistent object for a ellipse
Standard_EXPORT static Handle(Curve) Translate (const Handle(Geom_Ellipse)& theCurve,
StdObjMgt_TransientPersistentMap& theMap);
//! Create a persistent object for a hyperbola
Standard_EXPORT static Handle(Curve) Translate (const Handle(Geom_Hyperbola)& theCurve,
StdObjMgt_TransientPersistentMap& theMap);
//! Create a persistent object for a parabola
Standard_EXPORT static Handle(Curve) Translate (const Handle(Geom_Parabola)& theCurve,
StdObjMgt_TransientPersistentMap& theMap);
//! Create a persistent object for a Bezier curve
Standard_EXPORT static Handle(Curve) Translate (const Handle(Geom_BezierCurve)& theCurve,
StdObjMgt_TransientPersistentMap& theMap);
//! Create a persistent object for a BSpline curve
Standard_EXPORT static Handle(Curve) Translate (const Handle(Geom_BSplineCurve)& theCurve,
StdObjMgt_TransientPersistentMap& theMap);
//! Create a persistent object for a trimmed curve
Standard_EXPORT static Handle(Curve) Translate (const Handle(Geom_TrimmedCurve)& theCurve,
StdObjMgt_TransientPersistentMap& theMap);
//! Create a persistent object for an offset curve
Standard_EXPORT static Handle(Curve) Translate (const Handle(Geom_OffsetCurve)& theCurve,
StdObjMgt_TransientPersistentMap& theMap);
};
//=======================================================================
// Line
//=======================================================================
template<>
Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom::Curve,
Geom_Line,
gp_Ax1>
::PName() const;
template<>
void ShapePersistent_Geom::instance<ShapePersistent_Geom::Curve,
Geom_Line,
gp_Ax1>
::Write(StdObjMgt_WriteData& theWriteData) const;
//=======================================================================
// Conic
//=======================================================================
template<>
Standard_CString ShapePersistent_Geom::subBase_gp<ShapePersistent_Geom::Curve,
gp_Ax2>
::PName() const;
//=======================================================================
// Circle
//=======================================================================
template<>
Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom_Curve::Conic,
Geom_Circle,
gp_Circ>
::PName() const;
template<>
void ShapePersistent_Geom::instance<ShapePersistent_Geom_Curve::Conic,
Geom_Circle,
gp_Circ>
::Write(StdObjMgt_WriteData& theWriteData) const;
//=======================================================================
// Ellipse
//=======================================================================
template<>
Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom_Curve::Conic,
Geom_Ellipse,
gp_Elips>
::PName() const;
template<>
void ShapePersistent_Geom::instance<ShapePersistent_Geom_Curve::Conic,
Geom_Ellipse,
gp_Elips>
::Write(StdObjMgt_WriteData& theWriteData) const;
//=======================================================================
// Hyperbola
//=======================================================================
template<>
Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom_Curve::Conic,
Geom_Hyperbola,
gp_Hypr>
::PName() const;
template<>
void ShapePersistent_Geom::instance<ShapePersistent_Geom_Curve::Conic,
Geom_Hyperbola,
gp_Hypr>
::Write(StdObjMgt_WriteData& theWriteData) const;
//=======================================================================
// Parabola
//=======================================================================
template<>
Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom_Curve::Conic,
Geom_Parabola,
gp_Parab>
::PName() const;
template<>
void ShapePersistent_Geom::instance<ShapePersistent_Geom_Curve::Conic,
Geom_Parabola,
gp_Parab>
::Write(StdObjMgt_WriteData& theWriteData) const;
#endif

373
src/ShapePersistent/ShapePersistent_Geom_Surface.cxx
View File

@ -12,6 +12,8 @@
// commercial license or contractual agreement.
#include <ShapePersistent_Geom_Surface.hxx>
#include <StdLPersistent_HArray1.hxx>
#include <ShapePersistent_HArray2.hxx>
#include <Geom_SurfaceOfLinearExtrusion.hxx>
#include <Geom_SurfaceOfRevolution.hxx>
@ -108,3 +110,374 @@ Handle(Geom_Surface) ShapePersistent_Geom_Surface::pOffset::Import() const
return new Geom_OffsetSurface (myBasisSurface->Import(), myOffsetValue);
}
//=======================================================================
// Elementary
//=======================================================================
template<>
Standard_CString ShapePersistent_Geom::subBase_gp<ShapePersistent_Geom::Surface,
gp_Ax3>
::PName() const { return "PGeom_ElementarySurface"; }
//=======================================================================
// Plane
//=======================================================================
template<>
Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom::subBase_gp<ShapePersistent_Geom::Surface, gp_Ax3>,
Geom_Plane,
gp_Ax3>
::PName() const { return "PGeom_Plane"; }
template<>
void ShapePersistent_Geom::instance<ShapePersistent_Geom::subBase_gp<ShapePersistent_Geom::Surface, gp_Ax3>,
Geom_Plane,
gp_Ax3>
::Write(StdObjMgt_WriteData& theWriteData) const
{
Handle(Geom_Plane) aMyGeom =
Handle(Geom_Plane)::DownCast(myTransient);
theWriteData << aMyGeom->Position();
}
Handle(ShapePersistent_Geom::Surface)
ShapePersistent_Geom_Surface::Translate(const Handle(Geom_Plane)& theSurf,
StdObjMgt_TransientPersistentMap& theMap)
{
Handle(ShapePersistent_Geom::Surface) aPS;
if (!theSurf.IsNull())
{
if (theMap.IsBound(theSurf))
aPS = Handle(ShapePersistent_Geom::Surface)::DownCast(theMap.Find(theSurf));
else
{
Handle(Plane) aPP = new Plane;
aPP->myTransient = theSurf;
aPS = aPP;
}
}
return aPS;
}
//=======================================================================
// Conical
//=======================================================================
template<>
Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom::subBase_gp<ShapePersistent_Geom::Surface, gp_Ax3>,
Geom_ConicalSurface,
gp_Cone>
::PName() const { return "PGeom_ConicalSurface"; }
template<>
void ShapePersistent_Geom::instance<ShapePersistent_Geom::subBase_gp<ShapePersistent_Geom::Surface, gp_Ax3>,
Geom_ConicalSurface,
gp_Cone>
::Write(StdObjMgt_WriteData& theWriteData) const
{
Handle(Geom_ConicalSurface) aMyGeom =
Handle(Geom_ConicalSurface)::DownCast(myTransient);
theWriteData << aMyGeom->Cone();
}
Handle(ShapePersistent_Geom::Surface)
ShapePersistent_Geom_Surface::Translate(const Handle(Geom_ConicalSurface)& theSurf,
StdObjMgt_TransientPersistentMap& theMap)
{
Handle(ShapePersistent_Geom::Surface) aPS;
if (!theSurf.IsNull())
{
if (theMap.IsBound(theSurf))
aPS = Handle(ShapePersistent_Geom::Surface)::DownCast(theMap.Find(theSurf));
else
{
Handle(Conical) aPCon = new Conical;
aPCon->myTransient = theSurf;
aPS = aPCon;
}
}
return aPS;
}
//=======================================================================
// Cylindrical
//=======================================================================
template<>
Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom::subBase_gp<ShapePersistent_Geom::Surface, gp_Ax3>,
Geom_CylindricalSurface,
gp_Cylinder>
::PName() const { return "PGeom_CylindricalSurface"; }
template<>
void ShapePersistent_Geom::instance<ShapePersistent_Geom::subBase_gp<ShapePersistent_Geom::Surface, gp_Ax3>,
Geom_CylindricalSurface,
gp_Cylinder>
::Write(StdObjMgt_WriteData& theWriteData) const
{
Handle(Geom_CylindricalSurface) aMyGeom =
Handle(Geom_CylindricalSurface)::DownCast(myTransient);
theWriteData << aMyGeom->Cylinder();
}
Handle(ShapePersistent_Geom::Surface)
ShapePersistent_Geom_Surface::Translate(const Handle(Geom_CylindricalSurface)& theSurf,
StdObjMgt_TransientPersistentMap& theMap)
{
Handle(ShapePersistent_Geom::Surface) aPS;
if (!theSurf.IsNull())
{
if (theMap.IsBound(theSurf))
aPS = Handle(ShapePersistent_Geom::Surface)::DownCast(theMap.Find(theSurf));
else
{
Handle(Cylindrical) aPCyl = new Cylindrical;
aPCyl->myTransient = theSurf;
aPS = aPCyl;
}
}
return aPS;
}
//=======================================================================
// Spherical
//=======================================================================
template<>
Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom::subBase_gp<ShapePersistent_Geom::Surface, gp_Ax3>,
Geom_SphericalSurface,
gp_Sphere>
::PName() const { return "PGeom_SphericalSurface"; }
template<>
void ShapePersistent_Geom::instance<ShapePersistent_Geom::subBase_gp<ShapePersistent_Geom::Surface, gp_Ax3>,
Geom_SphericalSurface,
gp_Sphere>
::Write(StdObjMgt_WriteData& theWriteData) const
{
Handle(Geom_SphericalSurface) aMyGeom =
Handle(Geom_SphericalSurface)::DownCast(myTransient);
theWriteData << aMyGeom->Sphere();
}
Handle(ShapePersistent_Geom::Surface)
ShapePersistent_Geom_Surface::Translate(const Handle(Geom_SphericalSurface)& theSurf,
StdObjMgt_TransientPersistentMap& theMap)
{
Handle(ShapePersistent_Geom::Surface) aPS;
if (!theSurf.IsNull())
{
if (theMap.IsBound(theSurf))
aPS = Handle(ShapePersistent_Geom::Surface)::DownCast(theMap.Find(theSurf));
else
{
Handle(Spherical) aPSph = new Spherical;
aPSph->myTransient = theSurf;
aPS = aPSph;
}
}
return aPS;
}
//=======================================================================
// Toroidal
//=======================================================================
template<>
Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom::subBase_gp<ShapePersistent_Geom::Surface, gp_Ax3>,
Geom_ToroidalSurface,
gp_Torus>
::PName() const { return "PGeom_ToroidalSurface"; }
template<>
void ShapePersistent_Geom::instance<ShapePersistent_Geom::subBase_gp<ShapePersistent_Geom::Surface, gp_Ax3>,
Geom_ToroidalSurface,
gp_Torus>
::Write(StdObjMgt_WriteData& theWriteData) const
{
Handle(Geom_ToroidalSurface) aMyGeom =
Handle(Geom_ToroidalSurface)::DownCast(myTransient);
theWriteData << aMyGeom->Torus();
}
Handle(ShapePersistent_Geom::Surface)
ShapePersistent_Geom_Surface::Translate(const Handle(Geom_ToroidalSurface)& theSurf,
StdObjMgt_TransientPersistentMap& theMap)
{
Handle(ShapePersistent_Geom::Surface) aPS;
if (!theSurf.IsNull())
{
if (theMap.IsBound(theSurf))
aPS = Handle(ShapePersistent_Geom::Surface)::DownCast(theMap.Find(theSurf));
else
{
Handle(Toroidal) aPTor = new Toroidal;
aPTor->myTransient = theSurf;
aPS = aPTor;
}
}
return aPS;
}
//=======================================================================
// LinearExtrusion
//=======================================================================
Handle(ShapePersistent_Geom::Surface)
ShapePersistent_Geom_Surface::Translate(const Handle(Geom_SurfaceOfLinearExtrusion)& theSurf,
StdObjMgt_TransientPersistentMap& theMap)
{
Handle(ShapePersistent_Geom::Surface) aPS;
if (!theSurf.IsNull())
{
if (theMap.IsBound(theSurf))
aPS = Handle(ShapePersistent_Geom::Surface)::DownCast(theMap.Find(theSurf));
else
{
Handle(LinearExtrusion) aPLE = new LinearExtrusion;
Handle(pLinearExtrusion) aPpLE = new pLinearExtrusion;
aPpLE->myDirection = theSurf->Direction();
aPpLE->myBasisCurve = ShapePersistent_Geom::Translate(theSurf->BasisCurve(), theMap);
aPLE->myPersistent = aPpLE;
aPS = aPLE;
}
}
return aPS;
}
//=======================================================================
// Revolution
//=======================================================================
Handle(ShapePersistent_Geom::Surface)
ShapePersistent_Geom_Surface::Translate(const Handle(Geom_SurfaceOfRevolution)& theSurf,
StdObjMgt_TransientPersistentMap& theMap)
{
Handle(ShapePersistent_Geom::Surface) aPS;
if (!theSurf.IsNull())
{
if (theMap.IsBound(theSurf))
aPS = Handle(ShapePersistent_Geom::Surface)::DownCast(theMap.Find(theSurf));
else
{
Handle(Revolution) aPR = new Revolution;
Handle(pRevolution) aPpR = new pRevolution;
aPpR->myLocation = theSurf->Location();
aPpR->myDirection = theSurf->Direction();
aPpR->myBasisCurve = ShapePersistent_Geom::Translate(theSurf->BasisCurve(), theMap);
aPR->myPersistent = aPpR;
aPS = aPR;
}
}
return aPS;
}
//=======================================================================
//
//=======================================================================
Handle(ShapePersistent_Geom::Surface)
ShapePersistent_Geom_Surface::Translate(const Handle(Geom_BezierSurface)& theSurf,
StdObjMgt_TransientPersistentMap& theMap)
{
Handle(ShapePersistent_Geom::Surface) aPS;
if (!theSurf.IsNull())
{
if (theMap.IsBound(theSurf))
aPS = Handle(ShapePersistent_Geom::Surface)::DownCast(theMap.Find(theSurf));
else
{
Handle(Bezier) aPB = new Bezier;
Handle(pBezier) aPpB = new pBezier;
aPpB->myURational = theSurf->IsURational();
aPpB->myVRational = theSurf->IsVRational();
aPpB->myPoles = StdLPersistent_HArray2::Translate<TColgp_HArray2OfPnt>("PColgp_HArray2OfPnt", theSurf->Poles());
if (theSurf->IsURational() || theSurf->IsVRational()) {
aPpB->myWeights = StdLPersistent_HArray2::Translate<TColStd_HArray2OfReal>(*theSurf->Weights());
}
aPB->myPersistent = aPpB;
aPS = aPB;
}
}
return aPS;
}
//=======================================================================
// BSpline
//=======================================================================
Handle(ShapePersistent_Geom::Surface)
ShapePersistent_Geom_Surface::Translate(const Handle(Geom_BSplineSurface)& theSurf,
StdObjMgt_TransientPersistentMap& theMap)
{
Handle(ShapePersistent_Geom::Surface) aPS;
if (!theSurf.IsNull())
{
if (theMap.IsBound(theSurf))
aPS = Handle(ShapePersistent_Geom::Surface)::DownCast(theMap.Find(theSurf));
else
{
Handle(BSpline) aPBS = new BSpline;
Handle(pBSpline) aPpBS = new pBSpline;
aPpBS->myURational = theSurf->IsURational();
aPpBS->myVRational = theSurf->IsVRational();
aPpBS->myUPeriodic = theSurf->IsUPeriodic();
aPpBS->myVPeriodic = theSurf->IsVPeriodic();
aPpBS->myUSpineDegree = theSurf->UDegree();
aPpBS->myVSpineDegree = theSurf->VDegree();
aPpBS->myPoles = StdLPersistent_HArray2::Translate<TColgp_HArray2OfPnt>("PColgp_HArray2OfPnt", theSurf->Poles());
if (theSurf->IsURational() || theSurf->IsVRational()) {
aPpBS->myWeights = StdLPersistent_HArray2::Translate<TColStd_HArray2OfReal>(*theSurf->Weights());
}
aPpBS->myUKnots = StdLPersistent_HArray1::Translate<TColStd_HArray1OfReal>(theSurf->UKnots());
aPpBS->myVKnots = StdLPersistent_HArray1::Translate<TColStd_HArray1OfReal>(theSurf->VKnots());
aPpBS->myUMultiplicities = StdLPersistent_HArray1::Translate<TColStd_HArray1OfInteger>(theSurf->UMultiplicities());
aPpBS->myVMultiplicities = StdLPersistent_HArray1::Translate<TColStd_HArray1OfInteger>(theSurf->VMultiplicities());
aPBS->myPersistent = aPpBS;
aPS = aPBS;
}
}
return aPS;
}
//=======================================================================
// RectangularTrimmed
//=======================================================================
Handle(ShapePersistent_Geom::Surface)
ShapePersistent_Geom_Surface::Translate(const Handle(Geom_RectangularTrimmedSurface)& theSurf,
StdObjMgt_TransientPersistentMap& theMap)
{
Handle(ShapePersistent_Geom::Surface) aPS;
if (!theSurf.IsNull())
{
if (theMap.IsBound(theSurf))
aPS = Handle(ShapePersistent_Geom::Surface)::DownCast(theMap.Find(theSurf));
else
{
Handle(RectangularTrimmed) aPRT = new RectangularTrimmed;
Handle(pRectangularTrimmed) aPpRT = new pRectangularTrimmed;
theSurf->Bounds(aPpRT->myFirstU, aPpRT->myLastU, aPpRT->myFirstV, aPpRT->myLastV);
aPpRT->myBasisSurface = ShapePersistent_Geom::Translate(theSurf->BasisSurface(), theMap);
aPRT->myPersistent = aPpRT;
aPS = aPRT;
}
}
return aPS;
}
//=======================================================================
// Offset
//=======================================================================
Handle(ShapePersistent_Geom::Surface)
ShapePersistent_Geom_Surface::Translate(const Handle(Geom_OffsetSurface)& theSurf,
StdObjMgt_TransientPersistentMap& theMap)
{
Handle(ShapePersistent_Geom::Surface) aPS;
if (!theSurf.IsNull())
{
if (theMap.IsBound(theSurf))
aPS = Handle(ShapePersistent_Geom::Surface)::DownCast(theMap.Find(theSurf));
else
{
Handle(Offset) aPO = new Offset;
Handle(pOffset) aPpO = new pOffset;
aPpO->myOffsetValue = theSurf->Offset();
aPpO->myBasisSurface = ShapePersistent_Geom::Translate(theSurf->BasisSurface(), theMap);
aPO->myPersistent = aPpO;
aPS = aPO;
}
}
return aPS;
}

204
src/ShapePersistent/ShapePersistent_Geom_Surface.hxx
View File

@ -15,6 +15,8 @@
#ifndef _ShapePersistent_Geom_Surface_HeaderFile
#define _ShapePersistent_Geom_Surface_HeaderFile
#include <StdObjMgt_TransientPersistentMap.hxx>
#include <ShapePersistent_Geom.hxx>
#include <ShapePersistent_HArray2.hxx>
#include <StdLPersistent_HArray1.hxx>
@ -25,6 +27,12 @@
#include <Geom_CylindricalSurface.hxx>
#include <Geom_SphericalSurface.hxx>
#include <Geom_ToroidalSurface.hxx>
#include <Geom_SurfaceOfLinearExtrusion.hxx>
#include <Geom_SurfaceOfRevolution.hxx>
#include <Geom_BezierSurface.hxx>
#include <Geom_BSplineSurface.hxx>
#include <Geom_RectangularTrimmedSurface.hxx>
#include <Geom_OffsetSurface.hxx>
#include <gp_Ax3.hxx>
#include <gp_Cone.hxx>
@ -42,31 +50,54 @@ class ShapePersistent_Geom_Surface : private ShapePersistent_Geom
class pSweptData
{
friend class ShapePersistent_Geom_Surface;
public:
inline void Read (StdObjMgt_ReadData& theReadData)
{ theReadData >> myBasisCurve >> myDirection; }
inline void Write (StdObjMgt_WriteData& theWriteData) const
{ theWriteData << myBasisCurve << myDirection; }
inline void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
{ theChildren.Append(myBasisCurve); }
protected:
Handle(Curve) myBasisCurve;
gp_Dir myDirection;
};
struct pSwept : pBase, pSweptData {};
struct pSwept : pBase, pSweptData
{
inline Standard_CString PName() const
{ return "PGeom_SweptSurface"; }
};
class pLinearExtrusion : public pSwept
{
friend class ShapePersistent_Geom_Surface;
public:
virtual Handle(Geom_Surface) Import() const;
inline Standard_CString PName() const
{ return "PGeom_SurfaceOfLinearExtrusion"; }
};
class pRevolution : public pSwept
{
friend class ShapePersistent_Geom_Surface;
public:
inline void Read (StdObjMgt_ReadData& theReadData)
{
pSwept::Read (theReadData);
theReadData >> myLocation;
}
inline void Write (StdObjMgt_WriteData& theWriteData) const
{
pSwept::Write(theWriteData);
theWriteData << myLocation;
}
inline Standard_CString PName() const
{ return "PGeom_SurfaceOfRevolution"; }
virtual Handle(Geom_Surface) Import() const;
@ -78,9 +109,20 @@ class ShapePersistent_Geom_Surface : private ShapePersistent_Geom
class pBezier : public pBounded
{
friend class ShapePersistent_Geom_Surface;
public:
inline void Read (StdObjMgt_ReadData& theReadData)
{ theReadData >> myURational >> myVRational >> myPoles >> myWeights; }
inline void Write (StdObjMgt_WriteData& theWriteData) const
{ theWriteData << myURational << myVRational << myPoles << myWeights; }
inline void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
{
theChildren.Append(myPoles);
theChildren.Append(myWeights);
}
inline Standard_CString PName() const
{ return "PGeom_BezierSurface"; }
virtual Handle(Geom_Surface) Import() const;
@ -93,6 +135,8 @@ class ShapePersistent_Geom_Surface : private ShapePersistent_Geom
class pBSpline : public pBounded
{
friend class ShapePersistent_Geom_Surface;
public:
inline void Read (StdObjMgt_ReadData& theReadData)
{
@ -104,6 +148,27 @@ class ShapePersistent_Geom_Surface : private ShapePersistent_Geom
theReadData >> myUKnots >> myVKnots;
theReadData >> myUMultiplicities >> myVMultiplicities;
}
inline void Write (StdObjMgt_WriteData& theWriteData) const
{
theWriteData << myURational << myVRational;
theWriteData << myUPeriodic << myVPeriodic;
theWriteData << myUSpineDegree << myVSpineDegree;
theWriteData << myPoles;
theWriteData << myWeights;
theWriteData << myUKnots << myVKnots;
theWriteData << myUMultiplicities << myVMultiplicities;
}
inline void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
{
theChildren.Append(myPoles);
theChildren.Append(myWeights);
theChildren.Append(myUKnots);
theChildren.Append(myVKnots);
theChildren.Append(myUMultiplicities);
theChildren.Append(myVMultiplicities);
}
inline Standard_CString PName() const
{ return "PGeom_BSplineSurface"; }
virtual Handle(Geom_Surface) Import() const;
@ -124,12 +189,23 @@ class ShapePersistent_Geom_Surface : private ShapePersistent_Geom
class pRectangularTrimmed : public pBounded
{
friend class ShapePersistent_Geom_Surface;
public:
inline void Read (StdObjMgt_ReadData& theReadData)
{
theReadData >> myBasisSurface;
theReadData >> myFirstU >> myLastU >> myFirstV >> myLastV;
}
inline void Write (StdObjMgt_WriteData& theWriteData) const
{
theWriteData << myBasisSurface;
theWriteData << myFirstU << myLastU << myFirstV << myLastV;
}
inline void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
{ theChildren.Append(myBasisSurface); }
inline Standard_CString PName() const
{ return "PGeom_RectangularTrimmedSurface"; }
virtual Handle(Geom_Surface) Import() const;
@ -143,9 +219,17 @@ class ShapePersistent_Geom_Surface : private ShapePersistent_Geom
class pOffset : public pBase
{
friend class ShapePersistent_Geom_Surface;
public:
inline void Read (StdObjMgt_ReadData& theReadData)
{ theReadData >> myBasisSurface >> myOffsetValue; }
inline void Write (StdObjMgt_WriteData& theWriteData) const
{ theWriteData << myBasisSurface << myOffsetValue; }
inline void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
{ theChildren.Append(myBasisSurface); }
inline Standard_CString PName() const
{ return "PGeom_OffsetSurface"; }
virtual Handle(Geom_Surface) Import() const;
@ -172,6 +256,124 @@ public:
typedef Delayed<Bounded, pRectangularTrimmed> RectangularTrimmed;
typedef Delayed<Surface, pOffset> Offset;
public:
//! Create a persistent object for a plane
Standard_EXPORT static Handle(Surface) Translate (const Handle(Geom_Plane)& theSurf,
StdObjMgt_TransientPersistentMap& theMap);
//! Create a persistent object for a cylinder
Standard_EXPORT static Handle(Surface) Translate (const Handle(Geom_CylindricalSurface)& theSurf,
StdObjMgt_TransientPersistentMap& theMap);
//! Create a persistent object for a cone
Standard_EXPORT static Handle(Surface) Translate (const Handle(Geom_ConicalSurface)& theSurf,
StdObjMgt_TransientPersistentMap& theMap);
//! Create a persistent object for a sphere
Standard_EXPORT static Handle(Surface) Translate (const Handle(Geom_SphericalSurface)& theSurf,
StdObjMgt_TransientPersistentMap& theMap);
//! Create a persistent object for a torus
Standard_EXPORT static Handle(Surface) Translate (const Handle(Geom_ToroidalSurface)& theSurf,
StdObjMgt_TransientPersistentMap& theMap);
//! Create a persistent object for a surface of linear extrusion
Standard_EXPORT static Handle(Surface) Translate (const Handle(Geom_SurfaceOfLinearExtrusion)& theSurf,
StdObjMgt_TransientPersistentMap& theMap);
//! Create a persistent object for a surface of evolution
Standard_EXPORT static Handle(Surface) Translate (const Handle(Geom_SurfaceOfRevolution)& theSurf,
StdObjMgt_TransientPersistentMap& theMap);
//! Create a persistent object for a Bezier surface
Standard_EXPORT static Handle(Surface) Translate (const Handle(Geom_BezierSurface)& theSurf,
StdObjMgt_TransientPersistentMap& theMap);
//! Create a persistent object for a BSpline surface
Standard_EXPORT static Handle(Surface) Translate (const Handle(Geom_BSplineSurface)& theSurf,
StdObjMgt_TransientPersistentMap& theMap);
//! Create a persistent object for a rectangylar trimmed surface
Standard_EXPORT static Handle(Surface) Translate (const Handle(Geom_RectangularTrimmedSurface)& theSurf,
StdObjMgt_TransientPersistentMap& theMap);
//! Create a persistent object for an offset surface
Standard_EXPORT static Handle(Surface) Translate (const Handle(Geom_OffsetSurface)& theSurf,
StdObjMgt_TransientPersistentMap& theMap);
};
//=======================================================================
// Elementary
//=======================================================================
template<>
Standard_CString ShapePersistent_Geom::subBase_gp<ShapePersistent_Geom::Surface,
gp_Ax3>
::PName() const;
//=======================================================================
// Plane
//=======================================================================
template<>
Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom::subBase_gp<ShapePersistent_Geom::Surface, gp_Ax3>,
Geom_Plane,
gp_Ax3>
::PName() const;
template<>
void ShapePersistent_Geom::instance<ShapePersistent_Geom::subBase_gp<ShapePersistent_Geom::Surface, gp_Ax3>,
Geom_Plane,
gp_Ax3>
::Write(StdObjMgt_WriteData& theWriteData) const;
//=======================================================================
// Conical
//=======================================================================
template<>
Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom::subBase_gp<ShapePersistent_Geom::Surface, gp_Ax3>,
Geom_ConicalSurface,
gp_Cone>
::PName() const;
template<>
void ShapePersistent_Geom::instance<ShapePersistent_Geom::subBase_gp<ShapePersistent_Geom::Surface, gp_Ax3>,
Geom_ConicalSurface,
gp_Cone>
::Write(StdObjMgt_WriteData& theWriteData) const;
//=======================================================================
// Cylindrical
//=======================================================================
template<>
Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom::subBase_gp<ShapePersistent_Geom::Surface, gp_Ax3>,
Geom_CylindricalSurface,
gp_Cylinder>
::PName() const;
template<>
void ShapePersistent_Geom::instance<ShapePersistent_Geom::subBase_gp<ShapePersistent_Geom::Surface, gp_Ax3>,
Geom_CylindricalSurface,
gp_Cylinder>
::Write(StdObjMgt_WriteData& theWriteData) const;
//=======================================================================
// Spherical
//=======================================================================
template<>
Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom::subBase_gp<ShapePersistent_Geom::Surface, gp_Ax3>,
Geom_SphericalSurface,
gp_Sphere>
::PName() const;
template<>
void ShapePersistent_Geom::instance<ShapePersistent_Geom::subBase_gp<ShapePersistent_Geom::Surface, gp_Ax3>,
Geom_SphericalSurface,
gp_Sphere>
::Write(StdObjMgt_WriteData& theWriteData) const;
//=======================================================================
// Toroidal
//=======================================================================
template<>
Standard_CString ShapePersistent_Geom::instance<ShapePersistent_Geom::subBase_gp<ShapePersistent_Geom::Surface, gp_Ax3>,
Geom_ToroidalSurface,
gp_Torus>
::PName() const;
template<>
void ShapePersistent_Geom::instance<ShapePersistent_Geom::subBase_gp<ShapePersistent_Geom::Surface, gp_Ax3>,
Geom_ToroidalSurface,
gp_Torus>
::Write(StdObjMgt_WriteData& theWriteData) const;
#endif

11
src/ShapePersistent/ShapePersistent_HArray1.hxx
View File

@ -49,7 +49,7 @@ public:
};
inline StdObjMgt_ReadData& operator >>
(StdObjMgt_ReadData& theReadData, Poly_Triangle& theTriangle)
(StdObjMgt_ReadData::Object theReadData, Poly_Triangle& theTriangle)
{
Standard_Integer N1, N2, N3;
theReadData >> N1 >> N2 >> N3;
@ -57,4 +57,13 @@ inline StdObjMgt_ReadData& operator >>
return theReadData;
}
inline StdObjMgt_WriteData& operator <<
(StdObjMgt_WriteData::Object theWriteData, const Poly_Triangle& theTriangle)
{
Standard_Integer N1, N2, N3;
theTriangle.Get(N1, N2, N3);
theWriteData << N1 << N2 << N3;
return theWriteData;
}
#endif

62
src/ShapePersistent/ShapePersistent_HSequence.cxx
View File

@ -11,8 +11,9 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <ShapePersistent_HSequence.hxx>
#include <StdObjMgt_ReadData.hxx>
#include <StdObjMgt_WriteData.hxx>
#include <ShapePersistent_HSequence.hxx>
template <class SequenceClass>
@ -22,6 +23,13 @@ void ShapePersistent_HSequence::node<SequenceClass>::Read
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)
@ -29,6 +37,13 @@ void ShapePersistent_HSequence::instance<SequenceClass>::Read
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
@ -50,3 +65,48 @@ template class ShapePersistent_HSequence::instance<TColgp_HSequenceOfXYZ>;
template class ShapePersistent_HSequence::instance<TColgp_HSequenceOfPnt>;
template class ShapePersistent_HSequence::instance<TColgp_HSequenceOfDir>;
template class ShapePersistent_HSequence::instance<TColgp_HSequenceOfVec>;
//=======================================================================
// XYZ
//=======================================================================
template<>
Standard_CString ShapePersistent_HSequence::instance<TColgp_HSequenceOfXYZ>
::PName() const { return "PColgp_HSequenceOfXYZ"; }
template<>
Standard_CString ShapePersistent_HSequence::node<TColgp_HSequenceOfXYZ>
::PName() const { return "PColgp_SeqNodeOfHSequenceOfXYZ"; }
//=======================================================================
// Pnt
//=======================================================================
template<>
Standard_CString ShapePersistent_HSequence::instance<TColgp_HSequenceOfPnt>
::PName() const { return "PColgp_HSequenceOfPnt"; }
template<>
Standard_CString ShapePersistent_HSequence::node<TColgp_HSequenceOfPnt>
::PName() const { return "PColgp_SeqNodeOfHSequenceOfPnt"; }
//=======================================================================
// Dir
//=======================================================================
template<>
Standard_CString ShapePersistent_HSequence::instance<TColgp_HSequenceOfDir>
::PName() const { return "PColgp_HSequenceOfDir"; }
template<>
Standard_CString ShapePersistent_HSequence::node<TColgp_HSequenceOfDir>
::PName() const { return "PColgp_SeqNodeOfHSequenceOffDir"; }
//=======================================================================
// Vec
//=======================================================================
template<>
Standard_CString ShapePersistent_HSequence::instance<TColgp_HSequenceOfVec>
::PName() const { return "PColgp_HSequenceOfVec"; }
template<>
Standard_CString ShapePersistent_HSequence::node<TColgp_HSequenceOfVec>
::PName() const { return "PColgp_SeqNodeOfHSequenceOfVec"; }

80
src/ShapePersistent/ShapePersistent_HSequence.hxx
View File

@ -15,6 +15,8 @@
#ifndef _ShapePersistent_HSequence_HeaderFile
#define _ShapePersistent_HSequence_HeaderFile
#include <Standard_NotImplemented.hxx>
#include <StdObjMgt_Persistent.hxx>
#include <StdObject_gp_Vectors.hxx>
@ -36,6 +38,23 @@ class ShapePersistent_HSequence
//! Read persistent data from a file.
Standard_EXPORT virtual void Read (StdObjMgt_ReadData& theReadData);
//! Write persistent data to a file.
Standard_EXPORT virtual void Write (StdObjMgt_WriteData& theWriteData) const;
//! Gets persistent objects
Standard_EXPORT virtual void PChildren (SequenceOfPersistent& theChildren) const
{
theChildren.Append(this->myPreviuos);
theChildren.Append(this->myNext);
}
//! Returns persistent type name
Standard_EXPORT virtual Standard_CString PName() const
{
Standard_NotImplemented::Raise("ShapePersistent_HSequence::node::PName - not implemented");
return "";
}
const Handle(node)& Previuos() const { return myPreviuos; }
const Handle(node)& Next() const { return myNext; }
const ItemType& Item() const { return myItem; }
@ -56,6 +75,23 @@ class ShapePersistent_HSequence
//! Read persistent data from a file.
Standard_EXPORT virtual void Read (StdObjMgt_ReadData& theReadData);
//! Write persistent data to a file.
Standard_EXPORT virtual void Write (StdObjMgt_WriteData& theWriteData) const;
//! Gets persistent objects
Standard_EXPORT virtual void PChildren(SequenceOfPersistent& theChildren) const
{
theChildren.Append(this->myFirst);
theChildren.Append(this->myLast);
}
//! Returns persistent type name
Standard_EXPORT virtual Standard_CString PName() const
{
Standard_NotImplemented::Raise("ShapePersistent_HSequence::instance::PName - not implemented");
return "";
}
//! Import transient object from the persistent data.
Standard_EXPORT Handle(SequenceClass) Import() const;
@ -72,4 +108,48 @@ public:
typedef instance<TColgp_HSequenceOfVec> Vec;
};
//=======================================================================
// XYZ
//=======================================================================
template<>
Standard_CString ShapePersistent_HSequence::instance<TColgp_HSequenceOfXYZ>
::PName() const;
template<>
Standard_CString ShapePersistent_HSequence::node<TColgp_HSequenceOfXYZ>
::PName() const;
//=======================================================================
// Pnt
//=======================================================================
template<>
Standard_CString ShapePersistent_HSequence::instance<TColgp_HSequenceOfPnt>
::PName() const;
template<>
Standard_CString ShapePersistent_HSequence::node<TColgp_HSequenceOfPnt>
::PName() const;
//=======================================================================
// Dir
//=======================================================================
template<>
Standard_CString ShapePersistent_HSequence::instance<TColgp_HSequenceOfDir>
::PName() const;
template<>
Standard_CString ShapePersistent_HSequence::node<TColgp_HSequenceOfDir>
::PName() const;
//=======================================================================
// Vec
//=======================================================================
template<>
Standard_CString ShapePersistent_HSequence::instance<TColgp_HSequenceOfVec>
::PName() const;
template<>
Standard_CString ShapePersistent_HSequence::node<TColgp_HSequenceOfVec>
::PName() const;
#endif

132
src/ShapePersistent/ShapePersistent_Poly.cxx
View File

@ -12,6 +12,7 @@
// commercial license or contractual agreement.
#include <ShapePersistent_Poly.hxx>
#include <ShapePersistent_HArray1.hxx>
#include <Poly_Polygon2D.hxx>
#include <Poly_Polygon3D.hxx>
@ -19,6 +20,12 @@
#include <Poly_Triangulation.hxx>
void ShapePersistent_Poly::pPolygon2D::PChildren
(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
{
theChildren.Append(myNodes);
}
Handle(Poly_Polygon2D) ShapePersistent_Poly::pPolygon2D::Import() const
{
if (myNodes.IsNull())
@ -29,6 +36,13 @@ Handle(Poly_Polygon2D) ShapePersistent_Poly::pPolygon2D::Import() const
return aPolygon;
}
void ShapePersistent_Poly::pPolygon3D::PChildren
(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
{
theChildren.Append(myNodes);
theChildren.Append(myParameters);
}
Handle(Poly_Polygon3D) ShapePersistent_Poly::pPolygon3D::Import() const
{
if (myNodes.IsNull() || myParameters.IsNull())
@ -40,6 +54,13 @@ Handle(Poly_Polygon3D) ShapePersistent_Poly::pPolygon3D::Import() const
return aPolygon;
}
void ShapePersistent_Poly::pPolygonOnTriangulation::PChildren
(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
{
theChildren.Append(myNodes);
theChildren.Append(myParameters);
}
Handle(Poly_PolygonOnTriangulation)
ShapePersistent_Poly::pPolygonOnTriangulation::Import() const
{
@ -59,12 +80,20 @@ Handle(Poly_PolygonOnTriangulation)
return aPolygon;
}
void ShapePersistent_Poly::pTriangulation::PChildren
(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
{
theChildren.Append(myNodes);
theChildren.Append(myUVNodes);
theChildren.Append(myTriangles);
}
Handle(Poly_Triangulation) ShapePersistent_Poly::pTriangulation::Import() const
{
Handle(Poly_Triangulation) aTriangulation;
// Triangulation is not used
#if 0
#if 1
if (myNodes && myTriangles)
{
if (myUVNodes)
@ -81,3 +110,104 @@ Handle(Poly_Triangulation) ShapePersistent_Poly::pTriangulation::Import() const
return aTriangulation;
}
Handle(ShapePersistent_Poly::Polygon2D)
ShapePersistent_Poly::Translate(const Handle(Poly_Polygon2D)& thePoly,
StdObjMgt_TransientPersistentMap& theMap)
{
Handle(Polygon2D) aPP;
if (!thePoly.IsNull())
{
if (theMap.IsBound(thePoly))
aPP = Handle(Polygon2D)::DownCast(theMap.Find(thePoly));
else
{
aPP = new Polygon2D;
aPP->myPersistent = new pPolygon2D;
aPP->myPersistent->myDeflection = thePoly->Deflection();
aPP->myPersistent->myNodes =
StdLPersistent_HArray1::Translate<TColgp_HArray1OfPnt2d>("PColgp_HArray1OfPnt2d", thePoly->Nodes());
theMap.Bind(thePoly, aPP);
}
}
return aPP;
}
Handle(ShapePersistent_Poly::Polygon3D)
ShapePersistent_Poly::Translate(const Handle(Poly_Polygon3D)& thePoly,
StdObjMgt_TransientPersistentMap& theMap)
{
Handle(Polygon3D) aPP = new Polygon3D;
if (!thePoly.IsNull())
{
if (theMap.IsBound(thePoly))
aPP = Handle(Polygon3D)::DownCast(theMap.Find(thePoly));
else
{
aPP = new Polygon3D;
aPP->myPersistent = new pPolygon3D;
aPP->myPersistent->myDeflection = thePoly->Deflection();
aPP->myPersistent->myNodes =
StdLPersistent_HArray1::Translate<TColgp_HArray1OfPnt>("PColgp_HArray1OfPnt", thePoly->Nodes());
if (thePoly->HasParameters()) {
aPP->myPersistent->myParameters =
StdLPersistent_HArray1::Translate<TColStd_HArray1OfReal>(thePoly->Parameters());
}
theMap.Bind(thePoly, aPP);
}
}
return aPP;
}
Handle(ShapePersistent_Poly::PolygonOnTriangulation)
ShapePersistent_Poly::Translate(const Handle(Poly_PolygonOnTriangulation)& thePolyOnTriang,
StdObjMgt_TransientPersistentMap& theMap)
{
Handle(PolygonOnTriangulation) aPPonT;
if (!thePolyOnTriang.IsNull())
{
if (theMap.IsBound(thePolyOnTriang))
aPPonT = Handle(PolygonOnTriangulation)::DownCast(theMap.Find(thePolyOnTriang));
else
{
aPPonT = new PolygonOnTriangulation;
aPPonT->myPersistent = new pPolygonOnTriangulation;
aPPonT->myPersistent->myDeflection = thePolyOnTriang->Deflection();
aPPonT->myPersistent->myNodes =
StdLPersistent_HArray1::Translate<TColStd_HArray1OfInteger>(thePolyOnTriang->Nodes());
if (thePolyOnTriang->HasParameters()) {
aPPonT->myPersistent->myParameters =
StdLPersistent_HArray1::Translate<TColStd_HArray1OfReal>(thePolyOnTriang->Parameters()->Array1());
}
theMap.Bind(thePolyOnTriang, aPPonT);
}
}
return aPPonT;
}
Handle(ShapePersistent_Poly::Triangulation)
ShapePersistent_Poly::Translate(const Handle(Poly_Triangulation)& thePolyTriang,
StdObjMgt_TransientPersistentMap& theMap)
{
Handle(Triangulation) aPT;
if (!thePolyTriang.IsNull())
{
if (theMap.IsBound(thePolyTriang))
aPT = Handle(Triangulation)::DownCast(theMap.Find(thePolyTriang));
else
{
aPT = new Triangulation;
aPT->myPersistent = new pTriangulation;
aPT->myPersistent->myNodes =
StdLPersistent_HArray1::Translate<TColgp_HArray1OfPnt>("PColgp_HArray1OfPnt", thePolyTriang->Nodes());
aPT->myPersistent->myTriangles =
StdLPersistent_HArray1::Translate<Poly_HArray1OfTriangle>("PPoly_HArray1OfTriangle", thePolyTriang->Triangles());
if (thePolyTriang->HasUVNodes()) {
aPT->myPersistent->myUVNodes =
StdLPersistent_HArray1::Translate<TColgp_HArray1OfPnt2d>("PColgp_HArray1OfPnt2d", thePolyTriang->UVNodes());
}
theMap.Bind(thePolyTriang, aPT);
}
}
return aPT;
}

42
src/ShapePersistent/ShapePersistent_Poly.hxx
View File

@ -16,7 +16,9 @@
#define _ShapePersistent_Poly_HeaderFile
#include <StdObjMgt_SharedObject.hxx>
#include <StdObjMgt_TransientPersistentMap.hxx>
#include <StdObjMgt_ReadData.hxx>
#include <StdObjMgt_WriteData.hxx>
#include <StdLPersistent_HArray1.hxx>
#include <ShapePersistent_HArray1.hxx>
@ -30,9 +32,15 @@ class ShapePersistent_Poly : private StdObjMgt_SharedObject
{
class pPolygon2D : public Standard_Transient
{
friend class ShapePersistent_Poly;
public:
inline void Read (StdObjMgt_ReadData& theReadData)
{ theReadData >> myDeflection >> myNodes; }
inline void Write (StdObjMgt_WriteData& theWriteData) const
{ theWriteData << myDeflection << myNodes; }
Standard_EXPORT void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const;
inline Standard_CString PName() const { return "PPoly_Polygon2D"; }
Handle(Poly_Polygon2D) Import() const;
@ -43,9 +51,15 @@ class ShapePersistent_Poly : private StdObjMgt_SharedObject
class pPolygon3D : public Standard_Transient
{
friend class ShapePersistent_Poly;
public:
inline void Read (StdObjMgt_ReadData& theReadData)
{ theReadData >> myDeflection >> myNodes >> myParameters; }
inline void Write (StdObjMgt_WriteData& theWriteData) const
{ theWriteData << myDeflection << myNodes << myParameters; }
Standard_EXPORT void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const;
inline Standard_CString PName() const { return "PPoly_Polygon3D"; }
Handle(Poly_Polygon3D) Import() const;
@ -57,9 +71,15 @@ class ShapePersistent_Poly : private StdObjMgt_SharedObject
class pPolygonOnTriangulation : public Standard_Transient
{
friend class ShapePersistent_Poly;
public:
inline void Read (StdObjMgt_ReadData& theReadData)
{ theReadData >> myDeflection >> myNodes >> myParameters; }
inline void Write (StdObjMgt_WriteData& theWriteData) const
{ theWriteData << myDeflection << myNodes << myParameters; }
Standard_EXPORT void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const;
inline Standard_CString PName() const { return "PPoly_PolygonOnTriangulation"; }
Handle(Poly_PolygonOnTriangulation) Import() const;
@ -71,9 +91,15 @@ class ShapePersistent_Poly : private StdObjMgt_SharedObject
class pTriangulation : public Standard_Transient
{
friend class ShapePersistent_Poly;
public:
inline void Read (StdObjMgt_ReadData& theReadData)
{ theReadData >> myDeflection >> myNodes >> myUVNodes >> myTriangles; }
inline void Write (StdObjMgt_WriteData& theWriteData) const
{ theWriteData << myDeflection << myNodes << myUVNodes << myTriangles; }
Standard_EXPORT void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const;
inline Standard_CString PName() const { return "PPoly_Triangulation"; }
Handle(Poly_Triangulation) Import() const;
@ -86,7 +112,7 @@ class ShapePersistent_Poly : private StdObjMgt_SharedObject
template <class Persistent, class Transient>
struct instance
: Delayed <DelayedBase<StdObjMgt_Persistent, Transient, Persistent> > {};
: public Delayed <DelayedBase<StdObjMgt_Persistent, Transient, Persistent> > {};
public:
typedef instance <pPolygon2D, Poly_Polygon2D> Polygon2D;
@ -94,6 +120,20 @@ public:
typedef instance <pPolygonOnTriangulation,
Poly_PolygonOnTriangulation> PolygonOnTriangulation;
typedef instance <pTriangulation, Poly_Triangulation> Triangulation;
public:
//! Create a persistent object for a 2D polygon
Standard_EXPORT static Handle(Polygon2D) Translate (const Handle(Poly_Polygon2D)& thePoly,
StdObjMgt_TransientPersistentMap& theMap);
//! Create a persistent object for a 3D polygon
Standard_EXPORT static Handle(Polygon3D) Translate (const Handle(Poly_Polygon3D)& thePoly,
StdObjMgt_TransientPersistentMap& theMap);
//! Create a persistent object for a triangulation
Standard_EXPORT static Handle(PolygonOnTriangulation) Translate (const Handle(Poly_PolygonOnTriangulation)& thePolyOnTriang,
StdObjMgt_TransientPersistentMap& theMap);
//! Create a persistent object for a polygon on triangulation
Standard_EXPORT static Handle(Triangulation) Translate(const Handle(Poly_Triangulation)& thePolyTriang,
StdObjMgt_TransientPersistentMap& theMap);
};
#endif

147
src/ShapePersistent/ShapePersistent_TopoDS.cxx
View File

@ -12,9 +12,15 @@
// commercial license or contractual agreement.
#include <ShapePersistent_TopoDS.hxx>
#include <ShapePersistent_BRep.hxx>
#include <BRep_Builder.hxx>
#include <TopoDS.hxx>
#include <TopoDS_Iterator.hxx>
#include <TopoDS_Vertex.hxx>
#include <Standard_Assert.hxx>
enum
{
@ -26,7 +32,6 @@ enum
ConvexMask = 64
};
//=======================================================================
//function : Read
//purpose : Read persistent data from a file
@ -37,6 +42,18 @@ void ShapePersistent_TopoDS::HShape::Read (StdObjMgt_ReadData& theReadData)
StdObject_Shape::read (theReadData);
}
void ShapePersistent_TopoDS::HShape::Write (StdObjMgt_WriteData& theWriteData) const
{
theWriteData << myEntry;
StdObject_Shape::write (theWriteData);
}
void ShapePersistent_TopoDS::HShape::PChildren(SequenceOfPersistent& theChildren) const
{
theChildren.Append(myEntry);
StdObject_Shape::PChildren(theChildren);
}
void ShapePersistent_TopoDS::pTBase::setFlags
(const Handle(TopoDS_TShape)& theTShape) const
{
@ -94,3 +111,131 @@ template class ShapePersistent_TopoDS::pTSimple<TopoDS_TShell>;
template class ShapePersistent_TopoDS::pTSimple<TopoDS_TSolid>;
template class ShapePersistent_TopoDS::pTSimple<TopoDS_TCompSolid>;
template class ShapePersistent_TopoDS::pTSimple<TopoDS_TCompound>;
//=======================================================================
//function : Translate
//purpose : Creates a persistent object from a shape
//=======================================================================
Handle(ShapePersistent_TopoDS::HShape)
ShapePersistent_TopoDS::Translate (const TopoDS_Shape& theShape,
StdObjMgt_TransientPersistentMap& theMap,
ShapePersistent_TriangleMode theTriangleMode)
{
Handle(HShape) pHShape;
if (theShape.IsNull())
return pHShape;
pHShape = new HShape;
if (theMap.IsBound(theShape.TShape()))
{
// found in the registered
Handle(StdPersistent_TopoDS::TShape) aPShape =
Handle(StdPersistent_TopoDS::TShape)::DownCast(theMap.Find(theShape.TShape()));
pHShape->myTShape = aPShape;
}
else
{
pTShape* aPTShape = 0;
switch (theShape.ShapeType())
{
case TopAbs_VERTEX: {
Handle(ShapePersistent_BRep::TVertex) aPVertex = new ShapePersistent_BRep::TVertex;
pHShape->myTShape = aPVertex;
aPVertex->myPersistent = ShapePersistent_BRep::Translate(TopoDS::Vertex(theShape), theMap);
aPTShape = aPVertex->myPersistent.get();
} break;
case TopAbs_EDGE: {
Handle(ShapePersistent_BRep::TEdge) aPEdge = new ShapePersistent_BRep::TEdge;
pHShape->myTShape = aPEdge;
aPEdge->myPersistent = ShapePersistent_BRep::Translate(TopoDS::Edge(theShape), theMap, theTriangleMode);
aPTShape = aPEdge->myPersistent.get();
} break;
case TopAbs_FACE: {
Handle(ShapePersistent_BRep::TFace) aPFace = new ShapePersistent_BRep::TFace;
pHShape->myTShape = aPFace;
aPFace->myPersistent = ShapePersistent_BRep::Translate(TopoDS::Face(theShape), theMap, theTriangleMode);
aPTShape = aPFace->myPersistent.get();
} break;
case TopAbs_WIRE: {
Handle(TWire) aPWire = new TWire;
pHShape->myTShape = aPWire;
aPWire->myPersistent = new TWire::pTObjectT;
aPTShape = aPWire->myPersistent.get();
} break;
case TopAbs_SHELL: {
Handle(TShell) aPShell = new TShell;
pHShape->myTShape = aPShell;
aPShell->myPersistent = new TShell::pTObjectT;
aPTShape = aPShell->myPersistent.get();
} break;
case TopAbs_SOLID: {
Handle(TSolid) aPSolid = new TSolid;
pHShape->myTShape = aPSolid;
aPSolid->myPersistent = new TSolid::pTObjectT;
aPTShape = aPSolid->myPersistent.get();
} break;
case TopAbs_COMPSOLID: {
Handle(TCompSolid) aPCompSolid = new TCompSolid;
pHShape->myTShape = aPCompSolid;
aPCompSolid->myPersistent = new TCompSolid::pTObjectT;
aPTShape = aPCompSolid->myPersistent.get();
} break;
case TopAbs_COMPOUND: {
Handle(TCompound) aPComp = new TCompound;
pHShape->myTShape = aPComp;
aPComp->myPersistent = new TCompound::pTObjectT;
aPTShape = aPComp->myPersistent.get();
} break;
case TopAbs_SHAPE:
default:
Standard_ASSERT_INVOKE ("Unsupported shape type");
break;
}
// Register in the persistent map
theMap.Bind(theShape.TShape(), pHShape->myTShape);
// Shape flags
Standard_Integer aFlags = 0;
if (theShape.Modified()) aFlags |= ModifiedMask;
if (theShape.Checked()) aFlags |= CheckedMask;
if (theShape.Orientable()) aFlags |= OrientableMask;
if (theShape.Closed()) aFlags |= ClosedMask;
if (theShape.Infinite()) aFlags |= InfiniteMask;
if (theShape.Convex()) aFlags |= ConvexMask;
aPTShape->myFlags = aFlags;
// Copy current Shape
TopoDS_Shape S = theShape;
S.Orientation(TopAbs_FORWARD);
S.Location(TopLoc_Location());
// Count the number of <sub-shape> of the Shape's TShape
Standard_Integer nbElem = 0;
TopoDS_Iterator anItCount(S);
while (anItCount.More()) {
++nbElem;
anItCount.Next();
}
if (nbElem > 0)
{
Handle(StdLPersistent_HArray1OfPersistent) aShapes =
new StdLPersistent_HArray1OfPersistent(1, nbElem);
// translate <sub-shapes>
TopoDS_Iterator anItTrans(S);
for (Standard_Integer i = 1; anItTrans.More(); anItTrans.Next(), ++i) {
aShapes->SetValue(i, Translate(anItTrans.Value(), theMap, theTriangleMode));
}
aPTShape->myShapes = StdLPersistent_HArray1::Translate<StdLPersistent_HArray1OfPersistent>
("PTopoDS_HArray1OfHShape", aShapes->Array1());
}
}
pHShape->myOrient = theShape.Orientation();
pHShape->myLocation = StdObject_Location::Translate(theShape.Location(), theMap);
return pHShape;
}

54
src/ShapePersistent/ShapePersistent_TopoDS.hxx
View File

@ -15,10 +15,13 @@
#ifndef _ShapePersistent_TopoDS_HeaderFile
#define _ShapePersistent_TopoDS_HeaderFile
#include <ShapePersistent_TriangleMode.hxx>
#include <StdPersistent_TopoDS.hxx>
#include <StdPersistent_HArray1.hxx>
#include <StdLPersistent_HArray1.hxx>
#include <StdObject_Shape.hxx>
#include <StdObjMgt_TransientPersistentMap.hxx>
#include <TopoDS_TWire.hxx>
#include <TopoDS_TShell.hxx>
@ -35,6 +38,12 @@ public:
public:
//! Read persistent data from a file.
Standard_EXPORT virtual void Read (StdObjMgt_ReadData& theReadData);
//! Write persistent data to a file
Standard_EXPORT virtual void Write (StdObjMgt_WriteData& theWriteData) const;
//! Gets persistent child objects
Standard_EXPORT virtual void PChildren(SequenceOfPersistent& theChildren) const;
//! Returns persistent type name
Standard_EXPORT virtual Standard_CString PName() const { return "PTopoDS_HShape"; }
private:
Handle(StdObjMgt_Persistent) myEntry;
@ -72,27 +81,30 @@ protected:
private:
template <class Target>
class pTSimple : public pTBase
{ virtual Handle(TopoDS_TShape) createTShape() const; };
{
virtual Handle(TopoDS_TShape) createTShape() const;
public:
inline Standard_CString PName() const;
};
template <class Persistent, class ShapesArray>
class pTObject : public Persistent
{
virtual void addShapes (TopoDS_Shape& theParent) const
{
pTBase::addShapesT<ShapesArray> (theParent);
}
{ pTBase::addShapesT<ShapesArray> (theParent); }
};
template <class Persistent, class ShapesArray>
struct tObjectT : Delayed <DelayedBase<TShape, TopoDS_TShape, pTBase>,
pTObject<Persistent, ShapesArray> > {};
struct tObjectT : public Delayed <DelayedBase<TShape, TopoDS_TShape, pTBase>,
pTObject<Persistent, ShapesArray> >
{ typedef pTObject<Persistent, ShapesArray> pTObjectT; };
protected:
template <class Persistent>
struct tObject : tObjectT<Persistent, StdLPersistent_HArray1::Persistent> {};
struct tObject : public tObjectT<Persistent, StdLPersistent_HArray1::Persistent> { };
template <class Persistent>
struct tObject1 : tObjectT<Persistent, StdPersistent_HArray1::Shape1> {};
struct tObject1 : public tObjectT<Persistent, StdPersistent_HArray1::Shape1> { };
public:
typedef tObject <pTSimple<TopoDS_TWire> > TWire;
@ -106,6 +118,32 @@ public:
typedef tObject1 <pTSimple<TopoDS_TSolid> > TSolid1;
typedef tObject1 <pTSimple<TopoDS_TCompSolid> > TCompSolid1;
typedef tObject1 <pTSimple<TopoDS_TCompound> > TCompound1;
public:
//! Create a persistent object for a shape
Standard_EXPORT static Handle(HShape) Translate (const TopoDS_Shape& theShape,
StdObjMgt_TransientPersistentMap& theMap,
ShapePersistent_TriangleMode theTriangleMode);
};
template<>
inline Standard_CString ShapePersistent_TopoDS::pTSimple<TopoDS_TWire>::PName() const
{ return "PTopoDS_TWire"; }
template<>
inline Standard_CString ShapePersistent_TopoDS::pTSimple<TopoDS_TShell>::PName() const
{ return "PTopoDS_TShell"; }
template<>
inline Standard_CString ShapePersistent_TopoDS::pTSimple<TopoDS_TSolid>::PName() const
{ return "PTopoDS_TSolid"; }
template<>
inline Standard_CString ShapePersistent_TopoDS::pTSimple<TopoDS_TCompSolid>::PName() const
{ return "PTopoDS_TCompSolid"; }
template<>
inline Standard_CString ShapePersistent_TopoDS::pTSimple<TopoDS_TCompound>::PName() const
{ return "PTopoDS_TCompound"; }
#endif

14
src/ShapePersistent/ShapePersistent_TriangleMode.hxx Normal file
View File

@ -0,0 +1,14 @@
#ifndef _ShapePersistent_TriangleMode_HeaderFile
#define _ShapePersistent_TriangleMode_HeaderFile
#include <Standard_PrimitiveTypes.hxx>
enum ShapePersistent_TriangleMode
{
ShapePersistent_WithTriangle,
ShapePersistent_WithoutTriangle
};
#endif // _ShapePersistent_TriangleMode_HeaderFile

6
src/StdLDrivers/StdLDrivers_DocumentRetrievalDriver.cxx
View File

@ -131,8 +131,8 @@ Handle(StdObjMgt_Persistent) StdLDrivers_DocumentRetrievalDriver::read (
NCollection_Array1<StdObjMgt_Persistent::Instantiator>
anInstantiators (1, aTypeData.NumberOfTypes());
{
StdObjMgt_MapOfInstantiators aMapOfInstantiators;
bindTypes (aMapOfInstantiators);
StdObjMgt_MapOfInstantiators aMapOfInst;
bindTypes (aMapOfInst);
TColStd_SequenceOfAsciiString anUnknownTypes;
Standard_Integer aCurTypeNum;
@ -144,7 +144,7 @@ Handle(StdObjMgt_Persistent) StdLDrivers_DocumentRetrievalDriver::read (
aCurTypeNum = aTypeData.Type (aCurTypeName);
StdObjMgt_Persistent::Instantiator anInstantiator;
if (aMapOfInstantiators.Find (aCurTypeName, anInstantiator))
if (aMapOfInst.Find(aCurTypeName, anInstantiator))
anInstantiators (aCurTypeNum) = anInstantiator;
else
anUnknownTypes.Append (aCurTypeName);

10
src/StdLPersistent/StdLPersistent_Data.cxx
View File

@ -13,6 +13,7 @@
#include <StdLPersistent_Data.hxx>
#include <StdObjMgt_ReadData.hxx>
#include <StdObjMgt_WriteData.hxx>
#include <TDF_Data.hxx>
#include <TDF_Attribute.hxx>
@ -80,6 +81,15 @@ void StdLPersistent_Data::Read (StdObjMgt_ReadData& theReadData)
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

11
src/StdLPersistent/StdLPersistent_Data.hxx
View File

@ -26,6 +26,17 @@ class StdLPersistent_Data : public StdObjMgt_Persistent
public:
//! Read persistent data from a file.
Standard_EXPORT virtual void Read (StdObjMgt_ReadData& theReadData);
//! Write persistent data to a file.
Standard_EXPORT virtual void Write (StdObjMgt_WriteData& theWriteData) const;
//! Gets persistent child objects
Standard_EXPORT virtual void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
{
theChildren.Append(myLabels);
theChildren.Append(myAttributes);
}
//! Returns persistent type name
Standard_EXPORT virtual Standard_CString PName() const
{ return "PDF_Data"; }
//! Import transient data from the persistent data.
Standard_EXPORT Handle(TDF_Data) Import() const;

19
src/StdLPersistent/StdLPersistent_Dependency.hxx
View File

@ -32,6 +32,17 @@ class StdLPersistent_Dependency
//! Read persistent data from a file.
inline void Read (StdObjMgt_ReadData& theReadData)
{ theReadData >> myName >> myVariables; }
//! Write persistent data to a file.
inline void Write (StdObjMgt_WriteData& theWriteData) const
{ theWriteData << myName << myVariables; }
//! Gets persistent child objects
inline void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
{
theChildren.Append(myName);
theChildren.Append(myVariables);
}
//! Returns persistent type name
Standard_CString PName() const;
//! Import transient attribuite from the persistent data.
void Import (const Handle(AttribClass)& theAttribute) const;
@ -46,4 +57,12 @@ public:
typedef instance<TDataStd_Relation> Relation;
};
template<>
inline Standard_CString StdLPersistent_Dependency::instance<TDataStd_Expression>::PName() const
{ return "PDataStd_Expression"; }
template<>
inline Standard_CString StdLPersistent_Dependency::instance<TDataStd_Relation>::PName() const
{ return "PDataStd_Relation"; }
#endif

19
src/StdLPersistent/StdLPersistent_Document.cxx
View File

@ -14,6 +14,7 @@
#include <StdLPersistent_Document.hxx>
#include <StdLPersistent_Data.hxx>
#include <StdObjMgt_ReadData.hxx>
#include <StdObjMgt_WriteData.hxx>
#include <TDocStd_Document.hxx>
#include <TDocStd_Owner.hxx>
@ -28,6 +29,24 @@ void StdLPersistent_Document::Read (StdObjMgt_ReadData& theReadData)
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

7
src/StdLPersistent/StdLPersistent_Document.hxx
View File

@ -26,6 +26,13 @@ class StdLPersistent_Document : public StdObjMgt_Persistent
public:
//! Read persistent data from a file.
Standard_EXPORT virtual void Read (StdObjMgt_ReadData& theReadData);
//! Read persistent data from a file.
Standard_EXPORT virtual void Write (StdObjMgt_WriteData& theWriteData) const;
//! Gets persistent child objects
Standard_EXPORT virtual void PChildren(StdObjMgt_Persistent::SequenceOfPersistent&) const;
//! Returns persistent type name
Standard_EXPORT virtual Standard_CString PName() const
{ return "PDocStd_Document"; }
//! Import transient document from the persistent data.
Standard_EXPORT virtual void ImportDocument

7
src/StdLPersistent/StdLPersistent_Function.hxx
View File

@ -27,6 +27,13 @@ public:
//! Read persistent data from a file.
inline void Read (StdObjMgt_ReadData& theReadData)
{ theReadData >> myDriverGUID >> myFailure; }
//! Write persistent data to a file.
inline void Write (StdObjMgt_WriteData& theWriteData) const
{ theWriteData << myDriverGUID << myFailure; }
//! Gets persistent child objects
inline void PChildren(StdObjMgt_Persistent::SequenceOfPersistent&) const {}
//! Returns persistent type name
inline Standard_CString PName() const { return "PFunction_Function"; }
//! Import transient attribuite from the persistent data.
void Import (const Handle(TFunction_Function)& theAttribute) const

18
src/StdLPersistent/StdLPersistent_HArray1.cxx
View File

@ -32,3 +32,21 @@ void StdLPersistent_HArray1::base::Read (StdObjMgt_ReadData& theReadData)
for (Standard_Integer i = aLowerBound; i <= anUpperBound; i++)
readValue (anObjectData, i);
}
//=======================================================================
//function : Write
//purpose : Write persistent data to a file
//=======================================================================
void StdLPersistent_HArray1::base::Write (StdObjMgt_WriteData& theWriteData) const
{
Standard_Integer aLowerBound = lowerBound(), anUpperBound = upperBound();
theWriteData << aLowerBound << anUpperBound;
StdObjMgt_WriteData::Object anObjectData(theWriteData);
Standard_Integer aSize = anUpperBound - aLowerBound + 1;
anObjectData << aSize;
for (Standard_Integer i = aLowerBound; i <= anUpperBound; i++)
writeValue(theWriteData, i);
}

92
src/StdLPersistent/StdLPersistent_HArray1.hxx
View File

@ -15,8 +15,12 @@
#ifndef _StdLPersistent_HArray1_HeaderFile
#define _StdLPersistent_HArray1_HeaderFile
#include <Standard_NotImplemented.hxx>
#include <Standard_NullValue.hxx>
#include <StdObjMgt_Persistent.hxx>
#include <StdObjMgt_ReadData.hxx>
#include <StdObjMgt_WriteData.hxx>
#include <NCollection_DefineHArray1.hxx>
@ -40,19 +44,27 @@ class StdLPersistent_HArray1
public:
//! Read persistent data from a file.
Standard_EXPORT virtual void Read (StdObjMgt_ReadData& theReadData);
//! Write persistent data to a file.
Standard_EXPORT virtual void Write (StdObjMgt_WriteData& theWriteData) const;
protected:
virtual Standard_Integer lowerBound() const = 0;
virtual Standard_Integer upperBound() const = 0;
virtual void createArray (const Standard_Integer theLowerBound,
const Standard_Integer theUpperBound) = 0;
virtual void readValue (StdObjMgt_ReadData& theReadData,
const Standard_Integer theIndex) = 0;
virtual void writeValue(StdObjMgt_WriteData& theWriteData,
const Standard_Integer theIndex) const = 0;
};
protected:
template <class ArrayClass>
class instance : public base
{
friend class StdLPersistent_HArray1;
public:
typedef Handle(ArrayClass) ArrayHandle;
typedef typename ArrayClass::value_type ValueType;
@ -63,27 +75,105 @@ protected:
const Handle(ArrayClass)& Array() const { return myArray; }
protected:
virtual void createArray (const Standard_Integer theLowerBound,
virtual Standard_Integer lowerBound() const { return myArray->Lower(); }
virtual Standard_Integer upperBound() const { return myArray->Upper(); }
virtual void createArray(const Standard_Integer theLowerBound,
const Standard_Integer theUpperBound)
{ myArray = new ArrayClass (theLowerBound, theUpperBound); }
virtual void readValue (StdObjMgt_ReadData& theReadData,
const Standard_Integer theIndex)
{ theReadData >> myArray->ChangeValue (theIndex); }
virtual void writeValue(StdObjMgt_WriteData& theWriteData,
const Standard_Integer theIndex) const
{ theWriteData << myArray->Value(theIndex); }
virtual void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
{ return PChildrenT(theChildren); }
virtual Standard_CString PName() const
{ return PNameT(); }
Standard_CString PNameT() const
{
Standard_NotImplemented::Raise("StdLPersistent_HArray1::instance::PName - not implemented");
return "";
}
void PChildrenT(StdObjMgt_Persistent::SequenceOfPersistent&) const {}
protected:
Handle(ArrayClass) myArray;
};
template <class ArrayClass>
class named_instance : public instance<ArrayClass>
{
friend class StdLPersistent_HArray1;
public:
virtual Standard_CString PName() const
{
Standard_NullValue_Raise_if(!myPName,
"StdLPersistent_HArray1::named_instance::PName - name not set");
return myPName;
}
protected:
named_instance(Standard_CString thePName) : myPName(thePName) {}
Standard_CString myPName;
};
public:
typedef instance<TColStd_HArray1OfInteger> Integer;
typedef instance<TColStd_HArray1OfReal> Real;
typedef instance<TColStd_HArray1OfByte> Byte;
typedef instance<StdLPersistent_HArray1OfPersistent> Persistent;
public:
template <class ArrayClass>
static Handle(instance<ArrayClass>) Translate(const ArrayClass& theArray)
{
Handle(instance<ArrayClass>) aPArray = new instance<ArrayClass>;
aPArray->myArray = new ArrayClass(theArray.Lower(), theArray.Upper());
for (Standard_Integer i = theArray.Lower(); i <= theArray.Upper(); ++i)
aPArray->myArray->ChangeValue(i) = theArray.Value(i);
return aPArray;
}
template <class ArrayClass>
static Handle(instance<ArrayClass>) Translate(Standard_CString thePName, const ArrayClass& theArray)
{
Handle(named_instance<ArrayClass>) aPArray = new named_instance<ArrayClass>(thePName);
aPArray->myArray = new ArrayClass(theArray.Lower(), theArray.Upper());
for (Standard_Integer i = theArray.Lower(); i <= theArray.Upper(); ++i)
aPArray->myArray->ChangeValue(i) = theArray.Value(i);
return aPArray;
}
};
template<>
inline Standard_CString StdLPersistent_HArray1::instance<TColStd_HArray1OfInteger>::PNameT() const
{ return "PColStd_HArray1OfInteger"; }
template<>
inline Standard_CString StdLPersistent_HArray1::instance<TColStd_HArray1OfReal>::PNameT() const
{ return "PColStd_HArray1OfReal"; }
template<>
inline Standard_CString StdLPersistent_HArray1::instance<TColStd_HArray1OfByte>::PNameT() const
{ return "PColStd_HArray1OfByte"; }
inline StdObjMgt_ReadData& operator >>
(StdObjMgt_ReadData& theReadData, Standard_Byte& theByte)
{ return theReadData >> reinterpret_cast<Standard_Character&> (theByte); }
inline StdObjMgt_WriteData& operator >>
(StdObjMgt_WriteData& theWriteData, const Standard_Byte& theByte)
{ return theWriteData << reinterpret_cast<const Standard_Character&> (theByte); }
template<>
inline void StdLPersistent_HArray1::instance<StdLPersistent_HArray1OfPersistent>::PChildrenT
(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
{
for (Standard_Integer i = myArray->Lower(); i <= myArray->Upper(); ++i)
theChildren.Append(myArray->Value(i));
}
#endif

21
src/StdLPersistent/StdLPersistent_HArray2.cxx
View File

@ -36,3 +36,24 @@ void StdLPersistent_HArray2::base::Read (StdObjMgt_ReadData& theReadData)
for (Standard_Integer aCol = aLowerCol; aCol <= anUpperCol; aCol++)
readValue (anObjectData, aRow, aCol);
}
//=======================================================================
//function : Read
//purpose : Read persistent data from a file
//=======================================================================
void StdLPersistent_HArray2::base::Write (StdObjMgt_WriteData& theWriteData) const
{
Standard_Integer aLowerRow, aLowerCol, anUpperRow, anUpperCol;
lowerBound(aLowerRow, aLowerCol);
upperBound(anUpperRow, anUpperCol);
theWriteData << aLowerRow << aLowerCol << anUpperRow << anUpperCol;
StdObjMgt_WriteData::Object anObjectData(theWriteData);
Standard_Integer aSize = (anUpperRow - aLowerRow + 1) * (anUpperCol - aLowerCol + 1);
anObjectData << aSize;
for (Standard_Integer aRow = aLowerRow; aRow <= anUpperRow; aRow++)
for (Standard_Integer aCol = aLowerCol; aCol <= anUpperCol; aCol++)
writeValue(anObjectData, aRow, aCol);
}

109
src/StdLPersistent/StdLPersistent_HArray2.hxx
View File

@ -15,8 +15,12 @@
#ifndef _StdLPersistent_HArray2_HeaderFile
#define _StdLPersistent_HArray2_HeaderFile
#include <Standard_NotImplemented.hxx>
#include <Standard_NullValue.hxx>
#include <StdObjMgt_Persistent.hxx>
#include <StdObjMgt_ReadData.hxx>
#include <StdObjMgt_WriteData.hxx>
#include <NCollection_DefineHArray2.hxx>
@ -36,8 +40,15 @@ class StdLPersistent_HArray2
//! Read persistent data from a file.
Standard_EXPORT virtual void Read (StdObjMgt_ReadData& theReadData);
//! Read persistent data from a file.
Standard_EXPORT virtual void Write (StdObjMgt_WriteData& theWriteData) const;
protected:
virtual void createArray (
virtual void lowerBound(Standard_Integer& theRow,
Standard_Integer& theCol) const = 0;
virtual void upperBound(Standard_Integer& theRow,
Standard_Integer& theCol) const = 0;
virtual void createArray(
const Standard_Integer theLowerRow, const Standard_Integer theLowerCol,
const Standard_Integer theUpperRow, const Standard_Integer theUpperCol)
= 0;
@ -45,12 +56,17 @@ class StdLPersistent_HArray2
virtual void readValue (StdObjMgt_ReadData& theReadData,
const Standard_Integer theRow,
const Standard_Integer theCol) = 0;
virtual void writeValue(StdObjMgt_WriteData& theWriteData,
const Standard_Integer theRow,
const Standard_Integer theCol) const = 0;
};
protected:
template <class ArrayClass>
class instance : public base
{
friend class StdLPersistent_HArray2;
public:
typedef Handle(ArrayClass) ArrayHandle;
@ -59,27 +75,114 @@ protected:
const Handle(ArrayClass)& Array() const { return myArray; }
protected:
virtual void createArray (
virtual void lowerBound(Standard_Integer& theRow,
Standard_Integer& theCol) const
{
theRow = myArray->LowerRow();
theCol = myArray->LowerCol();
}
virtual void upperBound(Standard_Integer& theRow,
Standard_Integer& theCol) const
{
theRow = myArray->UpperRow();
theCol = myArray->UpperCol();
}
virtual void createArray(
const Standard_Integer theLowerRow, const Standard_Integer theLowerCol,
const Standard_Integer theUpperRow, const Standard_Integer theUpperCol)
{
myArray = new ArrayClass (theLowerRow, theUpperRow,
theLowerCol, theUpperCol);
}
virtual void readValue (StdObjMgt_ReadData& theReadData,
const Standard_Integer theRow,
const Standard_Integer theCol)
{ theReadData >> myArray->ChangeValue (theRow, theCol); }
virtual void writeValue(StdObjMgt_WriteData& theWriteData,
const Standard_Integer theRow,
const Standard_Integer theCol) const
{
theWriteData << myArray->Value(theRow, theCol);
}
virtual void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
{ return PChildrenT(theChildren); }
virtual Standard_CString PName() const
{ return PNameT(); }
Standard_CString PNameT() const
{
Standard_NotImplemented::Raise("StdLPersistent_HArray2::instance::PName - not implemented");
return "";
}
void PChildrenT(StdObjMgt_Persistent::SequenceOfPersistent&) const {}
protected:
Handle(ArrayClass) myArray;
};
template <class ArrayClass>
class named_instance : public instance<ArrayClass>
{
friend class StdLPersistent_HArray2;
public:
virtual Standard_CString PName() const
{
Standard_NullValue_Raise_if(!myPName,
"StdLPersistent_HArray2::named_instance::PName - name not set");
return myPName;
}
protected:
named_instance(Standard_CString thePName) : myPName(thePName) {}
Standard_CString myPName;
};
public:
typedef instance<TColStd_HArray2OfInteger> Integer;
typedef instance<TColStd_HArray2OfReal> Real;
typedef instance<StdLPersistent_HArray2OfPersistent> Persistent;
public:
template <class ArrayClass>
static Handle(instance<ArrayClass>) Translate(const ArrayClass& theArray)
{
Handle(instance<ArrayClass>) aPArray = new instance<ArrayClass>;
aPArray->myArray = new ArrayClass(theArray.LowerRow(), theArray.UpperRow(),
theArray.LowerCol(), theArray.UpperCol());
for (Standard_Integer i = theArray.LowerRow(); i <= theArray.UpperRow(); ++i)
for (Standard_Integer j = theArray.LowerCol(); j <= theArray.UpperCol(); ++j)
aPArray->myArray->ChangeValue(i, j) = theArray.Value(i, j);
return aPArray;
}
template <class ArrayClass>
static Handle(instance<ArrayClass>) Translate(Standard_CString thePName, const ArrayClass& theArray)
{
Handle(named_instance<ArrayClass>) aPArray = new named_instance<ArrayClass>(thePName);
aPArray->myArray = new ArrayClass(theArray.LowerRow(), theArray.UpperRow(),
theArray.LowerCol(), theArray.UpperCol());
for (Standard_Integer i = theArray.LowerRow(); i <= theArray.UpperRow(); ++i)
for (Standard_Integer j = theArray.LowerCol(); j <= theArray.UpperCol(); ++j)
aPArray->myArray->ChangeValue(i, j) = theArray.Value(i, j);
return aPArray;
}
};
template<>
inline Standard_CString StdLPersistent_HArray2::instance<TColStd_HArray2OfInteger>::PNameT() const
{ return "PColStd_HArray2OfInteger"; }
template<>
inline Standard_CString StdLPersistent_HArray2::instance<TColStd_HArray2OfReal>::PNameT() const
{ return "PColStd_HArray2OfReal"; }
template<>
inline void StdLPersistent_HArray2::instance<StdLPersistent_HArray2OfPersistent>::PChildrenT
(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
{
for (Standard_Integer i = myArray->LowerRow(); i <= myArray->UpperRow(); ++i)
for (Standard_Integer j = myArray->LowerCol(); j <= myArray->UpperCol(); ++j)
theChildren.Append(myArray->Value(i, j));
}
#endif

21
src/StdLPersistent/StdLPersistent_HString.cxx
View File

@ -13,6 +13,7 @@
#include <StdLPersistent_HString.hxx>
#include <StdObjMgt_ReadData.hxx>
#include <StdObjMgt_WriteData.hxx>
#include <TDF_Label.hxx>
#include <TDF_Tool.hxx>
@ -39,6 +40,26 @@ void StdLPersistent_HString::instance<StringClass, CharType>::Read
}
}
//=======================================================================
//function : Write
//purpose : Write persistent data to a file
//=======================================================================
template <class StringClass, typename CharType>
void StdLPersistent_HString::instance<StringClass, CharType>::Write
(StdObjMgt_WriteData& theWriteData) const
{
StdObjMgt_WriteData::Object anObjectData(theWriteData);
Standard_Integer aSize = myValue->Length();
anObjectData << aSize;
for (Standard_Integer i = 1; i <= aSize; i++)
{
CharType aChar (0);
anObjectData << aChar;
}
}
//=======================================================================
//function : Label
//purpose : Get/create a label defined by referenced string

7
src/StdLPersistent/StdLPersistent_HString.hxx
View File

@ -30,6 +30,9 @@ class StdLPersistent_HString
public:
//! Read persistent data from a file.
Standard_EXPORT virtual void Read (StdObjMgt_ReadData& theReadData);
//! Write persistent data to a file.
Standard_EXPORT virtual void Write (StdObjMgt_WriteData& theWriteData) const;
Standard_EXPORT virtual void PChildren(StdObjMgt_Persistent::SequenceOfPersistent&) const { }
//! Get/create a label defined by referenced string.
Standard_EXPORT virtual TDF_Label Label (const Handle(TDF_Data)& theDF) const;
@ -48,6 +51,8 @@ public:
public:
//! Get referenced ASCII string.
Standard_EXPORT virtual Handle(TCollection_HAsciiString) AsciiString() const;
inline Standard_CString PName() const { return "PCollection_HAsciiString"; }
};
class Extended
@ -56,6 +61,8 @@ public:
public:
//! Get referenced extended string.
Standard_EXPORT virtual Handle(TCollection_HExtendedString) ExtString() const;
inline Standard_CString PName() const { return "PCollection_HExtendedString"; }
};
};

20
src/StdLPersistent/StdLPersistent_NamedData.hxx
View File

@ -32,6 +32,8 @@ class StdLPersistent_NamedData : public StdObjMgt_Attribute<TDataStd_NamedData>
inline void Read (StdObjMgt_ReadData& theReadData)
{ theReadData >> myKeys >> myValues; }
inline void Write (StdObjMgt_WriteData& theWriteData) const
{ theWriteData << myKeys << myValues; }
inline operator bool() const
{ return !myKeys.IsNull(); }
@ -60,6 +62,24 @@ public:
myRealArrays.Read (theReadData);
}
//! Write persistent data to a file.
inline void Write (StdObjMgt_WriteData& theWriteData) const
{
theWriteData << myDimensions;
myInts.Write(theWriteData);
myReals.Write(theWriteData);
myStrings.Write(theWriteData);
myBytes.Write(theWriteData);
myIntArrays.Write(theWriteData);
myRealArrays.Write(theWriteData);
}
//! Gets persistent child objects
void PChildren(StdObjMgt_Persistent::SequenceOfPersistent&) const {}
//! Returns persistent type name
Standard_CString PName() const { return "PDataStd_NamedData"; }
//! Import transient attribuite from the persistent data.
void Import (const Handle(TDataStd_NamedData)& theAttribute) const;

9
src/StdLPersistent/StdLPersistent_Real.hxx
View File

@ -26,13 +26,20 @@ public:
//! Read persistent data from a file.
inline void Read (StdObjMgt_ReadData& theReadData)
{ theReadData >> myValue >> myDimension; }
//! Write persistent data from a file.
inline void Write (StdObjMgt_WriteData& theWriteData) const
{ theWriteData << myValue << myDimension; }
//! Gets persistent child objects
void PChildren(StdObjMgt_Persistent::SequenceOfPersistent&) const {}
//! Returns persistent type name
Standard_CString PName() const { return "PDataStd_Real"; }
//! Import transient attribuite from the persistent data.
void Import (const Handle(TDataStd_Real)& theAttribute) const
{
theAttribute->Set (myValue);
theAttribute->SetDimension (static_cast<TDataStd_RealEnum> (myDimension));
theAttribute->SetID(TDataStd_Real::GetID());
theAttribute->SetID(TDataStd_Real::GetID());
}
private:

21
src/StdLPersistent/StdLPersistent_TreeNode.cxx
View File

@ -24,6 +24,27 @@ void StdLPersistent_TreeNode::Read (StdObjMgt_ReadData& theReadData)
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

10
src/StdLPersistent/StdLPersistent_TreeNode.hxx
View File

@ -28,6 +28,16 @@ public:
//! Read persistent data from a file.
Standard_EXPORT virtual void Read (StdObjMgt_ReadData& theReadData);
//! Write persistent data to a file.
Standard_EXPORT virtual void Write (StdObjMgt_WriteData& theWriteData) const;
//! Gets persistent child objects
Standard_EXPORT virtual void PChildren(StdObjMgt_Persistent::SequenceOfPersistent&) const;
//! Returns persistent type name
Standard_EXPORT virtual Standard_CString PName() const
{ return "PDataStd_TreeNode"; }
//! Create an empty transient attribuite
Standard_EXPORT virtual Handle(TDF_Attribute) CreateAttribute();

36
src/StdLPersistent/StdLPersistent_Value.hxx
View File

@ -48,15 +48,27 @@ class StdLPersistent_Value
public:
typedef integer <TDF_TagSource> TagSource;
typedef string <TDF_Reference> Reference;
typedef string <TDataStd_Comment> Comment;
class TagSource : public integer <TDF_TagSource> {
public:
Standard_CString PName() const { return "PDF_TagSource"; }
};
class Reference : public string <TDF_Reference> {
public:
Standard_CString PName() const { return "PDF_Reference"; }
};
class Comment : public string <TDataStd_Comment> {
public:
Standard_CString PName() const { return "PDF_Comment"; }
};
class UAttribute : public string <TDataStd_UAttribute>
{
public:
//! Create an empty transient attribuite
Standard_EXPORT virtual Handle(TDF_Attribute) CreateAttribute();
Standard_CString PName() const { return "PDataStd_UAttribute"; }
};
class Integer : public integer <TDataStd_Integer>
@ -64,6 +76,7 @@ public:
public:
//! Create an empty transient attribuite
Standard_EXPORT virtual Handle(TDF_Attribute) CreateAttribute();
Standard_CString PName() const { return "PDataStd_Integer"; }
};
class Name : public string <TDataStd_Name>
@ -71,6 +84,7 @@ public:
public:
//! Create an empty transient attribuite
Standard_EXPORT virtual Handle(TDF_Attribute) CreateAttribute();
Standard_CString PName() const { return "PDataStd_Name"; }
};
class AsciiString : public string <TDataStd_AsciiString, StdLPersistent_HString::Ascii>
@ -78,7 +92,23 @@ public:
public:
//! Create an empty transient attribuite
Standard_EXPORT virtual Handle(TDF_Attribute) CreateAttribute();
Standard_CString PName() const { return "PDataStd_AsciiString"; }
};
};
template<>
template<>
inline Standard_CString StdObjMgt_Attribute<TDF_TagSource>::Simple<Standard_Integer>::PName() const
{ return "PDF_TagSource"; }
template<>
template<>
inline Standard_CString StdObjMgt_Attribute<TDF_Reference>::Simple<Handle(StdObjMgt_Persistent)>::PName() const
{ return "PDF_Reference"; }
template<>
template<>
inline Standard_CString StdObjMgt_Attribute<TDataStd_Comment>::Simple<Handle(StdObjMgt_Persistent)>::PName() const
{ return "PDataStd_Comment"; }
#endif

8
src/StdLPersistent/StdLPersistent_Variable.hxx
View File

@ -27,6 +27,14 @@ public:
//! Read persistent data from a file.
inline void Read (StdObjMgt_ReadData& theReadData)
{ theReadData >> myIsConstant >> myUnit; }
//! Write persistent data to a file.
inline void Write (StdObjMgt_WriteData& theWriteData) const
{ theWriteData << myIsConstant << myUnit; }
//! Gets persistent child objects
inline void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
{ theChildren.Append(myUnit); }
//! Returns persistent type name
inline Standard_CString PName() const { return "PDataStd_Variable"; }
//! Import transient attribuite from the persistent data.
void Import (const Handle(TDataStd_Variable)& theAttribute) const

18
src/StdLPersistent/StdLPersistent_Void.hxx
View File

@ -31,6 +31,12 @@ protected:
public:
//! Read persistent data from a file.
Standard_EXPORT virtual void Read (StdObjMgt_ReadData&) {}
//! Write persistent data to a file.
Standard_EXPORT virtual void Write (StdObjMgt_WriteData&) const {}
//! Gets persistent child objects
inline void PChildren(StdObjMgt_Persistent::SequenceOfPersistent&) const {}
//! Returns persistent type name
Standard_CString PName() const;
//! Import transient attribuite from the persistent data
Standard_EXPORT virtual void ImportAttribute() {}
@ -42,4 +48,16 @@ public:
typedef instance<TDataStd_NoteBook> NoteBook;
};
template<>
inline Standard_CString StdLPersistent_Void::instance<TDataStd_Directory>::PName() const
{ return "PDataStd_Directory"; }
template<>
inline Standard_CString StdLPersistent_Void::instance<TDataStd_Tick>::PName() const
{ return "PDataStd_Tick"; }
template<>
inline Standard_CString StdLPersistent_Void::instance<TDataStd_NoteBook>::PName() const
{ return "PDataStd_Notebook"; }
#endif

11
src/StdLPersistent/StdLPersistent_XLink.hxx
View File

@ -27,6 +27,17 @@ public:
//! Read persistent data from a file.
inline void Read (StdObjMgt_ReadData& theReadData)
{ theReadData >> myDocEntry >> myLabEntry; }
//! Write persistent data to a file.
inline void Write (StdObjMgt_WriteData& theWriteData) const
{ theWriteData << myDocEntry << myLabEntry; }
//! Gets persistent child objects
inline void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
{
theChildren.Append(myDocEntry);
theChildren.Append(myLabEntry);
}
//! Returns persistent type name
inline Standard_CString PName() const { return "PDocStd_XLink"; }
//! Import transient attribuite from the persistent data.
void Import (const Handle(TDocStd_XLink)& theAttribute) const

4
src/StdObjMgt/FILES
View File

@ -1,8 +1,10 @@
StdObjMgt_Attribute.hxx
StdObjMgt_MapOfInstantiators.cxx
StdObjMgt_MapOfInstantiators.hxx
StdObjMgt_Persistent.cxx
StdObjMgt_Persistent.hxx
StdObjMgt_ReadData.cxx
StdObjMgt_ReadData.hxx
StdObjMgt_WriteData.hxx
StdObjMgt_WriteData.cxx
StdObjMgt_SharedObject.hxx
StdObjMgt_TransientPersistentMap.hxx

14
src/StdObjMgt/StdObjMgt_Attribute.hxx
View File

@ -16,6 +16,7 @@
#include <StdObjMgt_Persistent.hxx>
#include <StdObjMgt_ReadData.hxx>
#include <StdObjMgt_WriteData.hxx>
//! Root class for a temporary persistent object corresponding to an attribute.
@ -31,7 +32,7 @@ class StdObjMgt_Attribute : public Standard_Transient
//! Get transient attribuite for the persistent data
Standard_EXPORT virtual Handle(TDF_Attribute) GetAttribute() const
{ return Handle(TDF_Attribute)(myTransient); }
{ return Handle(TDF_Attribute)(myTransient); }
protected:
Handle(Transient) myTransient;
@ -47,6 +48,11 @@ public:
//! Read persistent data from a file.
Standard_EXPORT virtual void Read (StdObjMgt_ReadData& theReadData)
{ theReadData >> myData; }
//! Write persistent data to a file.
Standard_EXPORT virtual void Write (StdObjMgt_WriteData& theWriteData) const
{ theWriteData << myData; }
Standard_EXPORT virtual void PChildren(StdObjMgt_Persistent::SequenceOfPersistent&) const { }
Standard_EXPORT virtual Standard_CString PName() const { return "StdObjMgt_Attribute::undefined"; }
protected:
DataType myData;
@ -66,6 +72,12 @@ private:
myPersistent = new Persistent;
myPersistent->Read (theReadData);
}
//! Write persistent data to a file.
Standard_EXPORT virtual void Write(StdObjMgt_WriteData& theWriteData) const
{ myPersistent->Write(theWriteData); }
Standard_EXPORT virtual void PChildren(StdObjMgt_Persistent::SequenceOfPersistent&) const { }
Standard_EXPORT virtual Standard_CString PName() const
{ return myPersistent->PName(); }
//! Import transient attribuite from the persistent data
Standard_EXPORT virtual void ImportAttribute()

6
src/StdObjMgt/StdObjMgt_Persistent.cxx
View File

@ -13,6 +13,12 @@
#include <StdObjMgt_Persistent.hxx>
StdObjMgt_Persistent::StdObjMgt_Persistent()
: myTypeNum(0)
, myRefNum(0)
{
}
//=======================================================================
//function : ImportDocument

31
src/StdObjMgt/StdObjMgt_Persistent.hxx
View File

@ -18,10 +18,12 @@
#include <Standard.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Transient.hxx>
#include <NCollection_Sequence.hxx>
#include <TDF_Label.hxx>
class StdObjMgt_ReadData;
class StdObjMgt_WriteData;
class TDocStd_Document;
class TDF_Attribute;
class TDF_Data;
@ -34,6 +36,8 @@ class TCollection_HExtendedString;
class StdObjMgt_Persistent : public Standard_Transient
{
public:
Standard_EXPORT StdObjMgt_Persistent();
//! Derived class instance create function.
typedef Handle(StdObjMgt_Persistent) (*Instantiator)();
@ -45,6 +49,17 @@ public:
//! Read persistent data from a file.
Standard_EXPORT virtual void Read (StdObjMgt_ReadData& theReadData) = 0;
//! Write persistent data to a file.
Standard_EXPORT virtual void Write (StdObjMgt_WriteData& theWriteData) const = 0;
typedef NCollection_Sequence<Handle(StdObjMgt_Persistent)> SequenceOfPersistent;
//! Gets persistent child objects
Standard_EXPORT virtual void PChildren (SequenceOfPersistent&) const = 0;
//! Returns persistent type name
Standard_EXPORT virtual Standard_CString PName() const = 0;
//! Import transient document from the persistent data
//! (to be overriden by document class;
//! does nothing by default for other classes).
@ -80,6 +95,22 @@ public:
//! (to be overriden by extended string class;
//! returns a null label by default for other classes).
Standard_EXPORT virtual TDF_Label Label (const Handle(TDF_Data)& theDF) const;
//! Returns the assigned persistent type number
Standard_Integer TypeNum() const { return myTypeNum; }
//! Assigns a persistent type number to the object
void TypeNum(Standard_Integer theTypeNum) { myTypeNum = theTypeNum; }
//! Returns the object reference number
Standard_Integer RefNum() const { return myRefNum; }
//! Sets an object reference number
void RefNum(Standard_Integer theRefNum) { myRefNum = theRefNum; }
private:
Standard_Integer myTypeNum;
Standard_Integer myRefNum;
};
#endif // _StdObjMgt_Persistent_HeaderFile

4
src/StdObjMgt/StdObjMgt_ReadData.hxx
View File

@ -93,6 +93,8 @@ class StdObjMgt_ReadData::Object
public:
Object (StdObjMgt_ReadData& theData) : myReadData (&theData)
{ myReadData->myDriver->BeginReadObjectData(); }
Object(const StdObjMgt_ReadData::Object& theOther) : myReadData(theOther.myReadData)
{ myReadData->myDriver->BeginReadObjectData(); }
~Object()
{ myReadData->myDriver->EndReadObjectData(); }
@ -106,6 +108,8 @@ public:
private:
StdObjMgt_ReadData* myReadData;
StdObjMgt_ReadData::Object& operator = (const StdObjMgt_ReadData::Object&);
};
Standard_EXPORT StdObjMgt_ReadData& operator >>

65
src/StdObjMgt/StdObjMgt_SharedObject.hxx
View File

@ -15,9 +15,9 @@
#ifndef _StdObjMgt_SharedObject_HeaderFile
#define _StdObjMgt_SharedObject_HeaderFile
#include <Standard_NoSuchObject.hxx>
#include <StdObjMgt_Persistent.hxx>
class StdObjMgt_SharedObject
{
public:
@ -28,15 +28,19 @@ public:
virtual Handle(Transient) Import() const = 0;
};
template <class Transient, class Base = StdObjMgt_Persistent>
template <class TransientT, class Base = StdObjMgt_Persistent>
class SharedBase : public Base
{
public:
//! Changes transient object
inline void Transient(const Handle(TransientT)& theTransient)
{ myTransient = theTransient; }
//! Import transient object from the persistent data.
inline const Handle(Transient)& Import() { return myTransient; }
inline const Handle(TransientT)& Import() { return myTransient; }
protected:
Handle(Transient) myTransient;
Handle(TransientT) myTransient;
};
template <class Base,
@ -52,7 +56,7 @@ public:
Standard_EXPORT virtual Handle(Transient) Import()
{ return myTransient; }
protected:
public:
Handle(Transient) myTransient;
};
@ -65,6 +69,15 @@ public:
//! Read persistent data from a file.
Standard_EXPORT virtual void Read (StdObjMgt_ReadData& theReadData)
{ PersistentData().Read (theReadData); }
//! Write persistent data to a file.
Standard_EXPORT virtual void Write (StdObjMgt_WriteData& theWriteData) const
{ PersistentData().Write (theWriteData); }
//! Gets persistent child objects
Standard_EXPORT virtual void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
{ PersistentData().PChildren(theChildren); }
//! Returns persistent type name
Standard_EXPORT virtual Standard_CString PName() const
{ return PersistentData().PName(); }
//! Import transient object from the persistent data.
Standard_EXPORT virtual Handle(Transient) Import()
@ -88,7 +101,7 @@ private:
return Base::myTransient;
}
protected:
public:
Handle(typename Base::PersistentBase) myPersistent;
};
@ -96,6 +109,19 @@ public:
template <class Base, class Persistent = typename Base::PersistentBase>
class Delayed : public delayedSubBase<Base>
{
private:
template <class T1, class T2>
struct DownCast {
static Handle(T1) make(const Handle(T2)& theT2)
{ return Handle(T1)::DownCast(theT2); }
};
template <class T>
struct DownCast<T, T> {
static Handle(T) make(const Handle(T)& theT)
{ return theT; }
};
public:
//! Read persistent data from a file.
Standard_EXPORT virtual void Read (StdObjMgt_ReadData& theReadData)
@ -104,6 +130,33 @@ public:
aPersistent->Read (theReadData);
this->myPersistent = aPersistent;
}
//! Write persistent data to a file.
Standard_EXPORT virtual void Write(StdObjMgt_WriteData& theWriteData) const
{
Handle(Persistent) aPersistent =
DownCast<Persistent, typename Base::PersistentBase>::make(this->myPersistent);
Standard_NoSuchObject_Raise_if(aPersistent.IsNull(),
"StdObjMgt_SharedObject::Delayed::Write - persistent object wasn't set for writing!");
aPersistent->Write(theWriteData);
}
//! Gets persistent child objects
Standard_EXPORT virtual void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
{
Handle(Persistent) aPersistent =
DownCast<Persistent, typename Base::PersistentBase>::make(this->myPersistent);
Standard_NoSuchObject_Raise_if(aPersistent.IsNull(),
"StdObjMgt_SharedObject::Delayed::PChildren - persistent object wasn't set for writing!");
aPersistent->PChildren(theChildren);
}
//! Returns persistent type name
Standard_EXPORT virtual Standard_CString PName() const
{
Handle(Persistent) aPersistent =
DownCast<Persistent, typename Base::PersistentBase>::make(this->myPersistent);
Standard_NoSuchObject_Raise_if(aPersistent.IsNull(),
"StdObjMgt_SharedObject::Delayed::PName - persistent object wasn't set for writing!");
return aPersistent->PName();
}
};
};

12
src/StdObjMgt/StdObjMgt_TransientPersistentMap.hxx Normal file
View File

@ -0,0 +1,12 @@
#ifndef _StdObjMgt_TransientPersistentMap_HeaderFile
#define _StdObjMgt_TransientPersistentMap_HeaderFile
#include <NCollection_DataMap.hxx>
class Standard_Transient;
class StdObjMgt_Persistent;
typedef NCollection_DataMap<Handle(Standard_Transient), Handle(StdObjMgt_Persistent)> StdObjMgt_TransientPersistentMap;
#endif // _StdObjMgt_TransientPersistentMap_HeaderFile

71
src/StdObjMgt/StdObjMgt_WriteData.cxx Normal file
View File

@ -0,0 +1,71 @@
// Copyright (c) 2017 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <StdObjMgt_WriteData.hxx>
#include <StdObjMgt_Persistent.hxx>
#include <Standard_GUID.hxx>
StdObjMgt_WriteData::StdObjMgt_WriteData (Storage_BaseDriver& theDriver)
: myDriver (&theDriver)
{
}
void StdObjMgt_WriteData::WritePersistentObject (const Handle(StdObjMgt_Persistent)& thePersistent)
{
if (thePersistent)
{
myDriver->WritePersistentObjectHeader(thePersistent->RefNum(), thePersistent->TypeNum());
myDriver->BeginWritePersistentObjectData();
thePersistent->Write(*this);
myDriver->EndWritePersistentObjectData();
}
}
StdObjMgt_WriteData& StdObjMgt_WriteData::operator << (const Handle(StdObjMgt_Persistent)& thePersistent)
{
*myDriver << (thePersistent ? thePersistent->RefNum() : 0);
return *this;
}
//=======================================================================
//function : operator >>
//purpose : Read persistent data from a file
//=======================================================================
StdObjMgt_WriteData& operator <<
(StdObjMgt_WriteData::Object theWriteData, const Standard_GUID& theGUID)
{
const Standard_UUID anUUID = theGUID.ToUUID();
Standard_Integer a32b;
Standard_ExtCharacter a16b[3];
Standard_Character a8b [6];
// see Standard_GUID::Standard_GUID(const Standard_UUID& aWntGuid)
a32b = anUUID.Data1;
a16b[0] = anUUID.Data2;
a16b[1] = anUUID.Data3;
a16b[2] = (anUUID.Data4[0] << 8) | (anUUID.Data4[1]);
a8b[0] = anUUID.Data4[2];
a8b[1] = anUUID.Data4[3];
a8b[2] = anUUID.Data4[4];
a8b[3] = anUUID.Data4[5];
a8b[4] = anUUID.Data4[6];
a8b[5] = anUUID.Data4[7];
theWriteData << a32b << a16b[0] << a16b[1] << a16b[2];
theWriteData << a8b[0] << a8b[1] << a8b[2] << a8b[3] << a8b[4] << a8b[5];
return theWriteData;
}

101
src/StdObjMgt/StdObjMgt_WriteData.hxx Normal file
View File

@ -0,0 +1,101 @@
// Copyright (c) 2017 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _StdObjMgt_WriteData_HeaderFile
#define _StdObjMgt_WriteData_HeaderFile
#include <Standard.hxx>
#include <Storage_BaseDriver.hxx>
class StdObjMgt_Persistent;
class Standard_GUID;
//! Auxiliary data used to write persistent objects to a file.
class StdObjMgt_WriteData
{
public:
class Object;
Standard_EXPORT StdObjMgt_WriteData
(Storage_BaseDriver& theDriver);
Standard_EXPORT void WritePersistentObject
(const Handle(StdObjMgt_Persistent)& thePersistent);
template <class Persistent>
StdObjMgt_WriteData& operator << (const Handle(Persistent)& thePersistent)
{
*myDriver << (thePersistent ? thePersistent->RefNum() : 0);
return *this;
}
Standard_EXPORT StdObjMgt_WriteData& operator << (const Handle(StdObjMgt_Persistent)& thePersistent);
template <class Type>
StdObjMgt_WriteData& WriteValue(const Type& theValue)
{
*myDriver << theValue;
return *this;
}
StdObjMgt_WriteData& operator << (const Standard_Character& theValue)
{ return WriteValue(theValue); }
StdObjMgt_WriteData& operator << (const Standard_ExtCharacter& theValue)
{ return WriteValue(theValue); }
StdObjMgt_WriteData& operator << (const Standard_Integer& theValue)
{ return WriteValue(theValue); }
StdObjMgt_WriteData& operator << (const Standard_Boolean& theValue)
{ return WriteValue(theValue); }
StdObjMgt_WriteData& operator << (const Standard_Real& theValue)
{ return WriteValue(theValue); }
StdObjMgt_WriteData& operator << (const Standard_ShortReal& theValue)
{ return WriteValue(theValue); }
private:
Storage_BaseDriver* myDriver;
};
class StdObjMgt_WriteData::Object
{
public:
Object (StdObjMgt_WriteData& theData) : myWriteData(&theData)
{ myWriteData->myDriver->BeginWriteObjectData(); }
Object (const StdObjMgt_WriteData::Object& theOther) : myWriteData(theOther.myWriteData)
{ myWriteData->myDriver->BeginWriteObjectData(); }
~Object()
{ myWriteData->myDriver->EndWriteObjectData(); }
operator StdObjMgt_WriteData& ()
{ return *myWriteData; }
template <class Data>
StdObjMgt_WriteData& operator << (Data& theData)
{ return *myWriteData << theData; }
private:
StdObjMgt_WriteData* myWriteData;
StdObjMgt_WriteData::Object& operator = (const StdObjMgt_WriteData::Object&);
};
Standard_EXPORT StdObjMgt_WriteData& operator <<
(StdObjMgt_WriteData::Object theWriteData, const Standard_GUID& theGUID);
#endif // _StdObjMgt_WriteData_HeaderFile

22
src/StdObject/StdObject_Location.cxx
View File

@ -14,6 +14,28 @@
#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

21
src/StdObject/StdObject_Location.hxx
View File

@ -16,21 +16,33 @@
#define _StdObject_Location_HeaderFile
#include <StdObjMgt_ReadData.hxx>
#include <StdObjMgt_WriteData.hxx>
#include <StdObjMgt_Persistent.hxx>
#include <StdObjMgt_TransientPersistentMap.hxx>
#include <TopLoc_Location.hxx>
class StdObject_Location
{
public:
//! Gets persistent child objects
Standard_EXPORT void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const;
//! Import transient object from the persistent data.
TopLoc_Location Import() const;
//! Creates a persistent wrapper object for a location
Standard_EXPORT static StdObject_Location Translate (const TopLoc_Location& theLoc,
StdObjMgt_TransientPersistentMap& theMap);
private:
Handle(StdObjMgt_Persistent) myData;
friend StdObjMgt_ReadData& operator >>
(StdObjMgt_ReadData::Object, StdObject_Location&);
friend StdObjMgt_WriteData& operator <<
(StdObjMgt_WriteData::Object, const StdObject_Location&);
};
//! Read persistent data from a file.
@ -40,4 +52,11 @@ inline StdObjMgt_ReadData& operator >>
return theReadData >> theLocation.myData;
}
//! Write persistent data to a file.
inline StdObjMgt_WriteData& operator <<
(StdObjMgt_WriteData::Object theWriteData, const StdObject_Location& theLocation)
{
return theWriteData << theLocation.myData;
}
#endif

10
src/StdObject/StdObject_Shape.cxx
View File

@ -31,3 +31,13 @@ TopoDS_Shape StdObject_Shape::Import() const
return aShape;
}
//=======================================================================
//function : PChildren
//purpose :
//=======================================================================
void StdObject_Shape::PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
{
theChildren.Append(myTShape);
myLocation.PChildren(theChildren);
}

21
src/StdObject/StdObject_Shape.hxx
View File

@ -16,6 +16,7 @@
#define _StdObject_Shape_HeaderFile
#include <StdObjMgt_ReadData.hxx>
#include <StdObjMgt_WriteData.hxx>
#include <StdObject_Location.hxx>
#include <StdPersistent_TopoDS.hxx>
@ -24,22 +25,32 @@
class StdObject_Shape
{
friend class ShapePersistent_TopoDS;
public:
//! Import transient object from the persistent data.
Standard_EXPORT TopoDS_Shape Import() const;
Standard_EXPORT void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const;
protected:
//! Read persistent data from a file.
inline void read (StdObjMgt_ReadData& theReadData)
{ theReadData >> myTShape >> myLocation >> myOrient; }
private:
//! Write persistent data to a file.
inline void write (StdObjMgt_WriteData& theWriteData) const
{ theWriteData << myTShape << myLocation << myOrient; }
protected:
Handle(StdPersistent_TopoDS::TShape) myTShape;
StdObject_Location myLocation;
Standard_Integer myOrient;
friend StdObjMgt_ReadData& operator >>
(StdObjMgt_ReadData::Object, StdObject_Shape&);
friend StdObjMgt_WriteData& operator <<
(StdObjMgt_WriteData::Object, const StdObject_Shape&);
};
//! Read persistent data from a file.
@ -50,4 +61,12 @@ inline StdObjMgt_ReadData& operator >>
return theReadData;
}
//! Write persistent data to a file.
inline StdObjMgt_WriteData& operator <<
(StdObjMgt_WriteData::Object theWriteData, const StdObject_Shape& theShape)
{
theShape.write (theWriteData);
return theWriteData;
}
#endif

68
src/StdObject/StdObject_gp_Axes.hxx
View File

@ -35,6 +35,24 @@ inline StdObjMgt_ReadData& operator >>
return theReadData;
}
inline StdObjMgt_WriteData&
write (StdObjMgt_WriteData::Object theWriteData, const gp_Ax2d& theAx)
{
const gp_Pnt2d& aLoc = theAx.Location();
const gp_Dir2d& aDir = theAx.Direction();
theWriteData << aLoc << aDir;
return theWriteData;
}
inline StdObjMgt_WriteData& operator <<
(StdObjMgt_WriteData::Object theWriteData, const gp_Ax2d& theAx)
{
const gp_Pnt2d& aLoc = theAx.Location();
const gp_Dir2d& aDir = theAx.Direction();
theWriteData << aLoc << aDir;
return theWriteData;
}
inline StdObjMgt_ReadData& operator >>
(StdObjMgt_ReadData::Object theReadData, gp_Ax22d& theAx)
{
@ -45,16 +63,44 @@ inline StdObjMgt_ReadData& operator >>
return theReadData;
}
inline StdObjMgt_WriteData& operator <<
(StdObjMgt_WriteData::Object theWriteData, const gp_Ax22d& theAx)
{
const gp_Pnt2d& aLoc = theAx.Location();
const gp_Dir2d& aYDir = theAx.YDirection();
const gp_Dir2d& aXDir = theAx.XDirection();
theWriteData << aLoc << aYDir << aXDir;
return theWriteData;
}
inline StdObjMgt_ReadData& operator >>
(StdObjMgt_ReadData::Object theReadData, gp_Ax1& theAx)
{
gp_XYZ aLoc;
gp_Pnt aLoc;
gp_Dir aDir;
theReadData >> aLoc >> aDir;
theAx = gp_Ax1 (aLoc, aDir);
return theReadData;
}
inline StdObjMgt_WriteData&
write(StdObjMgt_WriteData::Object theWriteData, const gp_Ax1& theAx)
{
const gp_Pnt& aLoc = theAx.Location();
const gp_Dir& aDir = theAx.Direction();
theWriteData << aLoc << aDir;
return theWriteData;
}
inline StdObjMgt_WriteData& operator <<
(StdObjMgt_WriteData::Object theWriteData, const gp_Ax1& theAx)
{
const gp_Pnt& aLoc = theAx.Location();
const gp_Dir& aDir = theAx.Direction();
theWriteData << aLoc << aDir;
return theWriteData;
}
inline StdObjMgt_ReadData& operator >>
(StdObjMgt_ReadData::Object theReadData, gp_Ax2& theAx)
{
@ -65,6 +111,16 @@ inline StdObjMgt_ReadData& operator >>
return theReadData;
}
inline StdObjMgt_WriteData& operator <<
(StdObjMgt_WriteData::Object theWriteData, const gp_Ax2& theAx)
{
const gp_Ax1& anAx = theAx.Axis();
const gp_Dir& aYDir = theAx.YDirection();
const gp_Dir& aXDir = theAx.XDirection();
theWriteData << anAx << aYDir << aXDir;
return theWriteData;
}
inline StdObjMgt_ReadData& operator >>
(StdObjMgt_ReadData::Object theReadData, gp_Ax3& theAx)
{
@ -77,5 +133,15 @@ inline StdObjMgt_ReadData& operator >>
return theReadData;
}
inline StdObjMgt_WriteData& operator <<
(StdObjMgt_WriteData::Object theWriteData, const gp_Ax3& theAx)
{
const gp_Ax1& anAx = theAx.Axis();
const gp_Dir& aYDir = theAx.YDirection();
const gp_Dir& aXDir = theAx.XDirection();
theWriteData << anAx << aYDir << aXDir;
return theWriteData;
}
#endif

112
src/StdObject/StdObject_gp_Curves.hxx
View File

@ -31,7 +31,7 @@
inline StdObjMgt_ReadData& operator >>
(StdObjMgt_ReadData::Object theReadData, gp_Lin2d& theLin)
(StdObjMgt_ReadData& theReadData, gp_Lin2d& theLin)
{
gp_Ax2d anAx;
theReadData >> anAx;
@ -39,8 +39,16 @@ inline StdObjMgt_ReadData& operator >>
return theReadData;
}
inline StdObjMgt_WriteData& operator <<
(StdObjMgt_WriteData& theWriteData, const gp_Lin2d& theLin)
{
const gp_Ax2d& anAx = theLin.Position();
write (theWriteData, anAx);
return theWriteData;
}
inline StdObjMgt_ReadData& operator >>
(StdObjMgt_ReadData::Object theReadData, gp_Circ2d& theCirc)
(StdObjMgt_ReadData& theReadData, gp_Circ2d& theCirc)
{
gp_Ax22d anAx;
Standard_Real aRadius;
@ -53,8 +61,17 @@ inline StdObjMgt_ReadData& operator >>
return theReadData;
}
inline StdObjMgt_WriteData& operator <<
(StdObjMgt_WriteData& theWriteData, const gp_Circ2d& theCirc)
{
const gp_Ax22d& anAx = theCirc.Position();
Standard_Real aRadius = theCirc.Radius();
theWriteData << anAx << aRadius;
return theWriteData;
}
inline StdObjMgt_ReadData& operator >>
(StdObjMgt_ReadData::Object theReadData, gp_Elips2d& theElips)
(StdObjMgt_ReadData& theReadData, gp_Elips2d& theElips)
{
gp_Ax22d anAx;
Standard_Real aMajorRadius, aMinorRadius;
@ -68,8 +85,18 @@ inline StdObjMgt_ReadData& operator >>
return theReadData;
}
inline StdObjMgt_WriteData& operator <<
(StdObjMgt_WriteData& theWriteData, const gp_Elips2d& theElips)
{
const gp_Ax22d& anAx = theElips.Axis();
Standard_Real aMajorRadius = theElips.MajorRadius();
Standard_Real aMinorRadius = theElips.MinorRadius();
theWriteData << anAx << aMajorRadius << aMinorRadius;
return theWriteData;
}
inline StdObjMgt_ReadData& operator >>
(StdObjMgt_ReadData::Object theReadData, gp_Hypr2d& theHypr)
(StdObjMgt_ReadData& theReadData, gp_Hypr2d& theHypr)
{
gp_Ax22d anAx;
Standard_Real aMajorRadius, aMinorRadius;
@ -83,8 +110,18 @@ inline StdObjMgt_ReadData& operator >>
return theReadData;
}
inline StdObjMgt_WriteData& operator <<
(StdObjMgt_WriteData& theWriteData, const gp_Hypr2d& theHypr)
{
const gp_Ax22d& anAx = theHypr.Axis();
Standard_Real aMajorRadius = theHypr.MajorRadius();
Standard_Real aMinorRadius = theHypr.MinorRadius();
theWriteData << anAx << aMajorRadius << aMinorRadius;
return theWriteData;
}
inline StdObjMgt_ReadData& operator >>
(StdObjMgt_ReadData::Object theReadData, gp_Parab2d& theParab)
(StdObjMgt_ReadData& theReadData, gp_Parab2d& theParab)
{
gp_Ax22d anAx;
Standard_Real aFocalLength;
@ -97,8 +134,17 @@ inline StdObjMgt_ReadData& operator >>
return theReadData;
}
inline StdObjMgt_WriteData& operator <<
(StdObjMgt_WriteData& theWriteData, const gp_Parab2d& theParab)
{
const gp_Ax22d& anAx = theParab.Axis();
Standard_Real aFocalLength = theParab.Focal();
theWriteData << anAx << aFocalLength;
return theWriteData;
}
inline StdObjMgt_ReadData& operator >>
(StdObjMgt_ReadData::Object theReadData, gp_Lin& theLin)
(StdObjMgt_ReadData& theReadData, gp_Lin& theLin)
{
gp_Ax1 anAx;
theReadData >> anAx;
@ -106,8 +152,16 @@ inline StdObjMgt_ReadData& operator >>
return theReadData;
}
inline StdObjMgt_WriteData& operator <<
(StdObjMgt_WriteData& theWriteData, const gp_Lin& theLin)
{
const gp_Ax1& anAx = theLin.Position();
write (theWriteData, anAx);
return theWriteData;
}
inline StdObjMgt_ReadData& operator >>
(StdObjMgt_ReadData::Object theReadData, gp_Circ& theCirc)
(StdObjMgt_ReadData& theReadData, gp_Circ& theCirc)
{
gp_Ax2 anAx;
Standard_Real aRadius;
@ -120,8 +174,17 @@ inline StdObjMgt_ReadData& operator >>
return theReadData;
}
inline StdObjMgt_WriteData& operator <<
(StdObjMgt_WriteData& theWriteData, const gp_Circ& theCirc)
{
const gp_Ax2& anAx = theCirc.Position();
Standard_Real aRadius = theCirc.Radius();
theWriteData << anAx << aRadius;
return theWriteData;
}
inline StdObjMgt_ReadData& operator >>
(StdObjMgt_ReadData::Object theReadData, gp_Elips& theElips)
(StdObjMgt_ReadData& theReadData, gp_Elips& theElips)
{
gp_Ax2 anAx;
Standard_Real aMajorRadius, aMinorRadius;
@ -135,8 +198,18 @@ inline StdObjMgt_ReadData& operator >>
return theReadData;
}
inline StdObjMgt_WriteData& operator <<
(StdObjMgt_WriteData& theWriteData, const gp_Elips& theElips)
{
const gp_Ax2& anAx = theElips.Position();
Standard_Real aMajorRadius = theElips.MajorRadius();
Standard_Real aMinorRadius = theElips.MinorRadius();
theWriteData << anAx << aMajorRadius << aMinorRadius;
return theWriteData;
}
inline StdObjMgt_ReadData& operator >>
(StdObjMgt_ReadData::Object theReadData, gp_Hypr& theHypr)
(StdObjMgt_ReadData& theReadData, gp_Hypr& theHypr)
{
gp_Ax2 anAx;
Standard_Real aMajorRadius, aMinorRadius;
@ -150,8 +223,18 @@ inline StdObjMgt_ReadData& operator >>
return theReadData;
}
inline StdObjMgt_WriteData& operator <<
(StdObjMgt_WriteData& theWriteData, const gp_Hypr& theHypr)
{
const gp_Ax2& anAx = theHypr.Position();
Standard_Real aMajorRadius = theHypr.MajorRadius();
Standard_Real aMinorRadius = theHypr.MinorRadius();
theWriteData << anAx << aMajorRadius << aMinorRadius;
return theWriteData;
}
inline StdObjMgt_ReadData& operator >>
(StdObjMgt_ReadData::Object theReadData, gp_Parab& theParab)
(StdObjMgt_ReadData& theReadData, gp_Parab& theParab)
{
gp_Ax2 anAx;
Standard_Real aFocalLength;
@ -164,5 +247,14 @@ inline StdObjMgt_ReadData& operator >>
return theReadData;
}
inline StdObjMgt_WriteData& operator <<
(StdObjMgt_WriteData& theWriteData, const gp_Parab& theParab)
{
const gp_Ax2& anAx = theParab.Position();
Standard_Real aFocalLength = theParab.Focal();
theWriteData << anAx << aFocalLength;
return theWriteData;
}
#endif

46
src/StdObject/StdObject_gp_Surfaces.hxx
View File

@ -25,7 +25,7 @@
inline StdObjMgt_ReadData& operator >>
(StdObjMgt_ReadData::Object theReadData, gp_Cone& theCone)
(StdObjMgt_ReadData& theReadData, gp_Cone& theCone)
{
gp_Ax3 anAx;
Standard_Real aRadius, aSemiAngle;
@ -39,8 +39,18 @@ inline StdObjMgt_ReadData& operator >>
return theReadData;
}
inline StdObjMgt_WriteData& operator <<
(StdObjMgt_WriteData& theWriteData, const gp_Cone& theCone)
{
const gp_Ax3& anAx = theCone.Position();
Standard_Real aRadius = theCone.RefRadius();
Standard_Real aSemiAngle = theCone.SemiAngle();
theWriteData << anAx << aRadius << aSemiAngle;
return theWriteData;
}
inline StdObjMgt_ReadData& operator >>
(StdObjMgt_ReadData::Object theReadData, gp_Cylinder& theCyl)
(StdObjMgt_ReadData& theReadData, gp_Cylinder& theCyl)
{
gp_Ax3 anAx;
Standard_Real aRadius;
@ -53,8 +63,17 @@ inline StdObjMgt_ReadData& operator >>
return theReadData;
}
inline StdObjMgt_WriteData& operator <<
(StdObjMgt_WriteData& theWriteData, const gp_Cylinder& theCyl)
{
const gp_Ax3& anAx = theCyl.Position();
Standard_Real aRadius = theCyl.Radius();
theWriteData << anAx << aRadius;
return theWriteData;
}
inline StdObjMgt_ReadData& operator >>
(StdObjMgt_ReadData::Object theReadData, gp_Sphere& theSph)
(StdObjMgt_ReadData& theReadData, gp_Sphere& theSph)
{
gp_Ax3 anAx;
Standard_Real aRadius;
@ -67,8 +86,17 @@ inline StdObjMgt_ReadData& operator >>
return theReadData;
}
inline StdObjMgt_WriteData& operator <<
(StdObjMgt_WriteData& theWriteData, const gp_Sphere& theSph)
{
const gp_Ax3& anAx = theSph.Position();
Standard_Real aRadius = theSph.Radius();
theWriteData << anAx << aRadius;
return theWriteData;
}
inline StdObjMgt_ReadData& operator >>
(StdObjMgt_ReadData::Object theReadData, gp_Torus& theTorus)
(StdObjMgt_ReadData& theReadData, gp_Torus& theTorus)
{
gp_Ax3 anAx;
Standard_Real aMajorRadius, aMinorRadius;
@ -82,5 +110,15 @@ inline StdObjMgt_ReadData& operator >>
return theReadData;
}
inline StdObjMgt_WriteData& operator <<
(StdObjMgt_WriteData& theWriteData, const gp_Torus& theTorus)
{
const gp_Ax3& anAx = theTorus.Position();
Standard_Real aMajorRadius = theTorus.MajorRadius();
Standard_Real aMinorRadius = theTorus.MinorRadius();
theWriteData << anAx << aMajorRadius << aMinorRadius;
return theWriteData;
}
#endif

57
src/StdObject/StdObject_gp_Trsfs.hxx
View File

@ -27,21 +27,41 @@
inline StdObjMgt_ReadData& operator >>
(StdObjMgt_ReadData::Object theReadData, gp_Mat2d& theMat)
{
gp_XY aRow1, aRow2;
theReadData >> aRow1 >> aRow2;
theMat.SetRows (aRow1, aRow2);
theReadData
>> theMat(1, 1) >> theMat(1, 2)
>> theMat(2, 1) >> theMat(2, 2);
return theReadData;
}
inline StdObjMgt_WriteData& operator <<
(StdObjMgt_WriteData::Object theWriteData, const gp_Mat2d& theMat)
{
theWriteData
<< theMat(1, 1) << theMat(1, 2)
<< theMat(2, 1) << theMat(2, 2);
return theWriteData;
}
inline StdObjMgt_ReadData& operator >>
(StdObjMgt_ReadData::Object theReadData, gp_Mat& theMat)
{
gp_XYZ aRow1, aRow2, aRow3;
theReadData >> aRow1 >> aRow2 >> aRow3;
theMat.SetRows (aRow1, aRow2, aRow3);
theReadData
>> theMat(1, 1) >> theMat(1, 2) >> theMat(1, 3)
>> theMat(2, 1) >> theMat(2, 2) >> theMat(2, 3)
>> theMat(3, 1) >> theMat(3, 2) >> theMat(3, 3);
return theReadData;
}
inline StdObjMgt_WriteData& operator <<
(StdObjMgt_WriteData::Object theWriteData, const gp_Mat& theMat)
{
theWriteData
<< theMat(1, 1) << theMat(1, 2) << theMat(1, 3)
<< theMat(2, 1) << theMat(2, 2) << theMat(2, 3)
<< theMat(3, 1) << theMat(3, 2) << theMat(3, 3);
return theWriteData;
}
inline StdObjMgt_ReadData& operator >>
(StdObjMgt_ReadData::Object theReadData, gp_Trsf2d& theTrsf)
{
@ -58,6 +78,19 @@ inline StdObjMgt_ReadData& operator >>
return theReadData;
}
inline StdObjMgt_WriteData& operator <<
(StdObjMgt_WriteData::Object theWriteData, const gp_Trsf2d& theTrsf)
{
Standard_Real aScale = theTrsf.ScaleFactor();
Standard_Integer aForm = theTrsf.Form();
const gp_Mat2d& aMat = theTrsf.HVectorialPart();
const gp_XY& aLoc = theTrsf.TranslationPart();
theWriteData << aScale << aForm << aMat << aLoc;
return theWriteData;
}
inline StdObjMgt_ReadData& operator >>
(StdObjMgt_ReadData::Object theReadData, gp_Trsf& theTrsf)
{
@ -76,5 +109,17 @@ inline StdObjMgt_ReadData& operator >>
return theReadData;
}
inline StdObjMgt_WriteData& operator <<
(StdObjMgt_WriteData::Object theWriteData, const gp_Trsf& theTrsf)
{
Standard_Real aScale = theTrsf.ScaleFactor();
Standard_Integer aForm = theTrsf.Form();
const gp_Mat& aMat = theTrsf.HVectorialPart();
const gp_XYZ& aLoc = theTrsf.TranslationPart();
theWriteData << aScale << aForm << aMat << aLoc;
return theWriteData;
}
#endif

97
src/StdObject/StdObject_gp_Vectors.hxx
View File

@ -17,6 +17,7 @@
#include <StdObjMgt_ReadData.hxx>
#include <StdObjMgt_WriteData.hxx>
#include <gp_Pnt2d.hxx>
#include <gp_Vec2d.hxx>
@ -35,68 +36,126 @@ inline StdObjMgt_ReadData& operator >>
return theReadData;
}
inline StdObjMgt_WriteData& operator <<
(StdObjMgt_WriteData::Object theWriteData, const gp_XY& theXY)
{
Standard_Real aX = theXY.X(), aY = theXY.Y();
theWriteData << aX << aY;
return theWriteData;
}
inline StdObjMgt_ReadData& operator >>
(StdObjMgt_ReadData::Object theReadData, gp_Pnt2d& thePnt)
{
Standard_Real aX, aY;
theReadData >> aX >> aY;
thePnt.SetCoord (aX, aY);
gp_XY aXY;
theReadData >> aXY;
thePnt.SetXY (aXY);
return theReadData;
}
inline StdObjMgt_WriteData& operator <<
(StdObjMgt_WriteData::Object theWriteData, const gp_Pnt2d& thePnt)
{
theWriteData << thePnt.XY();
return theWriteData;
}
inline StdObjMgt_ReadData& operator >>
(StdObjMgt_ReadData::Object theReadData, gp_Vec2d& theVec)
{
Standard_Real aX, aY;
theReadData >> aX >> aY;
theVec.SetCoord (aX, aY);
gp_XY aXY;
theReadData >> aXY;
theVec.SetXY (aXY);
return theReadData;
}
inline StdObjMgt_WriteData& operator <<
(StdObjMgt_WriteData::Object theWriteData, const gp_Vec2d& theVec)
{
theWriteData << theVec.XY();
return theWriteData;
}
inline StdObjMgt_ReadData& operator >>
(StdObjMgt_ReadData::Object theReadData, gp_Dir2d& theDir)
{
Standard_Real aX, aY;
theReadData >> aX >> aY;
theDir.SetCoord (aX, aY);
gp_XY aXY;
theReadData >> aXY;
theDir.SetXY (aXY);
return theReadData;
}
inline StdObjMgt_WriteData& operator <<
(StdObjMgt_WriteData::Object theWriteData, const gp_Dir2d& theDir)
{
theWriteData << theDir.XY();
return theWriteData;
}
inline StdObjMgt_ReadData& operator >>
(StdObjMgt_ReadData::Object theReadData, gp_XYZ& theXYZ)
{
Standard_Real aX, aY, aZ;
theReadData >> aX >> aY >> aZ;
theXYZ.SetCoord (aX, aY, aZ);
theXYZ.SetCoord(aX, aY, aZ);
return theReadData;
}
inline StdObjMgt_WriteData& operator <<
(StdObjMgt_WriteData::Object theWriteData, const gp_XYZ& theXYZ)
{
Standard_Real aX = theXYZ.X(), aY = theXYZ.Y(), aZ = theXYZ.Z();
theWriteData << aX << aY << aZ;
return theWriteData;
}
inline StdObjMgt_ReadData& operator >>
(StdObjMgt_ReadData::Object theReadData, gp_Pnt& thePnt)
{
Standard_Real aX, aY, aZ;
theReadData >> aX >> aY >> aZ;
thePnt.SetCoord (aX, aY, aZ);
gp_XYZ aXYZ;
theReadData >> aXYZ;
thePnt.SetXYZ (aXYZ);
return theReadData;
}
inline StdObjMgt_WriteData& operator <<
(StdObjMgt_WriteData::Object theWriteData, const gp_Pnt& thePnt)
{
theWriteData << thePnt.XYZ();
return theWriteData;
}
inline StdObjMgt_ReadData& operator >>
(StdObjMgt_ReadData::Object theReadData, gp_Vec& theVec)
{
Standard_Real aX, aY, aZ;
theReadData >> aX >> aY >> aZ;
theVec.SetCoord (aX, aY, aZ);
gp_XYZ aXYZ;
theReadData >> aXYZ;
theVec.SetXYZ (aXYZ);
return theReadData;
}
inline StdObjMgt_WriteData& operator <<
(StdObjMgt_WriteData::Object theWriteData, const gp_Vec& theVec)
{
theWriteData << theVec.XYZ();
return theWriteData;
}
inline StdObjMgt_ReadData& operator >>
(StdObjMgt_ReadData::Object theReadData, gp_Dir& theDir)
{
Standard_Real aX, aY, aZ;
theReadData >> aX >> aY >> aZ;
theDir.SetCoord (aX, aY, aZ);
gp_XYZ aXYZ;
theReadData >> aXYZ;
theDir.SetXYZ(aXYZ);
return theReadData;
}
inline StdObjMgt_WriteData& operator <<
(StdObjMgt_WriteData::Object theWriteData, const gp_Dir& theDir)
{
theWriteData << theDir.XYZ();
return theWriteData;
}
#endif

1
src/StdPersistent/StdPersistent.hxx
View File

@ -16,7 +16,6 @@
#define _StdPersistent_HeaderFile
#include <Standard_Macro.hxx>
class StdObjMgt_MapOfInstantiators;
class StdPersistent

30
src/StdPersistent/StdPersistent_DataXtd.hxx
View File

@ -59,4 +59,34 @@ public:
};
};
template<>
inline Standard_CString StdLPersistent_Void::instance<TDataXtd_Shape>::PName() const
{ return "PDataXtd_Shape"; }
template<>
inline Standard_CString StdLPersistent_Void::instance<TDataXtd_Point>::PName() const
{ return "PDataXtd_Point"; }
template<>
inline Standard_CString StdLPersistent_Void::instance<TDataXtd_Axis>::PName() const
{ return "PDataXtd_Axis"; }
template<>
inline Standard_CString StdLPersistent_Void::instance<TDataXtd_Plane>::PName() const
{ return "PDataXtd_Plane"; }
template<>
inline Standard_CString StdLPersistent_Void::instance<TDataXtd_Placement>::PName() const
{ return "PDataXtd_Placement"; }
template<>
template<>
inline Standard_CString StdObjMgt_Attribute<TDataXtd_Geometry>::Simple<Standard_Integer>::PName() const
{ return "PDataXtd_Geometry"; }
template<>
template<>
inline Standard_CString StdObjMgt_Attribute<TDataXtd_Position>::Simple<gp_Pnt>::PName() const
{ return "PDataXtd_Position"; }
#endif

15
src/StdPersistent/StdPersistent_DataXtd_Constraint.hxx
View File

@ -31,6 +31,21 @@ public:
theReadData >> myType >> myGeometries >> myValue
>> myIsReversed >> myIsInverted >> myIsVerified >> myPlane;
}
//! Write persistent data to a file.
inline void Write (StdObjMgt_WriteData& theWriteData) const
{
theWriteData << myType << myGeometries << myValue
<< myIsReversed << myIsInverted << myIsVerified << myPlane;
}
//! Gets persistent child objects
inline void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
{
theChildren.Append(myGeometries);
theChildren.Append(myValue);
theChildren.Append(myPlane);
}
//! Returns persistent type name
inline Standard_CString PName() const { return "PDataXtd_Constraint"; }
//! Import transient attribuite from the persistent data.
void Import (const Handle(TDataXtd_Constraint)& theAttribute) const;

19
src/StdPersistent/StdPersistent_DataXtd_PatternStd.hxx
View File

@ -30,6 +30,25 @@ public:
theReadData >> mySignature >> myAxis1Reversed >> myAxis2Reversed >>
myAxis1 >> myAxis2 >> myValue1 >> myValue2 >> myNb1 >> myNb2 >> myMirror;
}
//! Write persistent data to a file.
inline void Write(StdObjMgt_WriteData& theWriteData)
{
theWriteData << mySignature << myAxis1Reversed << myAxis2Reversed <<
myAxis1 << myAxis2 << myValue1 << myValue2 << myNb1 << myNb2 << myMirror;
}
//! Gets persistent child objects
inline void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
{
theChildren.Append(myAxis1);
theChildren.Append(myAxis2);
theChildren.Append(myValue1);
theChildren.Append(myValue2);
theChildren.Append(myNb1);
theChildren.Append(myNb2);
theChildren.Append(myMirror);
}
//! Returns persistent type name
inline Standard_CString PName() const { return "PDataXtd_PatternStd"; }
//! Import transient attribuite from the persistent data.
void Import (const Handle(TDataXtd_PatternStd)& theAttribute) const;

29
src/StdPersistent/StdPersistent_Naming.cxx
View File

@ -61,6 +61,15 @@ void StdPersistent_Naming::Name::Read (StdObjMgt_ReadData& theReadData)
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
@ -104,6 +113,16 @@ void StdPersistent_Naming::Name_1::Read (StdObjMgt_ReadData& theReadData)
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
@ -126,6 +145,16 @@ void StdPersistent_Naming::Name_2::Read (StdObjMgt_ReadData& theReadData)
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

40
src/StdPersistent/StdPersistent_Naming.hxx
View File

@ -35,7 +35,18 @@ public:
public:
//! Read persistent data from a file.
inline void Read (StdObjMgt_ReadData& theReadData)
{ theReadData >> myOldShapes >> myNewShapes >> myShapeStatus >> myVersion; }
{ theReadData >> myOldShapes >> myNewShapes >> myShapeStatus >> myVersion; }
//! Read persistent data from a file.
inline void Write (StdObjMgt_WriteData& theWriteData) const
{ theWriteData << myOldShapes << myNewShapes << myShapeStatus << myVersion; }
//! Gets persistent child objects
inline void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
{
if (!myOldShapes.IsNull()) theChildren.Append(myOldShapes);
if (!myNewShapes.IsNull()) theChildren.Append(myNewShapes);
}
//! Returns persistent type name
inline Standard_CString PName() const { return "PNaming_NamedShape"; }
//! Import transient attribuite from the persistent data.
void Import (const Handle(TNaming_NamedShape)& theAttribute) const;
@ -52,6 +63,16 @@ public:
public:
//! Read persistent data from a file.
Standard_EXPORT virtual void Read (StdObjMgt_ReadData& theReadData);
//! Read persistent data from a file.
Standard_EXPORT virtual void Write (StdObjMgt_WriteData& theWriteData) const;
//! Gets persistent child objects
inline void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
{
if (!myArgs.IsNull()) theChildren.Append(myArgs);
if (!myStop.IsNull()) theChildren.Append(myStop);
}
//! Returns persistent type name
inline Standard_CString PName() const { return "PNaming_Name"; }
//! Import transient object from the persistent data.
Standard_EXPORT virtual void Import
@ -70,6 +91,16 @@ public:
public:
//! Read persistent data from a file.
Standard_EXPORT virtual void Read (StdObjMgt_ReadData& theReadData);
//! Read persistent data from a file.
Standard_EXPORT virtual void Write (StdObjMgt_WriteData& theWriteData) const;
//! Gets persistent child objects
inline void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
{
Name::PChildren(theChildren);
if (!myContextLabel.IsNull()) theChildren.Append(myContextLabel);
}
//! Returns persistent type name
inline Standard_CString PName() const { return "PNaming_Name_1"; }
//! Import transient object from the persistent data.
Standard_EXPORT virtual void Import
@ -84,6 +115,13 @@ public:
public:
//! Read persistent data from a file.
Standard_EXPORT virtual void Read (StdObjMgt_ReadData& theReadData);
//! Read persistent data from a file.
Standard_EXPORT virtual void Write (StdObjMgt_WriteData& theWriteData) const;
//! Gets persistent child objects
inline void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
{ Name_1::PChildren(theChildren); }
//! Returns persistent type name
inline Standard_CString PName() const { return "PNaming_Name_2"; }
//! Import transient object from the persistent data.
Standard_EXPORT virtual void Import

21
src/StdPersistent/StdPersistent_PPrsStd.hxx
View File

@ -32,6 +32,19 @@ public:
theReadData >> myIsDisplayed >> myDriverGUID
>> myTransparency >> myColor >> myMaterial >> myWidth;
}
//! Write persistent data to a file.
inline void Write (StdObjMgt_WriteData& theWriteData) const
{
theWriteData << myIsDisplayed << myDriverGUID
<< myTransparency << myColor << myMaterial << myWidth;
}
//! Gets persistent child objects
inline void PChildren(StdObjMgt_Persistent::SequenceOfPersistent& theChildren) const
{
theChildren.Append(myDriverGUID);
}
//! Returns persistent type name
inline Standard_CString PName() const { return "PPrsStd_AISPresentation"; }
//! Import transient attribuite from the persistent data.
void Import (const Handle(TDataXtd_Presentation)& theAttribute) const;
@ -54,6 +67,14 @@ public:
AISPresentation::Read (theReadData);
theReadData >> myMode;
}
//! Write persistent data to a file.
inline void Write (StdObjMgt_WriteData& theWriteData)
{
AISPresentation::Write (theWriteData);
theWriteData << myMode;
}
//! Returns persistent type name
inline Standard_CString PName() const { return "PPrsStd_AISPresentation_1"; }
//! Import transient attribuite from the persistent data.
void Import (const Handle(TDataXtd_Presentation)& theAttribute) const;

63
src/StdPersistent/StdPersistent_TopLoc.cxx
View File

@ -13,6 +13,7 @@
#include <StdPersistent_TopLoc.hxx>
#include <StdObjMgt_ReadData.hxx>
#include <StdObjMgt_WriteData.hxx>
#include <StdObject_gp_Trsfs.hxx>
@ -27,6 +28,11 @@ void StdPersistent_TopLoc::Datum3D::Read (StdObjMgt_ReadData& theReadData)
myTransient = new TopLoc_Datum3D (aTrsf);
}
void StdPersistent_TopLoc::Datum3D::Write(StdObjMgt_WriteData& theWriteData) const
{
theWriteData << myTransient->Transformation();
}
//=======================================================================
//function : Read
//purpose : Read persistent data from a file
@ -36,6 +42,26 @@ void StdPersistent_TopLoc::ItemLocation::Read (StdObjMgt_ReadData& theReadData)
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
@ -48,3 +74,40 @@ TopLoc_Location StdPersistent_TopLoc::ItemLocation::Import() const
else
return aNext;
}
//=======================================================================
//function : Translate
//purpose : Create a persistent object from a location
//=======================================================================
Handle(StdPersistent_TopLoc::ItemLocation)
StdPersistent_TopLoc::Translate (const TopLoc_Location& theLoc,
StdObjMgt_TransientPersistentMap& theMap)
{
Handle(ItemLocation) aPLoc = new ItemLocation;
aPLoc->myDatum = Translate(theLoc.FirstDatum(), theMap);
aPLoc->myPower = theLoc.FirstPower();
aPLoc->myNext = StdObject_Location::Translate(theLoc.NextLocation(), theMap);
return aPLoc;
}
//=======================================================================
//function : Translate
//purpose : Create a persistent object from a location datum
//=======================================================================
Handle(StdPersistent_TopLoc::Datum3D)
StdPersistent_TopLoc::Translate (const Handle(TopLoc_Datum3D)& theDatum,
StdObjMgt_TransientPersistentMap& theMap)
{
Handle(Datum3D) aPDatum;
if (theMap.IsBound(theDatum))
{
aPDatum = Handle(Datum3D)::DownCast(theMap.Find(theDatum));
}
else
{
aPDatum = new Datum3D;
aPDatum->Transient(theDatum);
theMap.Bind(theDatum, aPDatum);
}
return aPDatum;
}

23
src/StdPersistent/StdPersistent_TopLoc.hxx
View File

@ -18,6 +18,7 @@
#include <StdObjMgt_SharedObject.hxx>
#include <StdObjMgt_Persistent.hxx>
#include <StdObject_Location.hxx>
#include <StdObjMgt_TransientPersistentMap.hxx>
#include <TopLoc_Datum3D.hxx>
#include <TopLoc_Location.hxx>
@ -31,13 +32,29 @@ public:
public:
//! Read persistent data from a file.
void Read (StdObjMgt_ReadData& theReadData);
//! Write persistent data to a file.
void Write (StdObjMgt_WriteData& theWriteData) const;
//! Gets persistent child objects
Standard_EXPORT virtual void PChildren(SequenceOfPersistent&) const { }
//! Returns persistent type name
Standard_EXPORT virtual Standard_CString PName () const
{ return "PTopLoc_Datum3D"; }
};
class ItemLocation : public StdObjMgt_Persistent
{
friend class StdPersistent_TopLoc;
public:
//! Read persistent data from a file.
Standard_EXPORT virtual void Read (StdObjMgt_ReadData& theReadData);
//! Write persistent data to a file.
Standard_EXPORT virtual void Write (StdObjMgt_WriteData& theWriteData) const;
//! Gets persistent child objects
Standard_EXPORT virtual void PChildren(SequenceOfPersistent& theChildren) const;
//! Returns persistent type name
Standard_EXPORT virtual Standard_CString PName () const
{ return "PTopLoc_ItemLocation"; }
//! Import transient object from the persistent data.
Standard_EXPORT TopLoc_Location Import() const;
@ -47,6 +64,12 @@ public:
Standard_Integer myPower;
StdObject_Location myNext;
};
public:
Standard_EXPORT static Handle(ItemLocation) Translate (const TopLoc_Location& theLoc,
StdObjMgt_TransientPersistentMap& theMap);
Standard_EXPORT static Handle(Datum3D) Translate (const Handle(TopLoc_Datum3D)& theDatum,
StdObjMgt_TransientPersistentMap& theMap);
};
#endif

11
src/StdPersistent/StdPersistent_TopoDS.hxx
View File

@ -17,6 +17,7 @@
#include <StdObjMgt_SharedObject.hxx>
#include <StdObjMgt_ReadData.hxx>
#include <StdObjMgt_WriteData.hxx>
#include <TopoDS_TShape.hxx>
@ -26,9 +27,19 @@ class StdPersistent_TopoDS : protected StdObjMgt_SharedObject
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;

18
src/StdStorage/FILES Normal file
View File

@ -0,0 +1,18 @@
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

319
src/StdStorage/StdStorage.cxx Normal file
View File

@ -0,0 +1,319 @@
// 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;
}

72
src/StdStorage/StdStorage.hxx Normal file
View File

@ -0,0 +1,72 @@
// 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

213
src/StdStorage/StdStorage_BacketOfPersistent.cxx Normal file
View File

@ -0,0 +1,213 @@
// 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;
}
}
}

114
src/StdStorage/StdStorage_BacketOfPersistent.hxx Normal file
View File

@ -0,0 +1,114 @@
// 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

20
src/StdObjMgt/StdObjMgt_MapOfInstantiators.cxx → src/StdStorage/StdStorage_Data.cxx
View File

@ -1,4 +1,4 @@
// Copyright (c) 2015 OPEN CASCADE SAS
// Copyright (c) 2017 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
@ -11,5 +11,21 @@
// 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>
#include <StdObjMgt_MapOfInstantiators.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();
}

90
src/StdStorage/StdStorage_Data.hxx Normal file
View File

@ -0,0 +1,90 @@
// 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

11
src/StdStorage/StdStorage_HSequenceOfRoots.hxx Normal file
View File

@ -0,0 +1,11 @@
#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

324
src/StdStorage/StdStorage_HeaderData.cxx Normal file
View File

@ -0,0 +1,324 @@
// 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();
}

142
src/StdStorage/StdStorage_HeaderData.hxx Normal file
View File

@ -0,0 +1,142 @@
// 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

13
src/StdStorage/StdStorage_MapOfRoots.hxx Normal file
View File

@ -0,0 +1,13 @@
#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

28
src/StdStorage/StdStorage_MapOfTypes.hxx Normal file
View File

@ -0,0 +1,28 @@
// 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

82
src/StdStorage/StdStorage_Root.cxx Normal file
View File

@ -0,0 +1,82 @@
// 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;
}

83
src/StdStorage/StdStorage_Root.hxx Normal file
View File

@ -0,0 +1,83 @@
// 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

210
src/StdStorage/StdStorage_RootData.cxx Normal file
View File

@ -0,0 +1,210 @@
// 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;
}

104
src/StdStorage/StdStorage_RootData.hxx Normal file
View File

@ -0,0 +1,104 @@
// 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

10
src/StdStorage/StdStorage_SequenceOfRoots.hxx Normal file
View File

@ -0,0 +1,10 @@
#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

242
src/StdStorage/StdStorage_TypeData.cxx Normal file
View File

@ -0,0 +1,242 @@
// 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;
}

110
src/StdStorage/StdStorage_TypeData.hxx Normal file
View File

@ -0,0 +1,110 @@
// 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

1
src/TKStd/PACKAGES
View File

@ -1,4 +1,5 @@
StdDrivers
StdObject
StdPersistent
StdStorage
ShapePersistent

2
tests/persist/end Normal file
View File

@ -0,0 +1,2 @@
# to end a test script
puts "TEST COMPLETED"

5
tests/persist/fsd/A1 Normal file
View File

@ -0,0 +1,5 @@
vertex base 0 1 2
check_fsd base bin
check_fsd base cmp
check_fsd base gen

6
tests/persist/fsd/A2 Normal file
View File

@ -0,0 +1,6 @@
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

6
tests/persist/fsd/A3 Normal file
View File

@ -0,0 +1,6 @@
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

Some files were not shown because too many files have changed in this diff Show More