OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-09-18 14:27:39 +03:00
Code Activity

Merge remote-tracking branch 'remotes/origin/CR26229_V6_9_0p1' into CR25926_V6_9_0p3

Browse Source
This commit is contained in:
pdn
2015-08-24 16:59:17 +03:00
parent a495ec8d5e 81234cf250
commit 3e63891d8f
161 changed files with 5047 additions and 4454 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
adm/UDLIST
View File

@@ -240,7 +240,6 @@ p BinMDataXtd
p BinMDocStd
p BinMFunction
p BinMNaming
p BinMPrsStd
p BinObjMgt
p BinTools
p CDF
@@ -253,7 +252,6 @@ p MDataXtd
p MDocStd
p MFunction
p MNaming
p MPrsStd
p MgtBRep
p MgtGeom
p MgtGeom2d
@@ -277,7 +275,6 @@ p PGeom2d
p PMMgt
p PNaming
p PPoly
p PPrsStd
p PShort
p PStandard
p PTColStd
@@ -301,7 +298,6 @@ p XmlMDataXtd
p XmlMDocStd
p XmlMFunction
p XmlMNaming
p XmlMPrsStd
p XmlObjMgt
r StdResource
r XmlOcafResource
@@ -318,6 +314,7 @@ t TKCDF
t TKLCAF
t TKPCAF
t TKPLCAF
t TKVCAF
t TKPShape
t TKShapeSchema
t TKStdLSchema

2
src/BinDrivers/BinDrivers.cxx
View File

@@ -21,7 +21,6 @@
#include <BinMNaming.hxx>
#include <BinMDocStd.hxx>
#include <BinMFunction.hxx>
#include <BinMPrsStd.hxx>
#include <Standard_Failure.hxx>
#include <BinDrivers_DocumentStorageDriver.hxx>
#include <BinDrivers_DocumentRetrievalDriver.hxx>
@@ -76,7 +75,6 @@ Handle(BinMDF_ADriverTable) BinDrivers::AttributeDrivers
BinMNaming ::AddDrivers (aTable, aMsgDrv);
BinMDocStd ::AddDrivers (aTable, aMsgDrv);
BinMFunction ::AddDrivers (aTable, aMsgDrv);
BinMPrsStd ::AddDrivers (aTable, aMsgDrv);
return aTable;
}

11
src/BinDrivers/BinDrivers_DocumentRetrievalDriver.cdl
View File

@@ -20,7 +20,8 @@ uses
ADriverTable from BinMDF,
Position from Storage,
IStream from Standard,
DocumentSection from BinLDrivers
DocumentSection from BinLDrivers ,
IODevice from Storage
is
-- ===== Public methods =====
@@ -34,12 +35,12 @@ is
ReadShapeSection (me: mutable;
theSection : in out DocumentSection from BinLDrivers;
theIS : in out IStream from Standard;
isMess : Boolean from Standard = Standard_False) is redefined virtual;
theDevice : IODevice from Storage;
isMess : Boolean from Standard = Standard_False) is redefined virtual;
CheckShapeSection (me: mutable;
thePos : Position from Storage;
theIS : in out IStream from Standard) is redefined virtual;
thePos : Position from Storage;
theDevice : IODevice from Storage) is redefined virtual protected;
PropagateDocumentVersion(me: mutable; theVersion : Integer from Standard)
is redefined virtual;

55
src/BinDrivers/BinDrivers_DocumentRetrievalDriver.cxx
View File

@@ -24,6 +24,9 @@
#include <Standard_Failure.hxx>
#include <Standard_IStream.hxx>
#include <Standard_ErrorHandler.hxx>
#include <string>
//=======================================================================
//function : BinDrivers_DocumentRetrievalDriver
//purpose : Constructor
@@ -49,28 +52,44 @@ Handle(BinMDF_ADriverTable) BinDrivers_DocumentRetrievalDriver::AttributeDrivers
//purpose :
//=======================================================================
void BinDrivers_DocumentRetrievalDriver::ReadShapeSection
(BinLDrivers_DocumentSection& /*theSection*/,
Standard_IStream& theIS,
const Standard_Boolean /*isMess*/)
void BinDrivers_DocumentRetrievalDriver::ReadShapeSection( BinLDrivers_DocumentSection& theSection,
const Handle(Storage_IODevice)& theDevice,
const Standard_Boolean /*isMess*/)
{
// Read Shapes
Standard_Character* aBuf = 0;
Handle(BinMNaming_NamedShapeDriver) aNamedShapeDriver;
if (myDrivers->GetDriver(STANDARD_TYPE(TNaming_NamedShape),aNamedShapeDriver))
{
try {
OCC_CATCH_SIGNALS
aNamedShapeDriver->ReadShapeSection (theIS);
}
catch(Standard_Failure) {
Handle(Standard_Failure) aFailure = Standard_Failure::Caught();
const TCollection_ExtendedString aMethStr
("BinDrivers_DocumentRetrievalDriver: ");
WriteMessage (aMethStr + "error of Shape Section " +
aFailure->GetMessageString());
if (myDrivers->GetDriver(STANDARD_TYPE(TNaming_NamedShape), aNamedShapeDriver))
{
try {
OCC_CATCH_SIGNALS
aBuf = (Standard_Character*)malloc( theSection.Length() + 1 );
Standard_Size aSize = theDevice->Read( (Standard_Address)aBuf, theSection.Length() );
if ( aSize == theSection.Length() )
{
Standard_SStream aStrStream( std::string( aBuf, aSize ), Standard_SStream::in | Standard_SStream::binary );
aNamedShapeDriver->ReadShapeSection( aStrStream );
}
else
WriteMessage( "BinDrivers_DocumentRetrievalDriver: can't read all shape section data." );
}
catch(Standard_Failure) {
if ( aBuf )
{
free( aBuf );
aBuf = 0;
}
Handle(Standard_Failure) aFailure = Standard_Failure::Caught();
const TCollection_ExtendedString aMethStr ("BinDrivers_DocumentRetrievalDriver: ");
WriteMessage (aMethStr + "error of Shape Section " +
aFailure->GetMessageString());
}
}
if ( aBuf )
free( aBuf );
}
//=======================================================================
@@ -78,8 +97,8 @@ void BinDrivers_DocumentRetrievalDriver::ReadShapeSection
//purpose :
//=======================================================================
void BinDrivers_DocumentRetrievalDriver::CheckShapeSection(
const Storage_Position& /*ShapeSectionPos*/,
Standard_IStream& /*IS*/)
const Storage_Position& /*ShapeSectionPos*/,
const Handle(Storage_IODevice)& /*theDevice*/)
{}
//=======================================================================

5
src/BinDrivers/BinDrivers_DocumentStorageDriver.cdl
View File

@@ -21,7 +21,8 @@ uses
OStream from Standard,
MessageDriver from CDM,
DocumentSection from BinLDrivers,
ADriverTable from BinMDF
ADriverTable from BinMDF,
IODevice from Storage
is
-- ===== Public methods =====
@@ -34,7 +35,7 @@ is
is redefined virtual;
WriteShapeSection (me: mutable; theDocSection : in out DocumentSection from BinLDrivers;
theOS : in out OStream from Standard)
theDevice : IODevice from Storage)
is redefined virtual;
---Purpose: implements the procedure of writing a shape section to file

30
src/BinDrivers/BinDrivers_DocumentStorageDriver.cxx
View File

@@ -15,11 +15,15 @@
#include <BinDrivers_DocumentStorageDriver.ixx>
#include <Standard_ErrorHandler.hxx>
#include <Standard_SStream.hxx>
#include <TCollection_AsciiString.hxx>
#include <BinDrivers.hxx>
#include <BinMDF_ADriver.hxx>
#include <BinMNaming_NamedShapeDriver.hxx>
#include <TNaming_NamedShape.hxx>
#include <string>
//=======================================================================
//function : BinDrivers_DocumentStorageDriver
//purpose : Constructor
@@ -45,25 +49,37 @@ Handle(BinMDF_ADriverTable) BinDrivers_DocumentStorageDriver::AttributeDrivers
//purpose : Implements WriteShapeSection
//=======================================================================
void BinDrivers_DocumentStorageDriver::WriteShapeSection
(BinLDrivers_DocumentSection& theSection,
Standard_OStream& theOS)
(BinLDrivers_DocumentSection& theSection,
const Handle(Storage_IODevice)& theDevice)
{
const Standard_Size aShapesSectionOffset = (Standard_Size) theOS.tellp();
if (!theDevice->CanWrite())
{
return;
}
const Standard_Size aShapesSectionOffset = theDevice->Tell();
Handle(BinMNaming_NamedShapeDriver) aNamedShapeDriver;
if (myDrivers->GetDriver(STANDARD_TYPE(TNaming_NamedShape), aNamedShapeDriver)) {
try {
OCC_CATCH_SIGNALS aNamedShapeDriver->WriteShapeSection (theOS);
OCC_CATCH_SIGNALS
Standard_SStream aStrStream( Standard_SStream::out | Standard_SStream::binary );
aNamedShapeDriver->WriteShapeSection( aStrStream );
std::string aData = aStrStream.str();
Standard_Size aSize = theDevice->Write( (Standard_Address)aData.c_str(), aData.length() );
if ( aSize < aData.length() )
WriteMessage( "BinDrivers_DocumentRetrievalDriver: can't write all shape section data." );
}
catch(Standard_Failure) {
TCollection_ExtendedString anErrorStr ("Error: ");
Handle(Standard_Failure) aFailure = Standard_Failure::Caught();
TCollection_ExtendedString aStr =
anErrorStr + "BinDrivers_DocumentStorageDriver, Shape Section :";
TCollection_ExtendedString aStr = anErrorStr + "BinDrivers_DocumentStorageDriver, Shape Section :";
WriteMessage (aStr + aFailure->GetMessageString());
}
}
// Write the section info in the TOC.
theSection.Write (theOS, aShapesSectionOffset);
theSection.Write (theDevice, aShapesSectionOffset);
}

1
src/BinLDrivers/BinLDrivers.cxx
View File

@@ -74,7 +74,6 @@ Handle(BinMDF_ADriverTable) BinLDrivers::AttributeDrivers
BinMDocStd ::AddDrivers (aTable, aMsgDrv);
// BinMNaming ::AddDrivers (aTable, aMsgDrv);
// BinMPrsStd ::AddDrivers (aTable, aMsgDrv);
return aTable;
}

19
src/BinLDrivers/BinLDrivers_DocumentRetrievalDriver.cdl
View File

@@ -29,6 +29,7 @@ uses
Persistent from BinObjMgt,
Label from TDF,
IStream from Standard,
IODevice from Storage,
MapOfInteger from TColStd,
DocumentSection from BinLDrivers,
VectorOfDocumentSection from BinLDrivers
@@ -52,7 +53,7 @@ is
returns Document from CDM is redefined virtual;
---Purpose: pure virtual method definition
Read(me:mutable; theFileName: ExtendedString from TCollection;
Read(me:mutable; theDevice: IODevice from Storage;
theNewDocument: Document from CDM;
theApplication: Application from CDM) is redefined virtual;
---Purpose: retrieves the content of the file into a new Document.
@@ -63,14 +64,14 @@ is
-- ===== Protected methods =====
ReadSubTree (me: mutable; theIS : in out IStream from Standard;
ReadSubTree (me: mutable; theDevice: IODevice from Storage;
theData : Label from TDF)
returns Integer from Standard
is virtual protected;
---Purpose: Read the tree from the stream <theIS> to <theLabel>
ReadInfoSection(me: mutable; theFile : AsciiString from TCollection;
theData : in out HeaderData from Storage)
ReadInfoSection(me: mutable; theDevice: IODevice from Storage;
theData : in out HeaderData from Storage)
returns Position from Storage is protected;
---Purpose: Read the info section of theFile into theData,
-- return a file position corresponding to the info
@@ -79,19 +80,19 @@ is
ReadSection (me: mutable;
theSection : in out DocumentSection from BinLDrivers;
theDoc : Document from CDM;
theIS : in out IStream from Standard)
theDevice : IODevice from Storage)
is virtual protected;
---Purpose: define the procedure of reading a section to file.
ReadShapeSection (me: mutable;
theSection : in out DocumentSection from BinLDrivers;
theIS : in out IStream from Standard;
isMess : Boolean from Standard = Standard_False)
theDevice: IODevice from Storage;
isMess : Boolean from Standard = Standard_False)
is virtual protected;
CheckShapeSection (me: mutable;
thePos : Position from Storage;
theIS : in out IStream from Standard)
thePos : Position from Storage;
theDevice: IODevice from Storage)
is virtual protected;
PropagateDocumentVersion(me: mutable; theVersion : Integer from Standard)

116
src/BinLDrivers/BinLDrivers_DocumentRetrievalDriver.cxx
View File

@@ -82,10 +82,9 @@ void BinLDrivers_DocumentRetrievalDriver::Make (const Handle(PCDM_Document)&,
#define START_TYPES "START_TYPES"
#define END_TYPES "END_TYPES"
void BinLDrivers_DocumentRetrievalDriver::Read
(const TCollection_ExtendedString& theFileName,
const Handle(CDM_Document)& theNewDocument,
const Handle(CDM_Application)& theApplication)
void BinLDrivers_DocumentRetrievalDriver::Read (const Handle(Storage_IODevice)& theDevice,
const Handle(CDM_Document)& theNewDocument,
const Handle(CDM_Application)& theApplication)
{
myReaderStatus = PCDM_RS_DriverFailure;
myMsgDriver = theApplication -> MessageDriver();
@@ -103,11 +102,9 @@ void BinLDrivers_DocumentRetrievalDriver::Read
return;
}
TCollection_AsciiString aFileName (theFileName);
// 1. Read the information section
Handle(Storage_HeaderData) aHeaderData;
Storage_Position anInfoSectionEnd = ReadInfoSection( aFileName, aHeaderData );
Storage_Position anInfoSectionEnd = ReadInfoSection( theDevice, aHeaderData );
if (!anInfoSectionEnd) {
WriteMessage (aMethStr + "error: file has invalid header");
myReaderStatus = PCDM_RS_UnrecognizedFileFormat;
@@ -178,22 +175,24 @@ void BinLDrivers_DocumentRetrievalDriver::Read
WriteMessage (aTypeNames(i));
}
// Open the file stream
#ifdef _WIN32
ifstream anIS ((const wchar_t*) theFileName.ToExtString(), ios::in | ios::binary);
#else
ifstream anIS (aFileName.ToCString());
#endif
theDevice->Open (Storage_VSRead);
if (!anIS) {
// Open the file stream
//#ifdef _WIN32
// ifstream anIS ((const wchar_t*) theFileName.ToExtString(), ios::in | ios::binary);
//#else
// ifstream anIS (aFileName.ToCString());
//#endif
if (!theDevice->CanRead()) {
// Can not open file
WriteMessage (aMethStr + "error: can't open file " + theFileName);
WriteMessage (aMethStr + "error: can't read " + theDevice->Name());
myReaderStatus = PCDM_RS_OpenError;
return;
}
// skip info section
anIS.seekg( (streampos) anInfoSectionEnd );
theDevice->Seek ((streampos) anInfoSectionEnd);
// propagate the opened document version to data drivers
PropagateDocumentVersion(aFileVer);
@@ -211,30 +210,30 @@ void BinLDrivers_DocumentRetrievalDriver::Read
if (aFileVer >= 3) {
BinLDrivers_DocumentSection aSection;
do {
BinLDrivers_DocumentSection::ReadTOC (aSection, anIS);
BinLDrivers_DocumentSection::ReadTOC (aSection, theDevice);
mySections.Append(aSection);
} while
(!aSection.Name().IsEqual((Standard_CString)SHAPESECTION_POS));
aDocumentPos = anIS.tellg(); // position of root label
aDocumentPos = theDevice->Tell(); // position of root label
BinLDrivers_VectorOfDocumentSection::Iterator anIterS (mySections);
for (; anIterS.More(); anIterS.Next()) {
BinLDrivers_DocumentSection& aCurSection = anIterS.ChangeValue();
if (aCurSection.IsPostRead() == Standard_False) {
anIS.seekg ((streampos) aCurSection.Offset());
theDevice->Seek((streampos) aCurSection.Offset());
if (aCurSection.Name().IsEqual ((Standard_CString)SHAPESECTION_POS))
ReadShapeSection (aCurSection, anIS);
ReadShapeSection (aCurSection, theDevice);
else
ReadSection (aCurSection, theNewDocument, anIS);
ReadSection (aCurSection, theNewDocument, theDevice);
}
}
} else { //aFileVer < 3
aDocumentPos = anIS.tellg(); // position of root label
aDocumentPos = theDevice->Tell(); // position of root label
// retrieve SHAPESECTION_POS string
char aShapeSecLabel[SIZEOFSHAPELABEL + 1];
aShapeSecLabel[SIZEOFSHAPELABEL] = 0x00;
anIS.read ((char*)&aShapeSecLabel, SIZEOFSHAPELABEL);// SHAPESECTION_POS
theDevice->Read ((char*)&aShapeSecLabel, SIZEOFSHAPELABEL);// SHAPESECTION_POS
TCollection_AsciiString aShapeLabel(aShapeSecLabel);
// detect if a file was written in old fashion (version 2 without shapes)
// and if so then skip reading ShapeSection
@@ -248,7 +247,7 @@ void BinLDrivers_DocumentRetrievalDriver::Read
// retrieve ShapeSection Position
Standard_Integer aShapeSectionPos; // go to ShapeSection
anIS.read ((char*)&aShapeSectionPos, sizeof(Standard_Integer));
theDevice->Read ((char*)&aShapeSectionPos, sizeof(Standard_Integer));
#if DO_INVERSE
aShapeSectionPos = InverseInt (aShapeSectionPos);
@@ -257,26 +256,26 @@ void BinLDrivers_DocumentRetrievalDriver::Read
cout <<"aShapeSectionPos = " <<aShapeSectionPos <<endl;
#endif
if(aShapeSectionPos) {
aDocumentPos = anIS.tellg();
anIS.seekg((streampos) aShapeSectionPos);
aDocumentPos = theDevice->Tell();
theDevice->Seek ((streampos) aShapeSectionPos);
CheckShapeSection(aShapeSectionPos, anIS);
//CheckShapeSection(aShapeSectionPos, theDevice);
// Read Shapes
BinLDrivers_DocumentSection aCurSection;
ReadShapeSection (aCurSection, anIS, Standard_False);
ReadShapeSection (aCurSection, theDevice, Standard_False);
}
}
} // end of reading Sections or shape section
// Return to read of the Document structure
anIS.seekg(aDocumentPos);
theDevice->Seek (aDocumentPos);
// read the header (tag) of the root label
Standard_Integer aTag;
anIS.read ((char*)&aTag, sizeof(Standard_Integer));
theDevice->Read ((char*)&aTag, sizeof(Standard_Integer));
// read sub-tree of the root label
Standard_Integer nbRead = ReadSubTree (anIS, aData->Root());
Standard_Integer nbRead = ReadSubTree (theDevice, aData->Root());
myPAtt.Destroy(); // free buffer
myRelocTable.Clear();
myMapUnsupported.Clear();
@@ -295,8 +294,8 @@ void BinLDrivers_DocumentRetrievalDriver::Read
for (; anIterS.More(); anIterS.Next()) {
BinLDrivers_DocumentSection& aCurSection = anIterS.ChangeValue();
if (aCurSection.IsPostRead()) {
anIS.seekg ((streampos) aCurSection.Offset());
ReadSection (aCurSection, theNewDocument, anIS);
theDevice->Seek ((streampos) aCurSection.Offset());
ReadSection (aCurSection, theNewDocument, theDevice);
}
}
}
@@ -308,7 +307,7 @@ void BinLDrivers_DocumentRetrievalDriver::Read
//=======================================================================
Standard_Integer BinLDrivers_DocumentRetrievalDriver::ReadSubTree
(Standard_IStream& theIS,
(const Handle(Storage_IODevice)& theDevice,
const TDF_Label& theLabel)
{
Standard_Integer nbRead = 0;
@@ -316,9 +315,12 @@ Standard_Integer BinLDrivers_DocumentRetrievalDriver::ReadSubTree
("BinLDrivers_DocumentRetrievalDriver: ");
// Read attributes:
theIS >> myPAtt;
while (theIS && myPAtt.TypeId() > 0 && // not an end marker ?
myPAtt.Id() > 0) { // not a garbage ?
myPAtt.Read (theDevice);
while (theDevice->CanRead()
&& myPAtt.TypeId() > 0 // not an end marker ?
&& myPAtt.Id() > 0) // not a garbage ?
{
// get a driver according to TypeId
Handle(BinMDF_ADriver) aDriver = myDrivers->GetDriver (myPAtt.TypeId());
if (!aDriver.IsNull()) {
@@ -352,9 +354,9 @@ Standard_Integer BinLDrivers_DocumentRetrievalDriver::ReadSubTree
+ myPAtt.TypeId());
// read next attribute
theIS >> myPAtt;
}
if (!theIS || myPAtt.TypeId() != BinLDrivers_ENDATTRLIST) {
myPAtt.Read (theDevice);
}
if (!theDevice->CanRead() || myPAtt.TypeId() != BinLDrivers_ENDATTRLIST) {
// unexpected EOF or garbage data
WriteMessage (aMethStr + "error: unexpected EOF or garbage data");
myReaderStatus = PCDM_RS_UnrecognizedFileFormat;
@@ -364,23 +366,23 @@ Standard_Integer BinLDrivers_DocumentRetrievalDriver::ReadSubTree
// Read children:
// read the tag of a child label
Standard_Integer aTag = BinLDrivers_ENDLABEL;
theIS.read ((char*) &aTag, sizeof(Standard_Integer));
theDevice->Read ((char*) &aTag, sizeof(Standard_Integer));
#if DO_INVERSE
aTag = InverseInt (aTag);
#endif
while (theIS && aTag >= 0) { // not an end marker ?
while (theDevice->CanRead() && aTag >= 0) { // not an end marker ?
// create sub-label
TDF_Label aLab = theLabel.FindChild (aTag, Standard_True);
// read sub-tree
Standard_Integer nbSubRead = ReadSubTree(theIS, aLab);
Standard_Integer nbSubRead = ReadSubTree(theDevice, aLab);
// check for error
if (nbSubRead == -1)
return -1;
nbRead += nbSubRead;
// read the tag of the next child
theIS.read ((char*) &aTag, sizeof(Standard_Integer));
theDevice->Read ((char*) &aTag, sizeof(Standard_Integer));
#if DO_INVERSE
aTag = InverseInt (aTag);
#endif
@@ -413,7 +415,7 @@ Handle(BinMDF_ADriverTable) BinLDrivers_DocumentRetrievalDriver::AttributeDriver
//=======================================================================
Storage_Position BinLDrivers_DocumentRetrievalDriver::ReadInfoSection
(const TCollection_AsciiString& theFileName,
(const Handle(Storage_IODevice)& theDevice,
Handle(Storage_HeaderData)& theData)
{
TCollection_ExtendedString aMsg
@@ -421,7 +423,7 @@ Storage_Position BinLDrivers_DocumentRetrievalDriver::ReadInfoSection
FSD_BinaryFile aFileDriver;
Storage_Position aPos = 0;
if (aFileDriver.Open( theFileName, Storage_VSRead ) == Storage_VSOk)
if (aFileDriver.Open( theDevice, Storage_VSRead ) == Storage_VSOk)
{
Storage_Schema aSchema;
theData = aSchema.ReadHeaderSection( aFileDriver );
@@ -432,7 +434,7 @@ Storage_Position BinLDrivers_DocumentRetrievalDriver::ReadInfoSection
WriteMessage( aMsg + theData->ErrorStatusExtension() );
}
else
WriteMessage( aMsg + "can not open file " + theFileName);
WriteMessage( aMsg + "can not open file " + theDevice->Name());
aFileDriver.Close();
@@ -460,7 +462,7 @@ void BinLDrivers_DocumentRetrievalDriver::WriteMessage
void BinLDrivers_DocumentRetrievalDriver::ReadSection
(BinLDrivers_DocumentSection& /*theSection*/,
const Handle(CDM_Document)& /*theDocument*/,
Standard_IStream& /*theIS*/)
const Handle(Storage_IODevice)& /*theDevice*/)
{
// empty; should be redefined in subclasses
}
@@ -472,7 +474,7 @@ void BinLDrivers_DocumentRetrievalDriver::ReadSection
void BinLDrivers_DocumentRetrievalDriver::ReadShapeSection
(BinLDrivers_DocumentSection& theSection,
Standard_IStream& /*theIS*/,
const Handle(Storage_IODevice)& /*theDevice*/,
const Standard_Boolean isMess)
{
@@ -487,20 +489,10 @@ void BinLDrivers_DocumentRetrievalDriver::ReadShapeSection
//purpose :
//=======================================================================
void BinLDrivers_DocumentRetrievalDriver::CheckShapeSection(
const Storage_Position& ShapeSectionPos,
Standard_IStream& IS)
const Storage_Position& /*ShapeSectionPos*/,
const Handle(Storage_IODevice)& /*theDevice*/)
{
if (!IS.eof())
{
const std::streamoff endPos = IS.rdbuf()->pubseekoff(0L, std::ios_base::end, std::ios_base::in);
#ifdef OCCT_DEBUG
cout << "endPos = " << endPos <<endl;
#endif
if(ShapeSectionPos != endPos) {
const TCollection_ExtendedString aMethStr ("BinLDrivers_DocumentRetrievalDriver: ");
WriteMessage (aMethStr + "warning: Geometry is not supported by Lite schema. ");
}
}
}
//=======================================================================

9
src/BinLDrivers/BinLDrivers_DocumentSection.cdl
View File

@@ -20,7 +20,8 @@ class DocumentSection from BinLDrivers
uses
AsciiString from TCollection,
Size from Standard
Size from Standard,
IODevice from Storage
is
-- ===== Public methods =====
@@ -58,16 +59,16 @@ is
SetLength (me:in out; theLength: Size from Standard);
---Purpose: Set the length of the section in the persistent file
WriteTOC (me: in out; theOS : in out OStream from Standard);
WriteTOC (me: in out; theDevice : IODevice from Storage);
---Purpose: Create a Section entry in the Document TOC (list of sections)
Write (me: in out; theOS : in out OStream from Standard;
Write (me: in out; theDevice : IODevice from Storage;
theOffset: Size from Standard);
---Purpose: Save Offset and Length data into the Section entry
-- in the Document TOC (list of sections)
ReadTOC (myclass; theSection: out DocumentSection from BinLDrivers;
theIS : in out IStream from Standard);
theDevice : IODevice from Storage);
---Purpose: Fill a DocumentSection instance from the data that are read
-- from TOC.

31
src/BinLDrivers/BinLDrivers_DocumentSection.cxx
View File

@@ -16,6 +16,8 @@
#include <BinLDrivers_DocumentSection.hxx>
#include <FSD_FileHeader.hxx>
#include <Storage_IODevice.hxx>
//=======================================================================
//function : BinLDrivers_DocumentSection
//purpose : Empty constructor
@@ -108,7 +110,7 @@ void BinLDrivers_DocumentSection::SetLength (const Standard_Size theLength)
//purpose :
//=======================================================================
void BinLDrivers_DocumentSection::WriteTOC (Standard_OStream& theStream)
void BinLDrivers_DocumentSection::WriteTOC (const Handle(Storage_IODevice)& theDevice)
{
char aBuf[512];
@@ -135,10 +137,10 @@ void BinLDrivers_DocumentSection::WriteTOC (Standard_OStream& theStream)
#else
aBufSz[0] = (Standard_Integer)aBufSize;
#endif
theStream.write (&aBuf[0], aBufSize + sizeof(Standard_Integer));
theDevice->Write( (Standard_Address)&aBuf[0], aBufSize + sizeof(Standard_Integer) );
// Store the address of Offset word in the file
myValue[0] = (Standard_Size) theStream.tellp();
myValue[0] = (Standard_Size) theDevice->Tell();
myValue[1] = 0;
// Write the placeholders of Offset and Length of the section that should
@@ -146,7 +148,7 @@ void BinLDrivers_DocumentSection::WriteTOC (Standard_OStream& theStream)
aBufSz[0] = 0;
aBufSz[1] = 0;
aBufSz[2] = 0;
theStream.write (&aBuf[0], 3*sizeof(Standard_Integer));
theDevice->Write( (Standard_Address)&aBuf[0], 3*sizeof(Standard_Integer));
}
}
@@ -155,11 +157,11 @@ void BinLDrivers_DocumentSection::WriteTOC (Standard_OStream& theStream)
//purpose :
//=======================================================================
void BinLDrivers_DocumentSection::Write (Standard_OStream& theStream,
void BinLDrivers_DocumentSection::Write (const Handle(Storage_IODevice)& theDevice,
const Standard_Size theOffset)
{
const Standard_Size aSectionEnd = (Standard_Size) theStream.tellp();
theStream.seekp(myValue[0]);
const Standard_Size aSectionEnd = (Standard_Size)theDevice->Tell();
theDevice->Seek(myValue[0]);
myValue[0] = theOffset;
myValue[1] = aSectionEnd - theOffset;
Standard_Integer aVal[3] = {
@@ -173,8 +175,8 @@ void BinLDrivers_DocumentSection::Write (Standard_OStream& theStream,
aVal[2] = InverseSize(aVal[2]);
#endif
theStream.write((char *)&aVal[0], 3*sizeof(Standard_Integer));
theStream.seekp(aSectionEnd);
theDevice->Write((Standard_Address)&aVal[0], 3*sizeof(Standard_Integer));
theDevice->Seek(aSectionEnd);
}
//=======================================================================
@@ -182,21 +184,20 @@ void BinLDrivers_DocumentSection::Write (Standard_OStream& theStream,
//purpose :
//=======================================================================
void BinLDrivers_DocumentSection::ReadTOC
(BinLDrivers_DocumentSection& theSection,
Standard_IStream& theStream)
void BinLDrivers_DocumentSection::ReadTOC( BinLDrivers_DocumentSection& theSection,
const Handle(Storage_IODevice)& theDevice)
{
char aBuf[512];
Standard_Integer aNameBufferSize;
theStream.read ((char *)&aNameBufferSize, sizeof(Standard_Integer));
theDevice->Read( (Standard_Address)&aNameBufferSize, sizeof(Standard_Integer) );
#if DO_INVERSE
aNameBufferSize = InverseSize(aNameBufferSize);
#endif
if (aNameBufferSize > 0) {
theStream.read ((char *)&aBuf[0], (Standard_Size)aNameBufferSize);
theDevice->Read ((char *)&aBuf[0], (Standard_Size)aNameBufferSize);
theSection.myName = (Standard_CString)&aBuf[0];
Standard_Integer aValue[3];
theStream.read ((char *)&aValue[0], 3*sizeof(Standard_Integer));
theDevice->Read ((char *)&aValue[0], 3*sizeof(Standard_Integer));
#if DO_INVERSE
aValue[0] = InverseSize (aValue[0]);
aValue[1] = InverseSize (aValue[1]);

13
src/BinLDrivers/BinLDrivers_DocumentStorageDriver.cdl
View File

@@ -31,7 +31,8 @@ uses
MapOfTransient from TColStd,
IndexedMapOfTransient from TColStd,
DocumentSection from BinLDrivers,
VectorOfDocumentSection from BinLDrivers
VectorOfDocumentSection from BinLDrivers,
IODevice from Storage
is
-- ===== Public methods =====
@@ -43,7 +44,7 @@ is
---Purpose: pure virtual method definition
Write (me: mutable; theDocument: Document from CDM;
theFileName: ExtendedString from TCollection)
theDevice: IODevice from Storage)
is redefined virtual;
---Purpose: Write <theDocument> to the binary file <theFileName>
@@ -54,7 +55,7 @@ is
-- ===== Protected methods =====
WriteSubTree (me: mutable; theData : Label from TDF;
theOS : in out OStream from Standard)
theDevice: IODevice from Storage)
is protected;
---Purpose: Write the tree under <theLabel> to the stream <theOS>
@@ -64,12 +65,12 @@ is
WriteSection (me: mutable; theName : AsciiString from TCollection;
theDoc : Document from CDM;
theOS : in out OStream from Standard)
theDevice: IODevice from Storage)
is virtual protected;
---Purpose: define the procedure of writing a section to file.
WriteShapeSection (me: mutable; theDocSection : in out DocumentSection from BinLDrivers;
theOS : in out OStream from Standard)
theDevice: IODevice from Storage)
is virtual protected;
---Purpose: defines the procedure of writing a shape section to file
@@ -82,7 +83,7 @@ is
-- attributes to store
WriteInfoSection(me: mutable; theDocument : Document from CDM;
theFile : AsciiString from TCollection)
theDevice: IODevice from Storage)
is private;
---Purpose: Write info secton using FSD_BinaryFile driver

102
src/BinLDrivers/BinLDrivers_DocumentStorageDriver.cxx
View File

@@ -62,8 +62,8 @@ TCollection_ExtendedString BinLDrivers_DocumentStorageDriver::SchemaName() const
//=======================================================================
void BinLDrivers_DocumentStorageDriver::Write
(const Handle(CDM_Document)& theDocument,
const TCollection_ExtendedString& theFileName)
(const Handle(CDM_Document)& theDocument,
const Handle(Storage_IODevice)& theDevice)
{
SetIsError(Standard_False);
SetStoreStatus(PCDM_SS_OK);
@@ -78,9 +78,6 @@ void BinLDrivers_DocumentStorageDriver::Write
SetStoreStatus(PCDM_SS_Doc_IsNull);
}
else {
// Open the file
TCollection_AsciiString aFileName (theFileName);
// First pass: collect empty labels, assign IDs to the types
if (myDrivers.IsNull())
myDrivers = AttributeDrivers (myMsgDriver);
@@ -88,7 +85,7 @@ void BinLDrivers_DocumentStorageDriver::Write
FirstPass (aData->Root());
// 1. Write info section (including types table)
WriteInfoSection(theDocument, aFileName);
WriteInfoSection(theDocument, theDevice);
myTypesMap.Clear();
if (IsError())
{
@@ -96,31 +93,20 @@ void BinLDrivers_DocumentStorageDriver::Write
return;
}
#if defined(_WIN32)
ofstream anOS ((const wchar_t*) theFileName.ToExtString(), ios::in | ios::binary | ios::ate);
#elif !defined(IRIX) // 10.10.2005
ofstream anOS (aFileName.ToCString(), ios::in | ios::binary | ios::ate);
#else
ofstream anOS (aFileName.ToCString(), ios::ate);
//ofstream anOS (aFileName.ToCString(), ios::out| ios::binary | ios::ate);
#endif
#ifdef OCCT_DEBUG
const Standard_Integer aP = (Standard_Integer) anOS.tellp();
cout << "POS = " << aP <<endl;
#endif
//#endif
theDevice->Open( Storage_VSAppend );
Standard_Size aP = theDevice->Tell();
if (anOS) {
if (theDevice->CanWrite()) {
// 2. Write the Table of Contents of Sections
BinLDrivers_VectorOfDocumentSection::Iterator anIterS (mySections);
for (; anIterS.More(); anIterS.Next())
anIterS.ChangeValue().WriteTOC (anOS);
anIterS.ChangeValue().WriteTOC (theDevice);
// Shapes Section is the last one, it indicates the end of the table.
BinLDrivers_DocumentSection aShapesSection (SHAPESECTION_POS,
Standard_False);
aShapesSection.WriteTOC (anOS);
aShapesSection.WriteTOC (theDevice);
// 3. Write document contents
// (Storage data to the stream)
@@ -128,17 +114,17 @@ void BinLDrivers_DocumentStorageDriver::Write
myPAtt.Init();
// Write Doc structure
WriteSubTree (aData->Root(), anOS); // Doc is written
WriteSubTree (aData->Root(), theDevice); // Doc is written
// 4. Write Shapes section
WriteShapeSection(aShapesSection, anOS);
WriteShapeSection(aShapesSection, theDevice);
// Write application-defined sections
for (anIterS.Init (mySections); anIterS.More(); anIterS.Next()) {
BinLDrivers_DocumentSection& aSection = anIterS.ChangeValue();
const Standard_Size aSectionOffset = (Standard_Size) anOS.tellp();
WriteSection (aSection.Name(), theDocument, anOS);
aSection.Write (anOS, aSectionOffset);
const Standard_Size aSectionOffset = (Standard_Size)theDevice->Tell();
WriteSection (aSection.Name(), theDocument, theDevice);
aSection.Write (theDevice, aSectionOffset);
}
// End of processing: close structures and check the status
@@ -157,17 +143,13 @@ void BinLDrivers_DocumentStorageDriver::Write
myRelocTable.Clear();
}
if (!anOS) {
// A problem with the stream
#ifdef OCCT_DEBUG
TCollection_ExtendedString anErrorStr ("Error: ");
WriteMessage (anErrorStr + "BinLDrivers_DocumentStorageDriver, Problem with the file stream, rdstate="
+ (Standard_Integer )anOS.rdstate());
#endif
if (!theDevice->CanWrite()) {
WriteMessage ("Error: BinLDrivers_DocumentStorageDriver, Problem with the file stream.") ;
SetIsError(Standard_True);
SetStoreStatus(PCDM_SS_WriteFailure);
}
theDevice->Close();
}
}
@@ -196,9 +178,8 @@ void BinLDrivers_DocumentStorageDriver::UnsupportedAttrMsg
//purpose :
//=======================================================================
void BinLDrivers_DocumentStorageDriver::WriteSubTree
(const TDF_Label& theLabel,
Standard_OStream& theOS)
void BinLDrivers_DocumentStorageDriver::WriteSubTree(const TDF_Label& theLabel,
const Handle(Storage_IODevice)& theDevice)
{
// Skip empty labels
if (!myEmptyLabels.IsEmpty() && myEmptyLabels.First() == theLabel) {
@@ -211,11 +192,11 @@ void BinLDrivers_DocumentStorageDriver::WriteSubTree
#if DO_INVERSE
aTag = InverseInt (aTag);
#endif
theOS.write ((char*)&aTag, sizeof(Standard_Integer));
theDevice->Write ((char*)&aTag, sizeof(Standard_Integer));
// Write attributes
TDF_AttributeIterator itAtt (theLabel);
for ( ; itAtt.More() && theOS; itAtt.Next()) {
for ( ; itAtt.More() && theDevice->CanWrite(); itAtt.Next()) {
const Handle(TDF_Attribute)& tAtt = itAtt.Value();
const Handle(Standard_Type)& aType = tAtt->DynamicType();
// Get type ID and driver
@@ -231,14 +212,15 @@ void BinLDrivers_DocumentStorageDriver::WriteSubTree
aDriver->Paste (tAtt, myPAtt, myRelocTable);
// Write data to the stream -->!!!
theOS << myPAtt;
//theOS << myPAtt;
myPAtt.Write( theDevice );
}
#ifdef OCCT_DEBUG
else
UnsupportedAttrMsg (aType);
#endif
}
if (!theOS) {
if (!theDevice->CanWrite()) {
// Problem with the stream
return;
}
@@ -248,14 +230,14 @@ void BinLDrivers_DocumentStorageDriver::WriteSubTree
#if DO_INVERSE
anEndAttr = (BinLDrivers_Marker) InverseInt (anEndAttr);
#endif
theOS.write ((char*)&anEndAttr, sizeof(anEndAttr));
theDevice->Write ((char*)&anEndAttr, sizeof(anEndAttr));
// Process sub-labels
TDF_ChildIterator itChld (theLabel);
for ( ; itChld.More(); itChld.Next())
{
const TDF_Label& aChildLab = itChld.Value();
WriteSubTree (aChildLab, theOS);
WriteSubTree (aChildLab, theDevice);
}
// Write the end label marker
@@ -263,8 +245,7 @@ void BinLDrivers_DocumentStorageDriver::WriteSubTree
#if DO_INVERSE
anEndLabel = (BinLDrivers_Marker) InverseInt (anEndLabel);
#endif
theOS.write ((char*)&anEndLabel, sizeof(anEndLabel));
theDevice->Write( (Standard_Address)&anEndLabel, sizeof(anEndLabel));
}
//=======================================================================
@@ -352,13 +333,13 @@ void BinLDrivers_DocumentStorageDriver::FirstPass
#define END_TYPES "END_TYPES"
void BinLDrivers_DocumentStorageDriver::WriteInfoSection
(const Handle(CDM_Document)& theDocument,
const TCollection_AsciiString& theFileName)
(const Handle(CDM_Document)& theDocument,
const Handle(Storage_IODevice)& theDevice)
{
FSD_BinaryFile aFileDriver;
if (aFileDriver.Open( theFileName, Storage_VSWrite ) != Storage_VSOk) {
WriteMessage (TCollection_ExtendedString("Error: Cannot open file ") +
theFileName);
if (aFileDriver.Open( theDevice, Storage_VSWrite ) != Storage_VSOk) {
WriteMessage (TCollection_ExtendedString("Error: Cannot open the device ") +
theDevice->Name());
SetIsError(Standard_True);
return;
}
@@ -369,7 +350,7 @@ void BinLDrivers_DocumentStorageDriver::WriteInfoSection
Handle(Storage_Data) theData = new Storage_Data;
PCDM_ReadWriter::WriteFileFormat( theData, theDocument );
PCDM_ReadWriter::Writer()->WriteReferenceCounter(theData,theDocument);
PCDM_ReadWriter::Writer()->WriteReferences(theData,theDocument,theFileName);
PCDM_ReadWriter::Writer()->WriteReferences(theData,theDocument,theDevice);
PCDM_ReadWriter::Writer()->WriteExtensions(theData,theDocument);
PCDM_ReadWriter::Writer()->WriteVersion(theData,theDocument);
@@ -414,7 +395,7 @@ void BinLDrivers_DocumentStorageDriver::WriteInfoSection
}
else {
WriteMessage(TCollection_ExtendedString("Error: Problem writing header "
"into file ") + theFileName);
"into file ") + theDevice->Name());
SetIsError(Standard_True);
}
#ifdef OCCT_DEBUG
@@ -455,9 +436,9 @@ void BinLDrivers_DocumentStorageDriver::AddSection
//=======================================================================
void BinLDrivers_DocumentStorageDriver::WriteSection
(const TCollection_AsciiString& /*theName*/,
const Handle(CDM_Document)& /*theDocument*/,
Standard_OStream& /*theOS*/)
(const TCollection_AsciiString& /*theName*/,
const Handle(CDM_Document)& /*theDoc*/,
const Handle(Storage_IODevice)& /*theDevice*/)
{
// empty; should be redefined in subclasses
}
@@ -467,9 +448,12 @@ void BinLDrivers_DocumentStorageDriver::WriteSection
//purpose : defines WriteShapeSection
//=======================================================================
void BinLDrivers_DocumentStorageDriver::WriteShapeSection
(BinLDrivers_DocumentSection& theSection,
Standard_OStream& theOS)
(BinLDrivers_DocumentSection& theDocSection,
const Handle(Storage_IODevice)& theDevice)
{
const Standard_Size aShapesSectionOffset = (Standard_Size) theOS.tellp();
theSection.Write (theOS, aShapesSectionOffset);
if (theDevice->CanWrite())
{
const Standard_Size aShapesSectionOffset = theDevice->Tell();
theDocSection.Write (theDevice, aShapesSectionOffset);
}
}

4
src/BinMDataXtd/BinMDataXtd.cdl
View File

@@ -43,6 +43,10 @@ is
class PatternStdDriver;
class ShapeDriver;
class PresentationDriver;
class PositionDriver;
AddDrivers (theDriverTable : ADriverTable from BinMDF;

4
src/BinMDataXtd/BinMDataXtd.cxx
View File

@@ -24,6 +24,8 @@
#include <BinMDataXtd_AxisDriver.hxx>
#include <BinMDataXtd_PlaneDriver.hxx>
#include <BinMDataXtd_PlacementDriver.hxx>
#include <BinMDataXtd_PresentationDriver.hxx>
#include <BinMDataXtd_PositionDriver.hxx>
static Standard_Integer myDocumentVersion = -1;
//=======================================================================
@@ -42,6 +44,8 @@ void BinMDataXtd::AddDrivers (const Handle(BinMDF_ADriverTable)& theDriverTable,
theDriverTable->AddDriver (new BinMDataXtd_AxisDriver (theMsgDriver) );
theDriverTable->AddDriver (new BinMDataXtd_PlaneDriver (theMsgDriver) );
theDriverTable->AddDriver (new BinMDataXtd_PlacementDriver (theMsgDriver) );
theDriverTable->AddDriver (new BinMDataXtd_PresentationDriver(theMsgDriver) );
theDriverTable->AddDriver (new BinMDataXtd_PositionDriver (theMsgDriver) );
}

6
src/BinMPrsStd/BinMPrsStd_PositionDriver.cdl → src/BinMDataXtd/BinMDataXtd_PositionDriver.cdl
View File

@@ -13,7 +13,7 @@
-- Alternatively, this file may be used under the terms of Open CASCADE
-- commercial license or contractual agreement.
class PositionDriver from BinMPrsStd inherits ADriver from BinMDF
class PositionDriver from BinMDataXtd inherits ADriver from BinMDF
---Purpose: Position Attribute Driver.
@@ -26,8 +26,8 @@ uses
is
Create (theMessageDriver:MessageDriver from CDM)
returns PositionDriver from BinMPrsStd;
Create (theMessageDriver:MessageDriver from CDM)
returns PositionDriver from BinMDataXtd;
NewEmpty (me) returns Attribute from TDF;

12
src/BinMPrsStd/BinMPrsStd_PositionDriver.cxx → src/BinMDataXtd/BinMDataXtd_PositionDriver.cxx
View File

@@ -15,7 +15,7 @@
// modified 13.04.2009 Sergey ZARITCHNY
#include <BinMPrsStd_PositionDriver.ixx>
#include <BinMDataXtd_PositionDriver.ixx>
#include <gp_Pnt.hxx>
#include <TDataXtd_Position.hxx>
#include <CDM_MessageDriver.hxx>
@@ -25,9 +25,9 @@
//purpose : Constructor
//=======================================================================
BinMPrsStd_PositionDriver::BinMPrsStd_PositionDriver
BinMDataXtd_PositionDriver::BinMDataXtd_PositionDriver
(const Handle(CDM_MessageDriver)& theMsgDriver)
: BinMDF_ADriver (theMsgDriver, STANDARD_TYPE(TDataXtd_Position)->Name())
: BinMDF_ADriver (theMsgDriver, STANDARD_TYPE(TDataXtd_Position)->Name())
{
}
@@ -36,7 +36,7 @@ BinMPrsStd_PositionDriver::BinMPrsStd_PositionDriver
//purpose :
//=======================================================================
Handle(TDF_Attribute) BinMPrsStd_PositionDriver::NewEmpty() const
Handle(TDF_Attribute) BinMDataXtd_PositionDriver::NewEmpty() const
{
return new TDataXtd_Position();
}
@@ -46,7 +46,7 @@ Handle(TDF_Attribute) BinMPrsStd_PositionDriver::NewEmpty() const
//purpose : persistent -> transient (retrieve)
//=======================================================================
Standard_Boolean BinMPrsStd_PositionDriver::Paste
Standard_Boolean BinMDataXtd_PositionDriver::Paste
(const BinObjMgt_Persistent& theSource,
const Handle(TDF_Attribute)& theTarget,
BinObjMgt_RRelocationTable& ) const
@@ -76,7 +76,7 @@ Standard_Boolean BinMPrsStd_PositionDriver::Paste
//purpose : transient -> persistent (store)
//=======================================================================
void BinMPrsStd_PositionDriver::Paste (const Handle(TDF_Attribute)& theSource,
void BinMDataXtd_PositionDriver::Paste (const Handle(TDF_Attribute)& theSource,
BinObjMgt_Persistent& theTarget,
BinObjMgt_SRelocationTable& ) const
{

12
src/BinMPrsStd/BinMPrsStd_AISPresentationDriver.cdl → src/BinMDataXtd/BinMDataXtd_PresentationDriver.cdl
View File

@@ -13,9 +13,9 @@
-- Alternatively, this file may be used under the terms of Open CASCADE
-- commercial license or contractual agreement.
class AISPresentationDriver from BinMPrsStd inherits ADriver from BinMDF
class PresentationDriver from BinMDataXtd inherits ADriver from BinMDF
---Purpose: AISPresentation Attribute Driver.
---Purpose: Presentation Attribute Driver.
uses
SRelocationTable from BinObjMgt,
@@ -27,18 +27,18 @@ uses
is
Create (theMessageDriver:MessageDriver from CDM)
returns AISPresentationDriver from BinMPrsStd;
returns PresentationDriver from BinMDataXtd;
NewEmpty (me) returns Attribute from TDF;
Paste(me; Source : Persistent from BinObjMgt;
Target : Attribute from TDF;
RelocTable : out RRelocationTable from BinObjMgt)
returns Boolean from Standard;
returns Boolean from Standard;
Paste(me; Source : Attribute from TDF;
Target : in out Persistent from BinObjMgt;
RelocTable : out SRelocationTable from BinObjMgt);
end AISPresentationDriver;
end PresentationDriver;

155
src/BinMDataXtd/BinMDataXtd_PresentationDriver.cxx Normal file
View File

@@ -0,0 +1,155 @@
// Created on: 2004-05-17
// Created by: Sergey ZARITCHNY
// Copyright (c) 2004-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.
#include <BinMDataXtd_PresentationDriver.ixx>
#include <TDataXtd_Presentation.hxx>
#include <CDM_MessageDriver.hxx>
//=======================================================================
//function : BinMDataStd_AISPresentationDriver
//purpose : Constructor
//=======================================================================
BinMDataXtd_PresentationDriver::BinMDataXtd_PresentationDriver
(const Handle(CDM_MessageDriver)& theMsgDriver)
: BinMDF_ADriver(theMsgDriver, STANDARD_TYPE(TDataXtd_Presentation)->Name())
{
}
//=======================================================================
//function : NewEmpty
//purpose :
//=======================================================================
Handle(TDF_Attribute) BinMDataXtd_PresentationDriver::NewEmpty() const
{
return new TDataXtd_Presentation();
}
//=======================================================================
//function : Paste
//purpose : persistent -> transient (retrieve)
//=======================================================================
Standard_Boolean BinMDataXtd_PresentationDriver::Paste
(const BinObjMgt_Persistent& theSource,
const Handle(TDF_Attribute)& theTarget,
BinObjMgt_RRelocationTable& /*theRT*/) const
{
Standard_Boolean ok = Standard_False;
Handle(TDataXtd_Presentation) anAttribute = Handle(TDataXtd_Presentation)::DownCast(theTarget);
// Display status
Standard_Integer aValue;
ok = theSource >> aValue;
if (!ok) return ok;
anAttribute->SetDisplayed(static_cast<Standard_Boolean>(aValue));
// GUID
Standard_GUID aGUID;
ok = theSource >> aGUID;
if (!ok) return ok;
anAttribute->SetDriverGUID(aGUID);
// Color
ok = theSource >> aValue;
if (!ok) return ok;
if ( aValue != -1 )
anAttribute->SetColor(aValue);
else
anAttribute->UnsetColor();
// Material
ok = theSource >> aValue;
if ( !ok ) return ok;
if (aValue != -1)
anAttribute->SetMaterial(aValue);
else
anAttribute->UnsetMaterial();
// Transparency
Standard_Real aRValue;
ok = theSource >> aRValue;
if ( !ok ) return ok;
if ( aRValue != -1. )
anAttribute->SetTransparency(aRValue);
else
anAttribute->UnsetTransparency();
// Width
ok = theSource >> aRValue;
if ( !ok ) return ok;
if ( aRValue != -1. )
anAttribute->SetWidth(aRValue);
else
anAttribute->UnsetWidth();
// Mode
ok = theSource >> aValue;
if ( !ok ) return ok;
if ( aValue != -1 )
anAttribute->SetMode(aValue);
else
anAttribute->UnsetMode();
return ok;
}
//=======================================================================
//function : Paste
//purpose : transient -> persistent (store)
//=======================================================================
void BinMDataXtd_PresentationDriver::Paste(const Handle(TDF_Attribute)& theSource,
BinObjMgt_Persistent& theTarget,
BinObjMgt_SRelocationTable& /*theSRT*/) const
{
Handle(TDataXtd_Presentation) anAttribute = Handle(TDataXtd_Presentation)::DownCast(theSource);
// Display status
theTarget.PutBoolean(anAttribute->IsDisplayed());
// GUID
theTarget.PutGUID(anAttribute->GetDriverGUID());
// Color
if (anAttribute->IsHasOwnColor())
theTarget.PutInteger(anAttribute->Color());
else
theTarget.PutInteger(-1);
// Material
if (anAttribute->IsHasOwnMaterial())
theTarget.PutInteger(anAttribute->Material());
else
theTarget.PutInteger(-1);
// Transparency
if (anAttribute->IsHasOwnTransparency())
theTarget.PutReal(anAttribute->Transparency());
else
theTarget.PutReal(-1.);
// Width
if (anAttribute->IsHasOwnWidth())
theTarget.PutReal(anAttribute->Width());
else
theTarget.PutReal(-1.);
// Mode
if (anAttribute->IsHasOwnMode())
theTarget.PutInteger(anAttribute->Mode());
else
theTarget.PutInteger(-1);
}

3
src/BinMNaming/BinMNaming.cdl
View File

@@ -22,7 +22,8 @@ uses BinMDF,
BRepTools,
BinTools,
TDF,
CDM
CDM,
Storage
is

7
src/BinMNaming/BinMNaming_NamedShapeDriver.cdl
View File

@@ -24,7 +24,8 @@ uses
MessageDriver from CDM,
Attribute from TDF,
ShapeSet from BinTools,
LocationSet from BinTools
LocationSet from BinTools,
IODevice from Storage
is
Create (theMessageDriver:MessageDriver from CDM)
@@ -43,10 +44,10 @@ is
ReadShapeSection (me: mutable; theIS: in out IStream from Standard);
---Purpose: Input the shapes from Bin Document file
WriteShapeSection (me: mutable; theOS: in out OStream from Standard);
---Purpose: Output the shapes into Bin Document file
Clear (me:mutable);
---Purpose: Clear myShapeSet

3
src/BinMNaming/BinMNaming_NamedShapeDriver.cxx
View File

@@ -25,6 +25,8 @@
#include <TCollection_AsciiString.hxx>
#include <BinTools_ShapeSet.hxx>
#include <TopAbs_Orientation.hxx>
#include <Storage_IStream.hxx>
#include <Storage_OStream.hxx>
#define SHAPESET "SHAPE_SECTION"
#define FORMAT_NUMBER 3
@@ -304,4 +306,3 @@ void BinMNaming_NamedShapeDriver::ReadShapeSection (Standard_IStream& theIS)
else
theIS.seekg(aPos); // no shape section is present, try to return to initial point
}

37
src/BinMPrsStd/BinMPrsStd.cdl
View File

@@ -1,37 +0,0 @@
-- Created on: 2004-05-17
-- Created by: Sergey ZARITCHNY <szy@opencascade.com>
-- Copyright (c) 2004-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.
package BinMPrsStd
---Purpose:
uses
BinObjMgt,
TDF,
BinMDF,
CDM
is
---Category: Storage-Retrieval drivers for graphic attributes from
-- TPrsStd
class AISPresentationDriver;
class PositionDriver;
AddDrivers(theDriverTable : ADriverTable from BinMDF;
theMessageDriver : MessageDriver from CDM);
---Purpose: Adds the attribute storage-retrieval driver to <theDriverTable>.
end BinMPrsStd;

32
src/BinMPrsStd/BinMPrsStd.cxx
View File

@@ -1,32 +0,0 @@
// Created on: 2004-05-17
// Created by: Sergey ZARITCHNY
// Copyright (c) 2004-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.
#include <BinMPrsStd.ixx>
#include <CDM_MessageDriver.hxx>
#include <BinMDF_ADriverTable.hxx>
#include <BinMPrsStd_AISPresentationDriver.hxx>
#include <BinMPrsStd_PositionDriver.hxx>
//=======================================================================
//function : AddDrivers
//purpose :
//=======================================================================
void BinMPrsStd::AddDrivers (const Handle(BinMDF_ADriverTable)& aDriverTable,
const Handle(CDM_MessageDriver)& aMessageDriver)
{
aDriverTable->AddDriver (new BinMPrsStd_AISPresentationDriver(aMessageDriver));
aDriverTable->AddDriver (new BinMPrsStd_PositionDriver(aMessageDriver));
}

133
src/BinMPrsStd/BinMPrsStd_AISPresentationDriver.cxx
View File

@@ -1,133 +0,0 @@
// Created on: 2004-05-17
// Created by: Sergey ZARITCHNY
// Copyright (c) 2004-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.
#include <BinMPrsStd_AISPresentationDriver.ixx>
#include <TPrsStd_AISPresentation.hxx>
#include <Graphic3d_NameOfMaterial.hxx>
#include <Quantity_NameOfColor.hxx>
#include <CDM_MessageDriver.hxx>
//=======================================================================
//function : BinMDataStd_AISPresentationDriver
//purpose : Constructor
//=======================================================================
BinMPrsStd_AISPresentationDriver::BinMPrsStd_AISPresentationDriver
(const Handle(CDM_MessageDriver)& theMsgDriver)
: BinMDF_ADriver (theMsgDriver, STANDARD_TYPE(TPrsStd_AISPresentation)->Name())
{
}
//=======================================================================
//function : NewEmpty
//purpose :
//=======================================================================
Handle(TDF_Attribute) BinMPrsStd_AISPresentationDriver::NewEmpty() const
{
return new TPrsStd_AISPresentation();
}
//=======================================================================
//function : Paste
//purpose : persistent -> transient (retrieve)
//=======================================================================
Standard_Boolean BinMPrsStd_AISPresentationDriver::Paste
(const BinObjMgt_Persistent& theSource,
const Handle(TDF_Attribute)& theTarget,
BinObjMgt_RRelocationTable& ) const
{
Handle(TPrsStd_AISPresentation) anAtt = Handle(TPrsStd_AISPresentation)::DownCast(theTarget);
Standard_Integer aValue;
//Display status
Standard_Boolean ok = theSource >> aValue;
if (!ok) return ok;
anAtt->SetDisplayed((Standard_Boolean)aValue);
//GUID
Standard_GUID aGUID;
ok = theSource >> aGUID;
if (!ok) return ok;
anAtt->SetDriverGUID(aGUID);
//Color
ok = theSource >> aValue;
if (!ok) return ok;
if(aValue != -1) anAtt->SetColor( (Quantity_NameOfColor)(aValue) );
else anAtt->UnsetColor();
//Material
ok = theSource >> aValue;
if (!ok) return ok;
if(aValue != -1) anAtt->SetMaterial( (Graphic3d_NameOfMaterial)(aValue) );
else anAtt->UnsetMaterial();
//Transparency
Standard_Real aRValue;
ok = theSource >> aRValue;
if (!ok) return ok;
if(aRValue != -1.) anAtt->SetTransparency(aRValue);
else anAtt->UnsetTransparency();
//Width
ok = theSource >> aRValue;
if (!ok) return ok;
if(aRValue != -1.) anAtt->SetWidth( aRValue );
else anAtt->UnsetWidth();
//Mode
ok = theSource >> aValue;
if (!ok) return ok;
if(aValue != -1) anAtt->SetMode(aValue);
else anAtt->UnsetMode();
return ok;
}
//=======================================================================
//function : Paste
//purpose : transient -> persistent (store)
//=======================================================================
void BinMPrsStd_AISPresentationDriver::Paste (const Handle(TDF_Attribute)& theSource,
BinObjMgt_Persistent& theTarget,
BinObjMgt_SRelocationTable& ) const
{
Handle(TPrsStd_AISPresentation) anAtt = Handle(TPrsStd_AISPresentation)::DownCast(theSource);
//1
theTarget.PutBoolean(anAtt->IsDisplayed());//Bool
//2
theTarget.PutGUID(anAtt->GetDriverGUID());//GUID
//3
if(anAtt->HasOwnColor())
theTarget.PutInteger((Standard_Integer)anAtt->Color());//Color
else theTarget.PutInteger(-1);
//4
if(anAtt->HasOwnMaterial())
theTarget.PutInteger((Standard_Integer)anAtt->Material());
else theTarget.PutInteger(-1);
//5
if(anAtt->HasOwnTransparency())
theTarget.PutReal(anAtt->Transparency()); //Real
else theTarget.PutReal(-1.);
//6
if(anAtt->HasOwnWidth())
theTarget.PutReal(anAtt->Width());// Real
else theTarget.PutReal(-1.);
//7
if(anAtt->HasOwnMode())
theTarget.PutInteger(anAtt->Mode()); //Int
else theTarget.PutInteger(-1);
}

1
src/BinObjMgt/BinObjMgt.cdl
View File

@@ -21,6 +21,7 @@ package BinObjMgt
uses
TDF,
Standard,
Storage,
TCollection,
TColStd

6
src/BinObjMgt/BinObjMgt_Persistent.cdl
View File

@@ -26,6 +26,7 @@ uses
Address from Standard,
OStream from Standard,
IStream from Standard,
IODevice from Storage,
SequenceOfAddress from TColStd,
AsciiString from TCollection,
ExtendedString from TCollection,
@@ -317,12 +318,17 @@ is
-- inline Standard_OStream& operator<< (Standard_OStream&,
-- BinObjMgt_Persistent&) is also available
Write (me: in out; theDevice: IODevice from Storage) is static;
Read (me: in out; theIS: in out IStream from Standard)
returns IStream from Standard is static;
---C++: return &
---Purpose: Retrieves <me> from the stream.
-- inline Standard_IStream& operator>> (Standard_IStream&,
-- BinObjMgt_Persistent&) is also available
Read (me: in out; theDevice:IODevice from Storage) is static;
---Purpose: Retrieves <me> from the Storage_IODevice.
Destroy (me: in out);
---C++: alias ~

85
src/BinObjMgt/BinObjMgt_Persistent.cxx
View File

@@ -18,6 +18,7 @@
#include <TDF_Tool.hxx>
#include <TColStd_ListIteratorOfListOfInteger.hxx>
#include <FSD_FileHeader.hxx>
#include <Storage_OStream.hxx>
#define BP_INTSIZE ((Standard_Integer)sizeof(Standard_Integer))
#define BP_EXTCHARSIZE ((Standard_Integer)sizeof(Standard_ExtCharacter))
@@ -103,6 +104,34 @@ Standard_OStream& BinObjMgt_Persistent::Write (Standard_OStream& theOS)
return theOS;
}
//=======================================================================
//function : Write
//purpose : Stores <me> to the device.
//=======================================================================
void BinObjMgt_Persistent::Write (const Handle(Storage_IODevice)& theDevice)
{
Standard_Integer nbWritten = 0;
Standard_Integer *aData = (Standard_Integer*) myData(1);
// update data length
aData[2] = mySize - BP_HEADSIZE;
#if DO_INVERSE
aData[0] = InverseInt (aData[0]);
aData[1] = InverseInt (aData[1]);
aData[2] = InverseInt (aData[2]);
#endif
for (Standard_Integer i=1; theDevice->CanWrite() && nbWritten < mySize && i <= myData.Length(); i++)
{
Standard_Integer nbToWrite = Min(mySize - nbWritten, BP_PIECESIZE);
theDevice->Write( (Standard_Address)myData(i), nbToWrite );
nbWritten += nbToWrite;
}
myIndex = 1;
myOffset = BP_HEADSIZE;
mySize = BP_HEADSIZE;
myIsError = Standard_False;
}
//=======================================================================
//function : Read
//purpose : Retrieves <me> from the stream.
@@ -163,6 +192,62 @@ Standard_IStream& BinObjMgt_Persistent::Read (Standard_IStream& theIS)
return theIS;
}
//=======================================================================
//function : Read
//purpose :
//=======================================================================
void BinObjMgt_Persistent::Read (const Handle(Storage_IODevice)& aDevice)
{
myIndex = 1;
myOffset = BP_HEADSIZE;
mySize = BP_HEADSIZE;
myIsError = Standard_False;
Standard_Integer *aData = (Standard_Integer*) myData(1);
aData[0] = 0; // Type Id
aData[1] = 0; // Object Id
aData[2] = 0; // Data length
// read TypeId
aDevice->Read ((char*) &aData[0], BP_INTSIZE);
#if DO_INVERSE
aData[0] = InverseInt (aData[0]);
#endif
if (aDevice->CanRead() && aData[0] > 0) {
// read Id and Length
aDevice->Read ((char*)&aData[1], 2 * BP_INTSIZE);
#if DO_INVERSE
aData[1] = InverseInt (aData[1]);
aData[2] = InverseInt (aData[2]);
#endif
if (aDevice->CanRead() && aData[1] > 0 && aData[2] > 0) {
mySize += aData[2];
// read remaining data
Standard_Integer nbRead = BP_HEADSIZE;
for (Standard_Integer i=1; aDevice->CanRead() && nbRead < mySize; i++)
{
if (i > myData.Length()) {
// grow myData dynamically
Standard_Address aPiece = Standard::Allocate (BP_PIECESIZE);
myData.Append (aPiece);
}
Standard_Integer nbToRead = Min (mySize - nbRead, BP_PIECESIZE);
char *ptr = (char*)myData(i);
if (i == 1) {
// 1st piece: reduce the number of bytes by header size
ptr += BP_HEADSIZE;
if (nbToRead == BP_PIECESIZE) nbToRead -= BP_HEADSIZE;
}
aDevice->Read (ptr, nbToRead);
nbRead += nbToRead;
}
}
else
aData[2] = 0;
}
}
//=======================================================================
//function : Destroy
//purpose : Frees the allocated memory

2
src/CDF/CDF.cdl
View File

@@ -17,7 +17,7 @@
package CDF
uses CDM, PCDM, TCollection, TColStd, Storage, Resource, Quantity, OSD
uses CDM, PCDM, TCollection, TColStd, Storage, Resource, Quantity, OSD, Storage
is
class Directory;

27
src/CDF/CDF_Application.cdl
View File

@@ -29,7 +29,8 @@ uses
TypeOfActivation from CDF,
SequenceOfExtendedString from TColStd,
CanCloseStatus from CDM,
AsciiString from TCollection
AsciiString from TCollection,
IODevice from Storage
raises NoSuchObject from Standard
is
@@ -69,7 +70,7 @@ is
---Purpose: removes the document of the current session directory
-- and closes the document;
Retrieve (me: mutable; aFolder, aName: ExtendedString from TCollection; UseStorageConfiguration: Boolean from Standard = Standard_True)
Retrieve (me: mutable; aDevice: in out IODevice from Storage; UseStorageConfiguration: Boolean from Standard = Standard_True)
returns Document from CDM;
---Purpose: This method retrieves a document from the database.
-- If the Document references other documents which have
@@ -91,7 +92,7 @@ is
-- A link is kept with the database through an instance of CDM_MetaData
Retrieve (me: mutable; aFolder, aName, aVersion: ExtendedString from TCollection; UseStorageConfiguration: Boolean from Standard = Standard_True)
Retrieve (me: mutable; aDevice: in out IODevice from Storage; aVersion: ExtendedString from TCollection; UseStorageConfiguration: Boolean from Standard = Standard_True)
returns Document from CDM;
---Purpose: This method retrieves a document from the database.
-- If the Document references other documents which have
@@ -108,17 +109,17 @@ is
-- A link is kept with the database through an instance
-- of CDM_MetaData
CanRetrieve(me: mutable; aFolder, aName: ExtendedString from TCollection)
CanRetrieve(me: mutable; aDevice: in out IODevice from Storage)
---Purpose:
returns ReaderStatus from PCDM;
CanRetrieve(me: mutable; aFolder, aName, aVersion: ExtendedString from TCollection)
CanRetrieve(me: mutable; aDevice: in out IODevice from Storage; aVersion: ExtendedString from TCollection)
---Purpose:
returns ReaderStatus from PCDM;
Formats(me: mutable; Formats: out SequenceOfExtendedString from TColStd)
is deferred;
---Category: CurrentDocument methods.
--
@@ -148,11 +149,10 @@ is
---Category: methods to get storage/retrieval driver.
--
--
FindReader(me: mutable; aFileName: ExtendedString from TCollection)
FindReader(me: mutable; aDevice: IODevice from Storage)
returns Boolean from Standard;
Reader(me: mutable; aFileName: ExtendedString from TCollection)
Reader(me: mutable; aDevice: IODevice from Storage)
returns Reader from PCDM
raises NoSuchObject from Standard;
@@ -165,15 +165,13 @@ is
---Purpose:
Format (me : mutable; aFileName : ExtendedString from TCollection;
Format (me : mutable; aDevice : IODevice from Storage;
theFormat : out ExtendedString from TCollection)
---Purpose: try to retrieve a Format directly in the file or in
-- application resource by using extension. returns
-- True if found;
returns Boolean from Standard;
---Category: Default Storage folder
--
DefaultFolder(me: mutable) returns ExtString from Standard;
@@ -196,7 +194,7 @@ is
returns Integer from Standard
is private;
FindReader(me: mutable; aFileName: ExtendedString from TCollection; PluginIn: out GUID from Standard; ResourceName: out ExtendedString from TCollection)
FindReader(me: mutable; aDevice: IODevice from Storage; PluginIn: out GUID from Standard; ResourceName: out ExtendedString from TCollection)
returns Boolean from Standard
is private;
@@ -212,6 +210,7 @@ is
CanRetrieve(me: mutable; aMetaData: MetaData from CDM)
returns ReaderStatus from PCDM
is private;
fields
myDefaultFolder: ExtendedString from TCollection;

93
src/CDF/CDF_Application.cxx
View File

@@ -86,31 +86,31 @@ void CDF_Application::Close(const Handle(CDM_Document)& aDocument) {
//function : Retrieve
//purpose :
//=======================================================================
Handle(CDM_Document) CDF_Application::Retrieve(const TCollection_ExtendedString& aFolder,
const TCollection_ExtendedString& aName,
const Standard_Boolean UseStorageConfiguration) {
Handle(CDM_Document) CDF_Application::Retrieve(Handle(Storage_IODevice)& aDevice,
const Standard_Boolean UseStorageConfiguration)
{
TCollection_ExtendedString nullVersion;
return Retrieve(aFolder,aName,nullVersion,UseStorageConfiguration);
return Retrieve(aDevice, nullVersion, UseStorageConfiguration);
}
//=======================================================================
//function : Retrieve
//purpose :
//=======================================================================
Handle(CDM_Document) CDF_Application::Retrieve(const TCollection_ExtendedString& aFolder,
const TCollection_ExtendedString& aName,
const TCollection_ExtendedString& aVersion,
const Standard_Boolean UseStorageConfiguration) {
Handle(CDM_Document) CDF_Application::Retrieve(Handle(Storage_IODevice)& aDevice,
const TCollection_ExtendedString& aVersion,
const Standard_Boolean UseStorageConfiguration)
{
#ifdef OCCT_DEBUG
CDF_Timer theTimer;
#endif
Handle(CDM_MetaData) theMetaData;
if(aVersion.Length() == 0)
theMetaData=theMetaDataDriver->MetaData(aFolder,aName);
else
theMetaData=theMetaDataDriver->MetaData(aFolder,aName,aVersion);
if(aVersion.Length() == 0)
theMetaData = theMetaDataDriver->MetaData(aDevice);
else
theMetaData = theMetaDataDriver->MetaData(aDevice, aVersion);
#ifdef OCCT_DEBUG
theTimer.ShowAndRestart("Getting MetaData: ");
@@ -140,31 +140,42 @@ Handle(CDM_Document) CDF_Application::Retrieve(const TCollection_ExtendedString
//function : CanRetrieve
//purpose :
//=======================================================================
PCDM_ReaderStatus CDF_Application::CanRetrieve(const TCollection_ExtendedString& aFolder, const TCollection_ExtendedString& aName) {
PCDM_ReaderStatus CDF_Application::CanRetrieve(Handle(Storage_IODevice)& aDevice)
{
TCollection_ExtendedString aVersion;
return CanRetrieve(aFolder,aName,aVersion);
return CanRetrieve(aDevice, aVersion);
}
//=======================================================================
//function : CanRetrieve
//purpose :
//=======================================================================
PCDM_ReaderStatus CDF_Application::CanRetrieve(const TCollection_ExtendedString& aFolder, const TCollection_ExtendedString& aName, const TCollection_ExtendedString& aVersion) {
PCDM_ReaderStatus CDF_Application::CanRetrieve(Handle(Storage_IODevice)& aDevice, const TCollection_ExtendedString& aVersion)
{
#ifdef OCCT_DEBUG
CDF_Timer theTimer;
#endif
if ( aDevice.IsNull() || aDevice->Open( Storage_VSRead ) != Storage_VSOk )
return PCDM_RS_OpenError;
Standard_Boolean canRead = aDevice->CanRead();
aDevice->Close();
if ( !canRead )
return PCDM_RS_PermissionDenied;
/*
if (!theMetaDataDriver->Find(aFolder,aName,aVersion))
return PCDM_RS_UnknownDocument;
else if (!theMetaDataDriver->HasReadPermission(aFolder,aName,aVersion))
return PCDM_RS_PermissionDenied;
*/
else {
#ifdef OCCT_DEBUG
theTimer.ShowAndRestart("theMetaDataDriver->Find: ");
#endif
Handle(CDM_MetaData) theMetaData = theMetaDataDriver->MetaData(aFolder,aName,aVersion);
Handle(CDM_MetaData) theMetaData = theMetaDataDriver->MetaData(aDevice, aVersion);
#ifdef OCCT_DEBUG
theTimer.ShowAndStop("Getting MetaData: ");
@@ -175,10 +186,9 @@ PCDM_ReaderStatus CDF_Application::CanRetrieve(const TCollection_ExtendedString&
? PCDM_RS_AlreadyRetrievedAndModified : PCDM_RS_AlreadyRetrieved;
}
else {
TCollection_ExtendedString theFileName=theMetaData->FileName();
TCollection_ExtendedString theFormat=PCDM_ReadWriter::FileFormat(theFileName);
TCollection_ExtendedString theFormat=PCDM_ReadWriter::FileFormat(theMetaData->Device());
if(theFormat.Length()==0) {
TCollection_ExtendedString ResourceName=UTL::Extension(theFileName);
TCollection_ExtendedString ResourceName=UTL::Extension(theMetaData->Device()->Name());
ResourceName+=".FileFormat";
if(UTL::Find(Resources(),ResourceName)) {
theFormat=UTL::Value(Resources(),ResourceName);
@@ -189,12 +199,10 @@ PCDM_ReaderStatus CDF_Application::CanRetrieve(const TCollection_ExtendedString&
if(!FindReaderFromFormat(theFormat)) return PCDM_RS_NoDriver;
}
}
return PCDM_RS_OK;
}
//=======================================================================
//function : Activate
//purpose :
@@ -265,12 +273,12 @@ Handle(CDM_Document) CDF_Application::Retrieve(const Handle(CDM_MetaData)& aMeta
Standard_SStream aMsg;
switch (CanRetrieve(aMetaData)) {
case PCDM_RS_UnknownDocument:
aMsg << "could not find the referenced document: " << aMetaData->Path() << "; not found." <<(char)0 << endl;
aMsg << "could not find the referenced document: " << aMetaData->Device() << "; not found." <<(char)0 << endl;
myRetrievableStatus = PCDM_RS_UnknownDocument;
Standard_Failure::Raise(aMsg);
break;
case PCDM_RS_PermissionDenied:
aMsg << "Could not find the referenced document: " << aMetaData->Path() << "; permission denied. " <<(char)0 << endl;
aMsg << "Could not find the referenced document: " << aMetaData->Device() << "; permission denied. " <<(char)0 << endl;
myRetrievableStatus = PCDM_RS_PermissionDenied;
Standard_Failure::Raise(aMsg);
break;
@@ -285,7 +293,7 @@ Handle(CDM_Document) CDF_Application::Retrieve(const Handle(CDM_MetaData)& aMeta
if(Modified) myRetrievableStatus = PCDM_RS_AlreadyRetrievedAndModified;
if(!AlreadyRetrieved || Modified) {
Handle(PCDM_Reader) theReader=Reader(aMetaData->FileName());
Handle(PCDM_Reader) theReader = Reader(aMetaData->Device());
Handle(CDM_Document) theDocument;
@@ -297,14 +305,14 @@ Handle(CDM_Document) CDF_Application::Retrieve(const Handle(CDM_MetaData)& aMeta
else
theDocument=theReader->CreateDocument();
SetReferenceCounter(theDocument,PCDM_RetrievalDriver::ReferenceCounter(aMetaData->FileName(), MessageDriver()));
SetReferenceCounter(theDocument,PCDM_RetrievalDriver::ReferenceCounter(aMetaData->Device(), MessageDriver()));
SetDocumentVersion(theDocument,aMetaData);
theMetaDataDriver->ReferenceIterator()->LoadReferences(theDocument,aMetaData,this,UseStorageConfiguration);
try {
OCC_CATCH_SIGNALS
theReader->Read(aMetaData->FileName(),theDocument,this);
theReader->Read(aMetaData->Device(),theDocument,this);
}
catch (Standard_Failure) {
myRetrievableStatus = theReader->GetStatus();
@@ -331,7 +339,7 @@ Handle(CDM_Document) CDF_Application::Retrieve(const Handle(CDM_MetaData)& aMeta
//=======================================================================
Standard_Integer CDF_Application::DocumentVersion(const Handle(CDM_MetaData)& theMetaData) {
// const Handle(CDM_MessageDriver)& aMsgDriver = MessageDriver();
return PCDM_RetrievalDriver::DocumentVersion(theMetaData->FileName(), MessageDriver());
return PCDM_RetrievalDriver::DocumentVersion(theMetaData->Device(), MessageDriver());
}
//=======================================================================
@@ -360,25 +368,25 @@ CDF_TypeOfActivation CDF_Application::TypeOfActivation(const Handle(CDM_MetaData
//function : FindReader
//purpose :
//=======================================================================
Standard_Boolean CDF_Application::FindReader(const TCollection_ExtendedString& aFileName) {
Standard_Boolean CDF_Application::FindReader(const Handle(Storage_IODevice)& aDevice) {
Standard_GUID voidGUID;
TCollection_ExtendedString voidResourceName;
return FindReader(aFileName,voidGUID,voidResourceName);
return FindReader(aDevice,voidGUID,voidResourceName);
}
//=======================================================================
//function : Reader
//purpose : code dp
//=======================================================================
Handle(PCDM_Reader) CDF_Application::Reader (const TCollection_ExtendedString& aFileName) {
Handle(PCDM_Reader) CDF_Application::Reader (const Handle(Storage_IODevice)& aDevice) {
TCollection_ExtendedString theFormat;
if (!Format(aFileName,theFormat)) {
if (!Format(aDevice,theFormat)) {
Standard_SStream aMsg;
aMsg << "Could not found the format" <<(char)0;
Standard_NoSuchObject::Raise(aMsg);
}
return ReaderFromFormat (theFormat);
return ReaderFromFormat(theFormat);
}
//=======================================================================
@@ -429,14 +437,14 @@ Handle(PCDM_Reader) CDF_Application::ReaderFromFormat(const TCollection_Extended
//function : FindReader
//purpose :
//=======================================================================
Standard_Boolean CDF_Application::FindReader(const TCollection_ExtendedString& aFileName, Standard_GUID& thePluginId, TCollection_ExtendedString& ResourceName) {
Standard_Boolean CDF_Application::FindReader(const Handle(Storage_IODevice)& aDevice, Standard_GUID& thePluginId, TCollection_ExtendedString& ResourceName) {
TCollection_ExtendedString theFormat=PCDM_ReadWriter::FileFormat(aFileName);
TCollection_ExtendedString theFormat=PCDM_ReadWriter::FileFormat(aDevice);
// It is good if the format is in the file. Otherwise base on the extension.
if(theFormat.Length()==0) {
ResourceName=UTL::Extension(aFileName);
ResourceName=UTL::Extension(aDevice->Name());
ResourceName+=".FileFormat";
if(UTL::Find(Resources(),ResourceName)) {
@@ -452,15 +460,15 @@ Standard_Boolean CDF_Application::FindReader(const TCollection_ExtendedString& a
//function : Format
//purpose : dp
//=======================================================================
Standard_Boolean CDF_Application::Format(const TCollection_ExtendedString& aFileName,
Standard_Boolean CDF_Application::Format(const Handle(Storage_IODevice)& aDevice,
TCollection_ExtendedString& theFormat)
{
theFormat = PCDM_ReadWriter::FileFormat(aFileName);
theFormat = PCDM_ReadWriter::FileFormat(aDevice);
// It is good if the format is in the file. Otherwise base on the extension.
if(theFormat.Length()==0) {
TCollection_ExtendedString ResourceName;
ResourceName=UTL::Extension(aFileName);
ResourceName=UTL::Extension(aDevice->Name());
ResourceName+=".FileFormat";
if(UTL::Find(Resources(),ResourceName)) {
@@ -500,8 +508,9 @@ Standard_Boolean CDF_Application::FindReaderFromFormat(const TCollection_Extende
//purpose :
//=======================================================================
PCDM_ReaderStatus CDF_Application::CanRetrieve(const Handle(CDM_MetaData)& aMetaData) {
Handle(Storage_IODevice) aDevice = aMetaData->Device();
if(aMetaData->HasVersion())
return CanRetrieve(aMetaData->Folder(),aMetaData->Name(),aMetaData->Version());
return CanRetrieve(aDevice, aMetaData->Version());
else
return CanRetrieve(aMetaData->Folder(),aMetaData->Name());
return CanRetrieve(aDevice);
}

19
src/CDF/CDF_FWOSDriver.cdl
View File

@@ -18,7 +18,9 @@ class FWOSDriver from CDF inherits MetaDataDriver from CDF
uses
MetaData from CDM,
Document from CDM,
ExtendedString from TCollection
ExtendedString from TCollection,
IODevice from Storage
is
Create
returns FWOSDriver from CDF;
@@ -34,20 +36,19 @@ is
returns Boolean from Standard;
MetaData(me: mutable; aFolder, aName, aVersion: ExtendedString from TCollection)
MetaData(me: mutable; aDevice: IODevice from Storage; aVersion: ExtendedString from TCollection)
returns MetaData from CDM
is private;
CreateMetaData(me: mutable; aDocument: Document from CDM;
aFileName: ExtendedString from TCollection)
returns MetaData from CDM
is private;
CreateMetaData(me: mutable; aDocument: Document from CDM)
returns MetaData from CDM
is private;
FindFolder(me: mutable; aFolder: ExtendedString from TCollection)
returns Boolean from Standard;
DefaultFolder(me: mutable) returns ExtendedString from TCollection;
DefaultFolder(me: mutable) returns ExtendedString from TCollection;
BuildFileName(me: mutable; aDocument: Document from CDM)
returns ExtendedString from TCollection;
@@ -57,9 +58,9 @@ is
is private;
BuildMetaData(me: mutable; aFileName: ExtendedString from TCollection)
BuildMetaData(me: mutable; aDevice: IODevice from Storage)
returns MetaData from CDM
is private;
is private;
SetName(me: mutable; aDocument: Document from CDM; aName: ExtendedString from TCollection)
returns ExtendedString from TCollection

26
src/CDF/CDF_FWOSDriver.cxx
View File

@@ -96,24 +96,20 @@ Standard_Boolean CDF_FWOSDriver::HasReadPermission(const TCollection_ExtendedStr
//function : MetaData
//purpose :
//==============================================================================
Handle(CDM_MetaData) CDF_FWOSDriver::MetaData(const TCollection_ExtendedString& aFolder,
const TCollection_ExtendedString& aName,
const TCollection_ExtendedString& /*aVersion*/)
Handle(CDM_MetaData) CDF_FWOSDriver::MetaData(const Handle(Storage_IODevice)& aDevice,
const TCollection_ExtendedString& /*aVersion*/)
{
TCollection_ExtendedString p = Concatenate(aFolder,aName);
return CDM_MetaData::LookUp(aFolder,aName,p,p,UTL::IsReadOnly(p));
// TCollection_ExtendedString p = Concatenate(aFolder,aName);
return CDM_MetaData::LookUp(aDevice,!aDevice->CanWrite());
}
//==============================================================================
//function : CreateMetaData
//purpose :
//==============================================================================
Handle(CDM_MetaData) CDF_FWOSDriver::CreateMetaData(const Handle(CDM_Document)& aDocument,
const TCollection_ExtendedString& aFileName)
Handle(CDM_MetaData) CDF_FWOSDriver::CreateMetaData(const Handle(CDM_Document)& aDocument)
{
return CDM_MetaData::LookUp(aDocument->RequestedFolder(),aDocument->RequestedName(),
Concatenate(aDocument->RequestedFolder(),aDocument->RequestedName()),
aFileName,UTL::IsReadOnly(aFileName));
return CDM_MetaData::LookUp(aDocument->RequestedDevice(),!aDocument->RequestedDevice()->CanWrite());
}
//==============================================================================
@@ -122,11 +118,13 @@ Handle(CDM_MetaData) CDF_FWOSDriver::CreateMetaData(const Handle(CDM_Document)&
//==============================================================================
TCollection_ExtendedString CDF_FWOSDriver::BuildFileName(const Handle(CDM_Document)& aDocument)
{
/*
TCollection_ExtendedString retstr = TCollection_ExtendedString(aDocument->RequestedFolder());
PutSlash(retstr);
retstr += aDocument->RequestedName();
return retstr;
*/
return aDocument->RequestedDevice()->Name();
}
//==============================================================================
@@ -191,9 +189,9 @@ TCollection_ExtendedString CDF_FWOSDriver::DefaultFolder()
//function : BuildMetaData
//purpose :
//==============================================================================
Handle(CDM_MetaData) CDF_FWOSDriver::BuildMetaData(const TCollection_ExtendedString& aFileName)
Handle(CDM_MetaData) CDF_FWOSDriver::BuildMetaData(const Handle(Storage_IODevice)& aDevice)
{
/*
OSD_Path p = UTL::Path(aFileName);
TCollection_ExtendedString f = UTL::Trek(p);
@@ -202,6 +200,8 @@ Handle(CDM_MetaData) CDF_FWOSDriver::BuildMetaData(const TCollection_ExtendedStr
n += UTL::Extension(p);
return CDM_MetaData::LookUp(f,n,aFileName,aFileName,UTL::IsReadOnly(aFileName));
*/
return CDM_MetaData::LookUp(aDevice,!aDevice->CanWrite());
}
//==============================================================================

12
src/CDF/CDF_MetaDataDriver.cdl
View File

@@ -21,7 +21,8 @@ deferred class MetaDataDriver from CDF inherits Transient from Standard
uses
Document from CDM, MetaData from CDM,
ExtendedString from TCollection,
ReferenceIterator from PCDM
ReferenceIterator from PCDM,
IODevice from Storage
raises
NotImplemented from Standard
@@ -81,7 +82,7 @@ is
returns Boolean from Standard
is deferred;
MetaData(me: mutable; aFolder, aName, aVersion: ExtendedString from TCollection)
MetaData(me: mutable; aDevice: IODevice from Storage; aVersion: ExtendedString from TCollection)
returns MetaData from CDM
---Purpose: should return the MetaData stored in the DBMS with the meta-data
-- corresponding to the Data. If the MetaDataDriver has version management capabilities
@@ -110,8 +111,7 @@ is
CreateMetaData(me: mutable; aDocument: Document from CDM;
aFileName: ExtendedString from TCollection)
CreateMetaData(me: mutable; aDocument: Document from CDM)
---Purpose: should create meta-data corresponding to aData and maintaining a meta-link
-- between these meta-data and aFileName
-- CreateMetaData is called by CreateData
@@ -134,14 +134,12 @@ is
returns ReferenceIterator from PCDM
is virtual;
Find(me: mutable; aFolder, aName: ExtendedString from TCollection)
returns Boolean from Standard;
---Purpose: calls Find with an empty version
MetaData(me: mutable; aFolder, aName: ExtendedString from TCollection)
MetaData(me: mutable; aDevice: IODevice from Storage)
returns MetaData from CDM;
---Purpose: calls MetaData with an empty version
end MetaDataDriver from CDF;

5
src/CDF/CDF_MetaDataDriver.cxx
View File

@@ -86,10 +86,11 @@ Standard_Boolean CDF_MetaDataDriver::Find(const TCollection_ExtendedString& aFol
//purpose :
//=======================================================================
Handle(CDM_MetaData) CDF_MetaDataDriver::MetaData(const TCollection_ExtendedString& aFolder, const TCollection_ExtendedString& aName) {
Handle(CDM_MetaData) CDF_MetaDataDriver::MetaData(const Handle(Storage_IODevice)& aDevice) {
TCollection_ExtendedString aVersion;
return MetaData(aFolder,aName,aVersion);
return MetaData(aDevice,aVersion);
}
//=======================================================================
//function : LastVersion
//purpose :

43
src/CDF/CDF_Store.cdl
View File

@@ -23,11 +23,10 @@ uses Document from CDM,
ExtendedString from TCollection,
StoreList from CDF,
StoreStatus from PCDM,
ExtendedString from TCollection
ExtendedString from TCollection,
IODevice from Storage
is
Create is private;
Create (aDocument: Document from CDM)
@@ -65,8 +64,8 @@ is
--
-- The store list contains one or more documents. One of them is the current document.
--
Folder(me)
returns ExtString from Standard;
Device(me)
returns IODevice from Storage;
---Purpose: returns the folder in which the current document will be stored.
Name(me) returns ExtString from Standard;
@@ -91,16 +90,16 @@ is
---Category: Set methods
--
SetFolder(me: in out; aFolder: ExtendedString from TCollection)
SetDevice(me: in out; aDevice: IODevice from Storage)
---Purpose: defines the folder in which the document should be
-- stored. returns Standard_True if the Folder exists,
-- Standard_False otherwise.
returns Boolean from Standard;
SetName(me: in out; aName: ExtString from Standard)
---Purpose: defines the name under which the document should be stored.
returns StoreSetNameStatus from CDF;
-- SetName(me: in out; aName: ExtString from Standard)
-- ---Purpose: defines the name under which the document should be stored.
-- returns StoreSetNameStatus from CDF;
SetComment(me: in out; aComment: ExtString from Standard);
@@ -116,12 +115,13 @@ is
Realize(me: in out);
Path(me) returns ExtString from Standard;
---Purpose: returns the complete path of the created meta-data.
-- Path(me) returns ExtString from Standard;
-- ---Purpose: returns the complete path of the created meta-data.
MetaDataPath(me) returns ExtString from Standard;
MetaDataDevice(me) returns IODevice from Storage;
---Purpose: returns the path of the previous store is the object
-- is already stored, otherwise an empty string;
Description(me) returns ExtString from Standard;
---Purpose: returns the description of the format of the main object.
@@ -167,17 +167,17 @@ is
Init(me: in out) is private;
SetName(me: in out; aName: ExtendedString from TCollection)
---Purpose: defines the name under which the document should be stored.
returns StoreSetNameStatus from CDF;
-- SetName(me: in out; aName: ExtendedString from TCollection)
-- ---Purpose: defines the name under which the document should be stored.
-- returns StoreSetNameStatus from CDF;
---Category: compatibility
SetFolder(me: in out; aFolder: ExtString from Standard)
---Purpose: defines the folder in which the document should be
-- stored. returns Standard_True if the Folder exists,
-- Standard_False otherwise.
returns Boolean from Standard;
-- SetFolder(me: in out; aFolder: ExtString from Standard)
-- ---Purpose: defines the folder in which the document should be
-- -- stored. returns Standard_True if the Folder exists,
-- -- Standard_False otherwise.
-- returns Boolean from Standard;
fields
@@ -189,9 +189,8 @@ fields
myLastName: ExtendedString from TCollection;
myPath: ExtendedString from TCollection;
-- myPath: ExtendedString from TCollection;
myText: ExtendedString from TCollection;
myStatus: StoreStatus from PCDM;
end Store from CDF;

114
src/CDF/CDF_Store.cxx
View File

@@ -90,100 +90,46 @@ Standard_ExtString CDF_Store::LastName() const {
return myLastName.ToExtString();
}
Standard_ExtString CDF_Store::Folder() const {
static TCollection_ExtendedString retv;
if(myCurrentDocument->HasRequestedFolder())
retv = myCurrentDocument->RequestedFolder();
else
retv= blank;
return retv.ToExtString();
Handle(Storage_IODevice) CDF_Store::Device() const {
Handle(Storage_IODevice) retv;
if( myCurrentDocument->HasRequestedDevice() )
retv = myCurrentDocument->RequestedDevice();
return retv;
}
Standard_ExtString CDF_Store::Name() const {
static TCollection_ExtendedString retv;
retv = myCurrentDocument->RequestedName();
Handle(Storage_IODevice) dev = myCurrentDocument->RequestedDevice();
if ( !dev.IsNull() )
retv = dev->Name();
else
retv = blank;
return retv.ToExtString();
}
Standard_Boolean CDF_Store::SetFolder(const Standard_ExtString aFolder) {
TCollection_ExtendedString f(aFolder);
return SetFolder(f);
Standard_Boolean CDF_Store::SetDevice(const Handle(Storage_IODevice)& aDevice) {
myCurrentDocument->SetRequestedDevice(aDevice);
return Standard_True;
}
Standard_Boolean CDF_Store::SetFolder(const TCollection_ExtendedString& aFolder) {
TCollection_ExtendedString theFolder(aFolder);
Standard_Integer l = theFolder.Length();
// if the last character is the folder separator (which is always the first character)
// it is removed.
// This is correct for Unix systems but not for Windows! VMS and MAC? Thomas Haller, 23.11.01
if(l > 1) {
#ifndef WNT
if(theFolder.Value(l) == theFolder.Value(1)) theFolder.Trunc(l-1);
#else
if (theFolder.Value(l) == '/' || theFolder.Value(l) == '\\')
theFolder.Trunc(l-1);
#endif
}
if(theMetaDataDriver->FindFolder(theFolder)) {
myCurrentDocument->SetRequestedFolder(theFolder);
return Standard_True;
}
return Standard_False;
}
CDF_StoreSetNameStatus CDF_Store::RecheckName () {
return SetName(myCurrentDocument->RequestedName());
}
CDF_StoreSetNameStatus CDF_Store::SetName(const TCollection_ExtendedString& aName)
{
TCollection_ExtendedString theName=theMetaDataDriver->SetName(myCurrentDocument,aName);
if(myCurrentDocument->IsStored ()) {
Handle(CDM_MetaData) E = myCurrentDocument->MetaData();
if( E->Folder() == myCurrentDocument->RequestedFolder()
&& E->Name() == theName) return CDF_SSNS_OK;
}
if(myCurrentDocument->HasRequestedFolder()) {
if (theMetaDataDriver->Find(myCurrentDocument->RequestedFolder(),theName)) {
if(theMetaDataDriver->MetaData(myCurrentDocument->RequestedFolder(),theName)->IsRetrieved())
return CDF_SSNS_OpenDocument;
else {
myCurrentDocument->SetRequestedName(theName);
return CDF_SSNS_ReplacingAnExistentDocument;
}
}
}
myCurrentDocument->SetRequestedName(theName);
return CDF_SSNS_OK;
}
CDF_StoreSetNameStatus CDF_Store::SetName(const Standard_ExtString aName)
{
TCollection_ExtendedString theName(aName);
return SetName(theName);
// return SetName(myCurrentDocument->RequestedName());
return CDF_SSNS_OK;
}
void CDF_Store::Realize() {
Standard_ProgramError_Raise_if(!myList->IsConsistent(),"information are missing");
Handle(CDM_MetaData) m;
myText = "";
myStatus = myList->Store(m,myText);
if(myStatus==PCDM_SS_OK) myPath = m->Path();
}
Standard_ExtString CDF_Store::Path() const {
return myPath.ToExtString();
}
Standard_ExtString CDF_Store::MetaDataPath() const {
static TCollection_ExtendedString retv;
retv="";
if(myCurrentDocument->IsStored()) retv=myCurrentDocument->MetaData()->Path();
return retv.ToExtString();
Handle(Storage_IODevice) CDF_Store::MetaDataDevice() const {
return myCurrentDocument->MetaData()->Device();
}
Standard_ExtString CDF_Store::Description() const {
static TCollection_ExtendedString retv;
@@ -203,7 +149,7 @@ Standard_Boolean CDF_Store::IsModified() const {
}
Standard_Boolean CDF_Store::CurrentIsConsistent() const {
if(!myCurrentDocument->IsStored())
return myCurrentDocument->HasRequestedFolder();
return myCurrentDocument->HasRequestedDevice();
return Standard_True;
}
@@ -225,14 +171,14 @@ Standard_ExtString CDF_Store::PreviousVersion() const {
Standard_Boolean CDF_Store::SetPreviousVersion (const Standard_ExtString aPreviousVersion) {
if(theMetaDataDriver->HasVersionCapability()) {
if(myCurrentDocument->HasRequestedFolder()) {
if(theMetaDataDriver->Find(myCurrentDocument->RequestedFolder(),myCurrentDocument->RequestedName(),aPreviousVersion)){
if(myCurrentDocument->HasRequestedDevice()) {
// if(theMetaDataDriver->Find(myCurrentDocument->RequestedFolder(),myCurrentDocument->RequestedName(),aPreviousVersion)){
myCurrentDocument->SetRequestedPreviousVersion(aPreviousVersion);
return Standard_True;
}
else
return Standard_False;
// }
// else
// return Standard_False;
}
else
return Standard_False;
@@ -285,7 +231,7 @@ CDF_SubComponentStatus CDF_Store::SubComponentStatus(const Standard_ExtString aP
Handle(CDM_Document) d = CDM_Document::FindFromPresentation(aPresentation);
if(!d->IsStored())
return d->HasRequestedFolder()? CDF_SCS_Consistent : CDF_SCS_Unconsistent;
return d->HasRequestedDevice()? CDF_SCS_Consistent : CDF_SCS_Unconsistent;
if(d->IsModified()) return CDF_SCS_Modified;
return CDF_SCS_Stored;
@@ -303,9 +249,9 @@ Standard_ExtString CDF_Store::AssociatedStatusText() const {
void CDF_Store::FindDefault() {
if (!myCurrentDocument->IsStored ()) {
myCurrentDocument->SetRequestedFolder(CDF_Session::CurrentSession()->CurrentApplication()->DefaultFolder());
// myCurrentDocument->SetRequestedFolder(CDF_Session::CurrentSession()->CurrentApplication()->DefaultFolder());
// myCurrentDocument->SetRequestedName(theMetaDataDriver->SetName(myCurrentDocument,myCurrentDocument->Presentation()));
myCurrentDocument->SetRequestedName(theMetaDataDriver->SetName(myCurrentDocument,myCurrentDocument->RequestedName()));
// myCurrentDocument->SetRequestedName(theMetaDataDriver->SetName(myCurrentDocument,myCurrentDocument->RequestedName()));
}
}
void CDF_Store::SetComment(const Standard_ExtString aComment) {

13
src/CDF/CDF_StoreList.cxx
View File

@@ -57,13 +57,14 @@ Standard_Boolean CDF_StoreList::IsConsistent () const {
Standard_Boolean yes = Standard_True;
CDM_MapIteratorOfMapOfDocument it (myItems);
for ( ; it.More() && yes ; it.Next()) {
yes = it.Key()->HasRequestedFolder();
yes = it.Key()->HasRequestedDevice();
}
return yes && myMainDocument->HasRequestedFolder();
return yes && myMainDocument->HasRequestedDevice();
}
void CDF_StoreList::Init() {
myIterator = CDM_MapIteratorOfMapOfDocument(myItems);
}
Standard_Boolean CDF_StoreList::More() const {
return myIterator.More();
}
@@ -93,23 +94,25 @@ PCDM_StoreStatus CDF_StoreList::Store (Handle(CDM_MetaData)& aMetaData, TCollect
aMsg <<"No storage driver does exist for this format: " << theDocument->StorageFormat() << (char)0;
Standard_Failure::Raise(aMsg);
}
/*
if(!theMetaDataDriver->FindFolder(theDocument->RequestedFolder())) {
Standard_SStream aMsg; aMsg << "could not find the active dbunit";
aMsg << TCollection_ExtendedString(theDocument->RequestedFolder())<< (char)0;
Standard_NoSuchObject::Raise(aMsg);
}
TCollection_ExtendedString theName=theMetaDataDriver->BuildFileName(theDocument);
*/
CDF_Timer theTimer;
Handle(Storage_IODevice) aDevice = theDocument->RequestedDevice();
Handle(PCDM_StorageDriver) aDocumentStorageDriver = PCDM::StorageDriver(theDocument);
aDocumentStorageDriver->Write(theDocument,theName);
aDocumentStorageDriver->Write(theDocument, aDevice);
status = aDocumentStorageDriver->GetStoreStatus();
theTimer.ShowAndRestart("Driver->Write: ");
aMetaData = theMetaDataDriver->CreateMetaData(theDocument,theName);
aMetaData = theMetaDataDriver->CreateMetaData(theDocument);
theTimer.ShowAndStop("metadata creating: ");
theDocument->SetMetaData(aMetaData);

2
src/CDM/CDM.cdl
View File

@@ -17,7 +17,7 @@
package CDM
uses TCollection,TColStd,Resource
uses TCollection, TColStd, Resource, Storage
is

36
src/CDM/CDM_Document.cdl
View File

@@ -51,13 +51,18 @@ inherits Transient from Standard
-- the retrieving of the referenced documents.
uses
MetaData from CDM,
Reference from CDM,
Application from CDM,
CanCloseStatus from CDM,
ListOfReferences from CDM,
ReferenceIterator from CDM,
ExtendedString from TCollection,MetaData from CDM, Application from CDM,
ListOfReferences from CDM, SequenceOfExtendedString from TColStd,
GUID from Standard,Manager from Resource,CanCloseStatus from CDM
ExtendedString from TCollection,
SequenceOfExtendedString from TColStd,
GUID from Standard,
Manager from Resource,
IODevice from Storage
raises NoSuchObject from Standard,Failure from Standard,DomainError from Standard
is
@@ -290,7 +295,7 @@ is
MetaData(me) returns MetaData from CDM
raises NoSuchObject from Standard;
Folder(me) returns ExtendedString from TCollection
Device(me) returns IODevice from Storage
raises NoSuchObject from Standard;
---Warning: if the object is not stored;
@@ -300,20 +305,16 @@ is
SetRequestedFolder(me: mutable; aFolder: ExtendedString from TCollection);
SetRequestedDevice(me: mutable; aDevice: IODevice from Storage);
---Purpose: defines the folder in which the object should be stored.
RequestedFolder(me) returns ExtendedString from TCollection
raises NoSuchObject from Standard;
RequestedDevice(me) returns IODevice from Storage;
HasRequestedFolder(me) returns Boolean from Standard;
HasRequestedDevice(me) returns Boolean from Standard;
SetRequestedName(me: mutable; aName: ExtendedString from TCollection);
---Purpose: defines the name under which the object should be stored.
RequestedName(me:mutable) returns ExtendedString from TCollection;
---Purpose: determines under which the document is going to be
-- store. By default the name of the document wil be --
@@ -332,7 +333,6 @@ is
---Purpose: defines the Comment with which the object should be stored.
RequestedComment(me) returns ExtendedString from TCollection;
---Category: resource reading methods
--
@@ -507,11 +507,7 @@ fields
myRequestedComment: ExtendedString from TCollection;
myRequestedFolder: ExtendedString from TCollection;
myRequestedFolderIsDefined: Boolean from Standard;
myRequestedName: ExtendedString from TCollection;
myRequestedNameIsDefined: Boolean from Standard;
myRequestedDevice: IODevice from Storage;
myRequestedPreviousVersionIsDefined: Boolean from Standard;
myRequestedPreviousVersion: ExtendedString from TCollection;

66
src/CDM/CDM_Document.cxx
View File

@@ -50,8 +50,6 @@ CDM_Document::CDM_Document():
myActualReferenceIdentifier (0),
myStorageVersion (0),
myRequestedComment (""),
myRequestedFolderIsDefined (Standard_False),
myRequestedNameIsDefined (Standard_False),
myRequestedPreviousVersionIsDefined(Standard_False),
myFileExtensionWasFound (Standard_False),
myDataTypeWasFound (Standard_False),
@@ -681,8 +679,9 @@ void CDM_Document::SetMetaData(const Handle(CDM_MetaData)& aMetaData)
myMetaData = aMetaData;
SetRequestedFolder(aMetaData->Folder());
if(aMetaData->HasVersion()) SetRequestedPreviousVersion(aMetaData->Version());
SetRequestedDevice( aMetaData->Device() );
if ( aMetaData->HasVersion() )
SetRequestedPreviousVersion( aMetaData->Version() );
}
//=======================================================================
@@ -732,62 +731,45 @@ TCollection_ExtendedString CDM_Document::RequestedComment() const
}
//=======================================================================
//function : Folder
//function : Device
//purpose :
//=======================================================================
TCollection_ExtendedString CDM_Document::Folder() const {
Handle(Storage_IODevice) CDM_Document::Device() const {
if(myMetaData.IsNull())
Standard_NoSuchObject::Raise("cannot furnish the folder of an object "
"which is not stored");
return myMetaData->Folder();
return myMetaData->Device();
}
//=======================================================================
//function : SetRequestedFolder
//function : SetRequestedDevice
//purpose :
//=======================================================================
void CDM_Document::SetRequestedFolder(const TCollection_ExtendedString& aFolder)
void CDM_Document::SetRequestedDevice(const Handle(Storage_IODevice)& aDevice)
{
TCollection_ExtendedString f(aFolder);
if(f.Length() != 0) {
myRequestedFolderIsDefined=Standard_True;
myRequestedFolder=aFolder;
}
myRequestedDevice=aDevice;
}
//=======================================================================
//function : RequestedFolder
//function : RequestedDevice
//purpose :
//=======================================================================
TCollection_ExtendedString CDM_Document::RequestedFolder() const
Handle(Storage_IODevice) CDM_Document::RequestedDevice() const
{
Standard_NoSuchObject_Raise_if (!myRequestedFolderIsDefined,
"storage folder is undefined for this document");
return myRequestedFolder;
return myRequestedDevice;
}
//=======================================================================
//function : HasRequestedFolder
//function : HasRequestedDevice
//purpose :
//=======================================================================
Standard_Boolean CDM_Document::HasRequestedFolder() const
Standard_Boolean CDM_Document::HasRequestedDevice() const
{
return myRequestedFolderIsDefined;
}
//=======================================================================
//function : SetRequestedName
//purpose :
//=======================================================================
void CDM_Document::SetRequestedName(const TCollection_ExtendedString& aName)
{
myRequestedName=aName;
myRequestedNameIsDefined=Standard_True;
return !myRequestedDevice.IsNull();
}
//=======================================================================
@@ -797,14 +779,16 @@ void CDM_Document::SetRequestedName(const TCollection_ExtendedString& aName)
TCollection_ExtendedString CDM_Document::RequestedName()
{
if(!myRequestedNameIsDefined) {
if(!myMetaData.IsNull())
myRequestedName=myMetaData->Name();
else
myRequestedName=Presentation();
}
myRequestedNameIsDefined=Standard_True;
return myRequestedName;
TCollection_ExtendedString aName;
if ( !myRequestedDevice.IsNull() )
aName = myRequestedDevice->Name();
else if ( !myMetaData.IsNull() )
aName = myMetaData->Name();
else
aName = Presentation();
return aName;
}
//=======================================================================

50
src/CDM/CDM_MetaData.cdl
View File

@@ -16,37 +16,34 @@
class MetaData from CDM inherits Transient from Standard
uses ExtendedString from TCollection,Document from CDM,MetaDataLookUpTable from CDM, DocumentPointer from CDM,
Application from CDM
uses ExtendedString from TCollection,
Document from CDM,
MetaDataLookUpTable from CDM,
DocumentPointer from CDM,
Application from CDM,
IODevice from Storage
raises NoSuchObject from Standard
is
Create(aFolder,aName, aPath: ExtendedString from TCollection;
aFileName: ExtendedString from TCollection; ReadOnly:Boolean from Standard)
returns MetaData from CDM is private;
Create(aFolder,aName, aPath, aVersion: ExtendedString from TCollection;
aFileName: ExtendedString from TCollection; ReadOnly:Boolean from Standard)
returns MetaData from CDM is private;
LookUp(myclass; aFolder,aName, aPath: ExtendedString from TCollection;
aFileName: ExtendedString from TCollection; ReadOnly:Boolean from Standard)
returns MetaData from CDM;
LookUp(myclass; aFolder,aName, aPath, aVersion: ExtendedString from TCollection; aFileName: ExtendedString from TCollection; ReadOnly:Boolean from Standard)
returns MetaData from CDM;
Create(aDevice: IODevice from Storage; ReadOnly:Boolean from Standard)
returns MetaData from CDM is private;
Create(aDevice: IODevice from Storage; aVersion: ExtendedString from TCollection; ReadOnly:Boolean from Standard)
returns MetaData from CDM is private;
LookUp(myclass; aDevice: IODevice from Storage; ReadOnly:Boolean from Standard)
returns MetaData from CDM;
LookUp(myclass; aDevice: IODevice from Storage; aVersion: ExtendedString from TCollection; ReadOnly:Boolean from Standard)
returns MetaData from CDM;
IsRetrieved(me) returns Boolean from Standard;
Document(me) returns Document from CDM;
Folder(me) returns ExtendedString from TCollection;
-- Folder(me) returns ExtendedString from TCollection;
---Purpose: returns the folder in which the meta-data has to be created
-- or has to be found.
--
@@ -65,7 +62,7 @@ is
---Purpose: indicates that the version has to be taken into account when
-- searching the corresponding meta-data.
FileName(me) returns ExtendedString from TCollection;
-- FileName(me) returns ExtendedString from TCollection;
---Category: programming facility
--
Print(me; anOStream: in out OStream from Standard)
@@ -74,8 +71,9 @@ is
---C++: alias "Standard_OStream& operator << (Standard_OStream& anOStream);"
--
Path(me) returns ExtendedString from TCollection;
-- Path(me) returns ExtendedString from TCollection;
Device(me) returns IODevice from Storage;
---Category: methods to modify the metadata.
--
@@ -100,15 +98,17 @@ is
fields
myIsRetrieved: Boolean from Standard;
myDocument: DocumentPointer from CDM;
myFolder: ExtendedString from TCollection;
-- myFolder: ExtendedString from TCollection;
myName: ExtendedString from TCollection;
myVersion: ExtendedString from TCollection;
myHasVersion: Boolean from Standard;
myFileName: ExtendedString from TCollection;
myPath: ExtendedString from TCollection;
-- myFileName: ExtendedString from TCollection;
-- myPath: ExtendedString from TCollection;
myDevice : IODevice from Storage;
myDocumentVersion: Integer from Standard;

106
src/CDM/CDM_MetaData.cxx
View File

@@ -17,32 +17,39 @@
#include <CDM_MetaData.ixx>
#include <CDM_MetaDataLookUpTable.hxx>
#include <TCollection_AsciiString.hxx>
static CDM_MetaDataLookUpTable& getLookUpTable(){
static CDM_MetaDataLookUpTable theLookUpTable;
return theLookUpTable;
}
CDM_MetaData::CDM_MetaData(const TCollection_ExtendedString& aFolder, const TCollection_ExtendedString& aName, const TCollection_ExtendedString& aPath,const TCollection_ExtendedString& aFileName,const Standard_Boolean ReadOnly):
CDM_MetaData::CDM_MetaData(const Handle(Storage_IODevice)& aDevice, const Standard_Boolean ReadOnly):
myIsRetrieved(Standard_False),
myFolder(aFolder),
myName(aName),
//myFolder(aFolder),
//myName(aName),
myHasVersion(Standard_False),
myFileName(aFileName),
myPath(aPath),
//myFileName(aFileName),
//myPath(aPath),
myDevice(aDevice),
myDocumentVersion(0),
myIsReadOnly(ReadOnly)
{}
{
}
CDM_MetaData::CDM_MetaData(const TCollection_ExtendedString& aFolder, const TCollection_ExtendedString& aName, const TCollection_ExtendedString& aPath,const TCollection_ExtendedString& aVersion,const TCollection_ExtendedString& aFileName,const Standard_Boolean ReadOnly):
CDM_MetaData::CDM_MetaData(const Handle(Storage_IODevice)& aDevice, const TCollection_ExtendedString& aVersion, const Standard_Boolean ReadOnly):
myIsRetrieved(Standard_False),
myFolder(aFolder),
myName(aName),
//myFolder(aFolder),
//myName(aName),
myVersion(aVersion),
myHasVersion(Standard_True),
myFileName(aFileName),
myPath(aPath),
//myFileName(aFileName),
//myPath(aPath),
myDevice(aDevice),
myDocumentVersion(0),
myIsReadOnly(ReadOnly)
{}
{
}
Standard_Boolean CDM_MetaData::IsRetrieved() const {
return myIsRetrieved;
@@ -59,60 +66,81 @@ void CDM_MetaData::SetDocument(const Handle(CDM_Document)& aDocument) {
void CDM_MetaData::UnsetDocument() {
myIsRetrieved = Standard_False;
}
Handle(CDM_MetaData) CDM_MetaData::LookUp(const TCollection_ExtendedString& aFolder, const TCollection_ExtendedString& aName, const TCollection_ExtendedString& aPath,const TCollection_ExtendedString& aFileName,const Standard_Boolean ReadOnly) {
Handle(CDM_MetaData) CDM_MetaData::LookUp(const Handle(Storage_IODevice)& aDevice, const Standard_Boolean ReadOnly) {
Handle(CDM_MetaData) theMetaData;
TCollection_ExtendedString aConventionalPath=aPath;
aConventionalPath.ChangeAll('\\','/');
if(!getLookUpTable().IsBound(aConventionalPath)) {
theMetaData = new CDM_MetaData(aFolder,aName,aPath,aFileName,ReadOnly);
getLookUpTable().Bind(aConventionalPath,theMetaData);
TCollection_AsciiString aSig;
if ( !aDevice.IsNull() )
aSig = aDevice->Signature();
if ( aSig.IsEmpty() || !getLookUpTable().IsBound(aSig) ) {
theMetaData = new CDM_MetaData(aDevice, ReadOnly);
if ( !aSig.IsEmpty() )
getLookUpTable().Bind(aSig, theMetaData);
}
else
theMetaData = getLookUpTable()(aConventionalPath);
return theMetaData;
}
Handle(CDM_MetaData) CDM_MetaData::LookUp(const TCollection_ExtendedString& aFolder, const TCollection_ExtendedString& aName, const TCollection_ExtendedString& aPath, const TCollection_ExtendedString& aVersion, const TCollection_ExtendedString& aFileName,const Standard_Boolean ReadOnly) {
Handle(CDM_MetaData) theMetaData;
TCollection_ExtendedString aConventionalPath=aPath;
aConventionalPath.ChangeAll('\\','/');
if(!getLookUpTable().IsBound(aConventionalPath)) {
theMetaData = new CDM_MetaData(aFolder,aName,aPath,aVersion,aFileName,ReadOnly);
getLookUpTable().Bind(aConventionalPath,theMetaData);
}
else
theMetaData = getLookUpTable()(aConventionalPath);
theMetaData = getLookUpTable()(aSig);
return theMetaData;
}
Handle(CDM_MetaData) CDM_MetaData::LookUp(const Handle(Storage_IODevice)& aDevice, const TCollection_ExtendedString& aVersion, const Standard_Boolean ReadOnly) {
Handle(CDM_MetaData) theMetaData;
TCollection_AsciiString aSig;
if ( !aDevice.IsNull() )
aSig = aDevice->Signature();
if ( aSig.IsEmpty() || !getLookUpTable().IsBound(aSig) ) {
theMetaData = new CDM_MetaData(aDevice, aVersion, ReadOnly);
if ( !aSig.IsEmpty() )
getLookUpTable().Bind(aSig, theMetaData);
}
else
theMetaData = getLookUpTable()(aSig);
return theMetaData;
}
/*
TCollection_ExtendedString CDM_MetaData::Folder() const {
return myFolder;
}
*/
TCollection_ExtendedString CDM_MetaData::Name() const {
return myName;
TCollection_ExtendedString aName;
if ( !Device().IsNull() )
aName = Device()->Name();
return aName;
}
TCollection_ExtendedString CDM_MetaData::Version() const {
Standard_NoSuchObject_Raise_if(!myHasVersion,"Document has no version");
return myVersion;
}
Standard_Boolean CDM_MetaData::HasVersion() const {
return myHasVersion;
}
/*
TCollection_ExtendedString CDM_MetaData::FileName() const {
return myFileName;
}
TCollection_ExtendedString CDM_MetaData::Path() const {
return myPath;
}
*/
Handle(Storage_IODevice) CDM_MetaData::Device() const
{
return myDevice;
}
Standard_OStream& CDM_MetaData::Print(Standard_OStream& anOStream) const {
anOStream << "*CDM_MetaData*";
anOStream << myFolder << "," << myName;
// anOStream << myFolder << "," << myName;
if(HasVersion()) anOStream << "," << myVersion ;
anOStream << "; Physical situation: ";
anOStream << myFileName;
anOStream << endl;
// anOStream << "; Physical situation: ";
// anOStream << myFileName;
// anOStream << endl;
return anOStream;
}
Standard_OStream& CDM_MetaData::operator << (Standard_OStream& anOStream) {

3
src/DDF/DDF_BasicCommands.cxx
View File

@@ -55,8 +55,7 @@
#include <TDF_RelocationTable.hxx>
#include <TDF_Tool.hxx>
#include <DDF_IOStream.hxx>
#include <Storage_Error.hxx>
//=======================================================================
//function : Children

1356
src/DDF/DDF_IOStream.cxx
View File

File diff suppressed because it is too large Load Diff

243
src/DDF/DDF_IOStream.hxx
View File

@@ -1,243 +0,0 @@
// Created on: 1997-08-22
// Created by: DAUTRY Philippe
// Copyright (c) 1997-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.
// This file has been written using FSD_File.hxx as template.
// This is a specific adaptation for Draw use (save & restore commands).
// It is not sure at all this code is portable on any other plateform than
// SUN OS. Don't use it anywhere else.
// Thanks for comprehension. (22 august 97)
#ifndef DDF_IOStream_HeaderFile
#define DDF_IOStream_HeaderFile
#include <stdio.h>
#include <Storage_BaseDriver.hxx>
#include <Storage_Error.hxx>
#include <Storage_OpenMode.hxx>
#include <Storage_Position.hxx>
class Storage_StreamTypeMismatchError;
class Storage_StreamFormatError;
class Storage_StreamWriteError;
class Storage_StreamExtCharParityError;
class TColStd_SequenceOfExtendedString;
#ifndef Standard_EXPORT
#ifdef WNT
#define Standard_EXPORT __declspec(dllexport)
#else
#define Standard_EXPORT
#endif
#endif
#ifdef WNT
#pragma warning (disable : 4275)
#endif
class Standard_EXPORT DDF_IOStream : public Storage_BaseDriver {
public:
// Methods PUBLIC
//
DDF_IOStream();
Storage_Error Open(const TCollection_AsciiString& aName,const Storage_OpenMode aMode) ;
Storage_Error Open(istream* anIStream) ;
Storage_Error Open(ostream* anOStream) ;
Standard_Boolean IsEnd() ;
Storage_Position Tell() { return -1; }
static Storage_Error IsGoodFileType(istream* anIStream) ;
Storage_Error BeginWriteInfoSection() ;
void WriteInfo(const Standard_Integer nbObj,const TCollection_AsciiString& dbVersion,const TCollection_AsciiString& date,const TCollection_AsciiString& schemaName,const TCollection_AsciiString& schemaVersion,const TCollection_ExtendedString& appName,const TCollection_AsciiString& appVersion,const TCollection_ExtendedString& objectType,const TColStd_SequenceOfAsciiString& userInfo) ;
Storage_Error EndWriteInfoSection() ;
Storage_Error BeginReadInfoSection() ;
void ReadInfo(Standard_Integer& nbObj,TCollection_AsciiString& dbVersion,TCollection_AsciiString& date,TCollection_AsciiString& schemaName,TCollection_AsciiString& schemaVersion,TCollection_ExtendedString& appName,TCollection_AsciiString& appVersion,TCollection_ExtendedString& objectType,TColStd_SequenceOfAsciiString& userInfo) ;
Storage_Error EndReadInfoSection() ;
Storage_Error BeginWriteCommentSection() ;
void WriteComment(const TColStd_SequenceOfExtendedString& userComments) ;
Storage_Error EndWriteCommentSection() ;
Storage_Error BeginReadCommentSection() ;
void ReadComment(TColStd_SequenceOfExtendedString& userComments) ;
Storage_Error EndReadCommentSection() ;
Storage_Error BeginWriteTypeSection() ;
void SetTypeSectionSize(const Standard_Integer aSize) ;
void WriteTypeInformations(const Standard_Integer typeNum,const TCollection_AsciiString& typeName) ;
Storage_Error EndWriteTypeSection() ;
Storage_Error BeginReadTypeSection() ;
Standard_Integer TypeSectionSize() ;
void ReadTypeInformations(Standard_Integer& typeNum,TCollection_AsciiString& typeName) ;
Storage_Error EndReadTypeSection() ;
Storage_Error BeginWriteRootSection() ;
void SetRootSectionSize(const Standard_Integer aSize) ;
void WriteRoot(const TCollection_AsciiString& rootName,const Standard_Integer aRef,const TCollection_AsciiString& aType) ;
Storage_Error EndWriteRootSection() ;
Storage_Error BeginReadRootSection() ;
Standard_Integer RootSectionSize() ;
void ReadRoot(TCollection_AsciiString& rootName,Standard_Integer& aRef,TCollection_AsciiString& aType) ;
Storage_Error EndReadRootSection() ;
Storage_Error BeginWriteRefSection() ;
void SetRefSectionSize(const Standard_Integer aSize) ;
void WriteReferenceType(const Standard_Integer reference,const Standard_Integer typeNum) ;
Storage_Error EndWriteRefSection() ;
Storage_Error BeginReadRefSection() ;
Standard_Integer RefSectionSize() ;
void ReadReferenceType(Standard_Integer& reference,Standard_Integer& typeNum) ;
Storage_Error EndReadRefSection() ;
Storage_Error BeginWriteDataSection() ;
void WritePersistentObjectHeader(const Standard_Integer aRef,const Standard_Integer aType) ;
void BeginWritePersistentObjectData() ;
void BeginWriteObjectData() ;
void EndWriteObjectData() ;
void EndWritePersistentObjectData() ;
Storage_Error EndWriteDataSection() ;
Storage_Error BeginReadDataSection() ;
void ReadPersistentObjectHeader(Standard_Integer& aRef,Standard_Integer& aType) ;
void BeginReadPersistentObjectData() ;
void BeginReadObjectData() ;
void EndReadObjectData() ;
void EndReadPersistentObjectData() ;
Storage_Error EndReadDataSection() ;
void SkipObject() ;
Storage_BaseDriver& PutReference(const Standard_Integer aValue) ;
Storage_BaseDriver& PutCharacter(const Standard_Character aValue) ;
Storage_BaseDriver& operator <<(const Standard_Character aValue)
{
return PutCharacter(aValue);
}
Storage_BaseDriver& PutExtCharacter(const Standard_ExtCharacter aValue) ;
Storage_BaseDriver& operator <<(const Standard_ExtCharacter aValue)
{
return PutExtCharacter(aValue);
}
Storage_BaseDriver& PutInteger(const Standard_Integer aValue) ;
Storage_BaseDriver& operator <<(const Standard_Integer aValue)
{
return PutInteger(aValue);
}
Storage_BaseDriver& PutBoolean(const Standard_Boolean aValue) ;
Storage_BaseDriver& operator <<(const Standard_Boolean aValue)
{
return PutBoolean(aValue);
}
Storage_BaseDriver& PutReal(const Standard_Real aValue) ;
Storage_BaseDriver& operator <<(const Standard_Real aValue)
{
return PutReal(aValue);
}
Storage_BaseDriver& PutShortReal(const Standard_ShortReal aValue) ;
Storage_BaseDriver& operator <<(const Standard_ShortReal aValue)
{
return PutShortReal(aValue);
}
Storage_BaseDriver& GetReference(Standard_Integer& aValue) ;
Storage_BaseDriver& GetCharacter(Standard_Character& aValue) ;
Storage_BaseDriver& operator >>(Standard_Character& aValue)
{
return GetCharacter(aValue);
}
Storage_BaseDriver& GetExtCharacter(Standard_ExtCharacter& aValue) ;
Storage_BaseDriver& operator >>(Standard_ExtCharacter& aValue)
{
return GetExtCharacter(aValue);
}
Storage_BaseDriver& GetInteger(Standard_Integer& aValue) ;
Storage_BaseDriver& operator >>(Standard_Integer& aValue)
{
return GetInteger(aValue);
}
Storage_BaseDriver& GetBoolean(Standard_Boolean& aValue) ;
Storage_BaseDriver& operator >>(Standard_Boolean& aValue)
{
return GetBoolean(aValue);
}
Storage_BaseDriver& GetReal(Standard_Real& aValue) ;
Storage_BaseDriver& operator >>(Standard_Real& aValue)
{
return GetReal(aValue);
}
Storage_BaseDriver& GetShortReal(Standard_ShortReal& aValue) ;
Storage_BaseDriver& operator >>(Standard_ShortReal& aValue)
{
return GetShortReal(aValue);
}
Storage_Error Close() ;
void Destroy() ;
~DDF_IOStream()
{
Destroy();
}
protected:
// Methods PROTECTED
//
void ReadLine(TCollection_AsciiString& buffer) ;
void ReadWord(TCollection_AsciiString& buffer) ;
void ReadExtendedLine(TCollection_ExtendedString& buffer) ;
void WriteExtendedLine(const TCollection_ExtendedString& buffer) ;
void ReadChar(TCollection_AsciiString& buffer,const Standard_Integer rsize) ;
void ReadString(TCollection_AsciiString& buffer) ;
void FlushEndOfLine() ;
Storage_Error FindTag(const Standard_CString aTag) ;
// Fields PROTECTED
//
private:
// Methods PRIVATE
//
static const Standard_CString MagicNumber() ;
// Fields PRIVATE
//
//FSD_FStream myStream;
istream* myIStream;
ostream* myOStream;
};
#ifdef WNT
#pragma warning (default : 4275)
#endif
// other inline functions and methods (like "C++: function call" methods)
//
#endif

2
src/DDF/FILES
View File

@@ -4,6 +4,4 @@ DDF_BasicCommands.cxx
DDF_DataCommands.cxx
DDF_TransactionCommands.cxx
DDF_BrowserCommands.cxx
DDF_IOStream.cxx
DDF_IOStream.hxx
FILES

11
src/FSD/FSD_BinaryFile.cdl
View File

@@ -21,6 +21,7 @@ inherits BaseDriver from Storage
uses Position from Storage,
Error from Storage,
OpenMode from Storage,
IODevice from Storage,
AsciiString from TCollection,
SequenceOfAsciiString from TColStd,
SequenceOfExtendedString from TColStd,
@@ -36,15 +37,16 @@ raises StreamTypeMismatchError from Storage,
is
Create returns BinaryFile from FSD;
Open(me : in out; aName : AsciiString from TCollection; aMode : OpenMode from Storage) returns Error from Storage;
Open(me : in out; aDevice : IODevice from Storage; aMode : OpenMode from Storage)
returns Error from Storage is redefined;
IsEnd(me : in out) returns Boolean from Standard;
Tell( me : in out ) returns Position from Storage;
---Purpose: return position in the file. Return -1 upon error.
IsGoodFileType(myclass; aName : AsciiString from TCollection)
returns Error from Storage;
IsGoodFileType(myclass; aDevice : IODevice from Storage)
returns Error from Storage;
-- INFO SECTION
-- write
@@ -316,8 +318,7 @@ is
WriteExtendedString(me : in out; buffer : ExtendedString from TCollection) is protected;
---Purpose: write string at the current position.
fields
fields
myStream : BStream from FSD;
myHeader : FileHeader from FSD;
end;

247
src/FSD/FSD_BinaryFile.cxx
View File

@@ -23,8 +23,7 @@ const Standard_CString MAGICNUMBER = "BINFILE";
//purpose :
//=======================================================================
FSD_BinaryFile::FSD_BinaryFile() :
myStream(0L)
FSD_BinaryFile::FSD_BinaryFile()
{
myHeader.testindian = -1;
myHeader.binfo = -1;
@@ -47,12 +46,12 @@ myStream(0L)
// write
//=======================================================================
Storage_Error FSD_BinaryFile::IsGoodFileType(const TCollection_AsciiString& aName)
Storage_Error FSD_BinaryFile::IsGoodFileType(const Handle(Storage_IODevice)& aDevice)
{
FSD_BinaryFile f;
Storage_Error s;
s = f.Open(aName,Storage_VSRead);
s = f.Open(aDevice, Storage_VSRead);
if (s == Storage_VSOk) {
TCollection_AsciiString l;
@@ -75,8 +74,16 @@ Storage_Error FSD_BinaryFile::IsGoodFileType(const TCollection_AsciiString& aNam
//purpose :
//=======================================================================
Storage_Error FSD_BinaryFile::Open(const TCollection_AsciiString& aName,const Storage_OpenMode aMode)
Storage_Error FSD_BinaryFile::Open(const Handle(Storage_IODevice)& aDevice, const Storage_OpenMode aMode)
{
SetDevice(aDevice);
if ( Device().IsNull() )
return Storage_VSOpenError;
return Device()->Open(aMode);
/*
Storage_Error result = Storage_VSOk;
SetName(aName);
@@ -104,6 +111,7 @@ Storage_Error FSD_BinaryFile::Open(const TCollection_AsciiString& aName,const St
}
return result;
*/
}
//=======================================================================
@@ -113,7 +121,7 @@ Storage_Error FSD_BinaryFile::Open(const TCollection_AsciiString& aName,const St
Standard_Boolean FSD_BinaryFile::IsEnd()
{
return (feof(myStream) != 0);
return !Device().IsNull() ? Device()->IsEnd() : Standard_True;
}
//=======================================================================
@@ -126,8 +134,9 @@ Storage_Error FSD_BinaryFile::Close()
Storage_Error result = Storage_VSOk;
if (OpenMode() != Storage_VSNone) {
fclose(myStream);
SetOpenMode(Storage_VSNone);
Device()->Close();
// fclose(myStream);
// SetOpenMode(Storage_VSNone);
}
else {
result = Storage_VSNotOpen;
@@ -159,7 +168,7 @@ void FSD_BinaryFile::ReadChar(TCollection_AsciiString& buffer, const Standard_Si
buffer.Clear();
while (!IsEnd() && (ccount < rsize)) {
fread(&c, sizeof(char),1, myStream);
Device()->Read((Standard_Address)&c, sizeof(char));
buffer += c;
ccount++;
}
@@ -182,13 +191,18 @@ void FSD_BinaryFile::SkipObject()
Storage_BaseDriver& FSD_BinaryFile::PutReference(const Standard_Integer aValue)
{
if ( Device().IsNull() )
Storage_StreamWriteError::Raise();
#if DO_INVERSE
Standard_Integer t = InverseInt (aValue);
if (!fwrite(&t,sizeof(Standard_Integer),1,myStream)) Storage_StreamWriteError::Raise();
#else
if (!fwrite(&aValue,sizeof(Standard_Integer),1,myStream)) Storage_StreamWriteError::Raise();
Standard_Integer t = aValue;
#endif
if ( Device()->Write( (Standard_Address)&t, sizeof(Standard_Integer) ) != sizeof(Standard_Integer) )
Storage_StreamWriteError::Raise();
return *this;
}
@@ -199,7 +213,11 @@ Storage_BaseDriver& FSD_BinaryFile::PutReference(const Standard_Integer aValue)
Storage_BaseDriver& FSD_BinaryFile::PutCharacter(const Standard_Character aValue)
{
if (!fwrite(&aValue,sizeof(Standard_Character),1,myStream)) Storage_StreamWriteError::Raise();
if ( Device().IsNull() )
Storage_StreamWriteError::Raise();
if ( Device()->Write((Standard_Address)&aValue,sizeof(Standard_Character)) != sizeof(Standard_Character) )
Storage_StreamWriteError::Raise();
return *this;
}
@@ -210,13 +228,18 @@ Storage_BaseDriver& FSD_BinaryFile::PutCharacter(const Standard_Character aValue
Storage_BaseDriver& FSD_BinaryFile::PutExtCharacter(const Standard_ExtCharacter aValue)
{
if ( Device().IsNull() )
Storage_StreamWriteError::Raise();
#if DO_INVERSE
Standard_ExtCharacter t = InverseExtChar (aValue);
if (!fwrite(&t,sizeof(Standard_ExtCharacter),1,myStream)) Storage_StreamWriteError::Raise();
#else
if (!fwrite(&aValue,sizeof(Standard_ExtCharacter),1,myStream)) Storage_StreamWriteError::Raise();
Standard_ExtCharacter t = aValue;
#endif
if ( Device()->Write((Standard_Address)&t, sizeof(Standard_ExtCharacter)) != sizeof(Standard_ExtCharacter) )
Storage_StreamWriteError::Raise();
return *this;
}
@@ -227,13 +250,17 @@ Storage_BaseDriver& FSD_BinaryFile::PutExtCharacter(const Standard_ExtCharacter
Storage_BaseDriver& FSD_BinaryFile::PutInteger(const Standard_Integer aValue)
{
if ( Device().IsNull() )
Storage_StreamWriteError::Raise();
#if DO_INVERSE
Standard_Integer t = InverseInt (aValue);
if (!fwrite(&t,sizeof(Standard_Integer),1,myStream)) Storage_StreamWriteError::Raise();
Standard_Integer t = InverseInt(aValue);
#else
if (!fwrite(&aValue,sizeof(Standard_Integer),1,myStream)) Storage_StreamWriteError::Raise();
Standard_Integer t = aValue;
#endif
if ( Device()->Write((Standard_Address)&t,sizeof(Standard_Integer)) != sizeof(Standard_Integer))
Storage_StreamWriteError::Raise();
return *this;
}
@@ -245,13 +272,18 @@ Storage_BaseDriver& FSD_BinaryFile::PutInteger(const Standard_Integer aValue)
Storage_BaseDriver& FSD_BinaryFile::PutBoolean(const Standard_Boolean aValue)
{
if ( Device().IsNull() )
Storage_StreamWriteError::Raise();
#if DO_INVERSE
Standard_Integer t = InverseInt ((Standard_Integer) aValue);
if (!fwrite(&t,sizeof(Standard_Integer),1,myStream)) Storage_StreamWriteError::Raise();
#else
if (!fwrite(&aValue,sizeof(Standard_Boolean),1,myStream)) Storage_StreamWriteError::Raise();
Standard_Integer t = (Standard_Integer)aValue;
#endif
if ( Device()->Write((Standard_Address)&t,sizeof(Standard_Integer)) != sizeof(Standard_Integer) )
Storage_StreamWriteError::Raise();
return *this;
}
@@ -262,13 +294,18 @@ Storage_BaseDriver& FSD_BinaryFile::PutBoolean(const Standard_Boolean aValue)
Storage_BaseDriver& FSD_BinaryFile::PutReal(const Standard_Real aValue)
{
if ( Device().IsNull() )
Storage_StreamWriteError::Raise();
#if DO_INVERSE
Standard_Real t = InverseReal (aValue);
if (!fwrite(&t,sizeof(Standard_Real),1,myStream)) Storage_StreamWriteError::Raise();
#else
if (!fwrite(&aValue,sizeof(Standard_Real),1,myStream)) Storage_StreamWriteError::Raise();
Standard_Real t = aValue;
#endif
if ( Device()->Write((Standard_Address)&t,sizeof(Standard_Real)) != sizeof(Standard_Real) )
Storage_StreamWriteError::Raise();
return *this;
}
@@ -279,13 +316,18 @@ Storage_BaseDriver& FSD_BinaryFile::PutReal(const Standard_Real aValue)
Storage_BaseDriver& FSD_BinaryFile::PutShortReal(const Standard_ShortReal aValue)
{
if ( Device().IsNull() )
Storage_StreamWriteError::Raise();
#if DO_INVERSE
Standard_ShortReal t = InverseShortReal (aValue);
if (!fwrite(&t,sizeof(Standard_ShortReal),1,myStream)) Storage_StreamWriteError::Raise();
#else
if (!fwrite(&aValue,sizeof(Standard_ShortReal),1,myStream)) Storage_StreamWriteError::Raise();
Standard_ShortReal t = aValue;
#endif
if ( Device()->Write((Standard_Address)&t,sizeof(Standard_ShortReal)) != sizeof(Standard_ShortReal) )
Storage_StreamWriteError::Raise();
return *this;
}
@@ -296,7 +338,10 @@ Storage_BaseDriver& FSD_BinaryFile::PutShortReal(const Standard_ShortReal aValue
Storage_BaseDriver& FSD_BinaryFile::GetReference(Standard_Integer& aValue)
{
if (!fread(&aValue,sizeof(Standard_Integer),1,myStream))
if ( Device().IsNull() )
Storage_StreamReadError::Raise();
if ( Device()->Read( (Standard_Address)&aValue,sizeof(Standard_Integer)) != sizeof(Standard_Integer) )
Storage_StreamTypeMismatchError::Raise();
#if DO_INVERSE
aValue = InverseInt (aValue);
@@ -311,8 +356,12 @@ Storage_BaseDriver& FSD_BinaryFile::GetReference(Standard_Integer& aValue)
Storage_BaseDriver& FSD_BinaryFile::GetCharacter(Standard_Character& aValue)
{
if (!fread(&aValue,sizeof(Standard_Character),1,myStream))
if ( Device().IsNull() )
Storage_StreamReadError::Raise();
if ( Device()->Read( (Standard_Address)&aValue,sizeof(Standard_Character)) != sizeof(Standard_Character) )
Storage_StreamTypeMismatchError::Raise();
return *this;
}
@@ -323,7 +372,10 @@ Storage_BaseDriver& FSD_BinaryFile::GetCharacter(Standard_Character& aValue)
Storage_BaseDriver& FSD_BinaryFile::GetExtCharacter(Standard_ExtCharacter& aValue)
{
if (!fread(&aValue,sizeof(Standard_ExtCharacter),1,myStream))
if ( Device().IsNull() )
Storage_StreamReadError::Raise();
if ( Device()->Read( (Standard_Address)&aValue,sizeof(Standard_ExtCharacter)) != sizeof(Standard_ExtCharacter) )
Storage_StreamTypeMismatchError::Raise();
#if DO_INVERSE
aValue = InverseExtChar (aValue);
@@ -338,7 +390,10 @@ Storage_BaseDriver& FSD_BinaryFile::GetExtCharacter(Standard_ExtCharacter& aValu
Storage_BaseDriver& FSD_BinaryFile::GetInteger(Standard_Integer& aValue)
{
if (!fread(&aValue,sizeof(Standard_Integer),1,myStream))
if ( Device().IsNull() )
Storage_StreamReadError::Raise();
if ( Device()->Read((Standard_Address)&aValue,sizeof(Standard_Integer)) != sizeof(Standard_Integer) )
Storage_StreamTypeMismatchError::Raise();
#if DO_INVERSE
aValue = InverseInt (aValue);
@@ -353,7 +408,10 @@ Storage_BaseDriver& FSD_BinaryFile::GetInteger(Standard_Integer& aValue)
Storage_BaseDriver& FSD_BinaryFile::GetBoolean(Standard_Boolean& aValue)
{
if (!fread(&aValue,sizeof(Standard_Boolean),1,myStream))
if ( Device().IsNull() )
Storage_StreamReadError::Raise();
if ( Device()->Read((Standard_Address)&aValue,sizeof(Standard_Boolean)) != sizeof(Standard_Boolean) )
Storage_StreamTypeMismatchError::Raise();
#if DO_INVERSE
aValue = InverseInt ((Standard_Integer) aValue);
@@ -368,7 +426,10 @@ Storage_BaseDriver& FSD_BinaryFile::GetBoolean(Standard_Boolean& aValue)
Storage_BaseDriver& FSD_BinaryFile::GetReal(Standard_Real& aValue)
{
if (!fread(&aValue,sizeof(Standard_Real),1,myStream))
if ( Device().IsNull() )
Storage_StreamReadError::Raise();
if ( Device()->Read((Standard_Address)&aValue,sizeof(Standard_Real)) != sizeof(Standard_Real))
Storage_StreamTypeMismatchError::Raise();
#if DO_INVERSE
aValue = InverseReal (aValue);
@@ -383,7 +444,10 @@ Storage_BaseDriver& FSD_BinaryFile::GetReal(Standard_Real& aValue)
Storage_BaseDriver& FSD_BinaryFile::GetShortReal(Standard_ShortReal& aValue)
{
if (!fread(&aValue,sizeof(Standard_ShortReal),1,myStream))
if ( Device().IsNull() )
Storage_StreamReadError::Raise();
if ( Device()->Read((Standard_Address)&aValue,sizeof(Standard_ShortReal)) != sizeof(Standard_ShortReal))
Storage_StreamTypeMismatchError::Raise();
#if DO_INVERSE
aValue = InverseShortReal (aValue);
@@ -416,13 +480,11 @@ Storage_Error FSD_BinaryFile::BeginWriteInfoSection()
ti[2] = 3;
ti[3] = 4;
myHeader.testindian = *((int*)ti);
if (!fwrite(FSD_BinaryFile::MagicNumber(),
strlen(FSD_BinaryFile::MagicNumber()),
1,
myStream))
Standard_Size aLen = strlen(FSD_BinaryFile::MagicNumber());
if ( Device()->Write( (Standard_Address)FSD_BinaryFile::MagicNumber(), aLen ) != aLen )
Storage_StreamWriteError::Raise();
myHeader.binfo = ftell(myStream);
myHeader.binfo = Device()->Tell();
WriteHeader();
return Storage_VSOk;
@@ -468,7 +530,7 @@ void FSD_BinaryFile::WriteInfo(const Standard_Integer nbObj,
Storage_Error FSD_BinaryFile::EndWriteInfoSection()
{
myHeader.einfo = ftell(myStream);
myHeader.einfo = Device()->Tell();
return Storage_VSOk;
}
@@ -539,8 +601,10 @@ void FSD_BinaryFile::ReadInfo(Standard_Integer& nbObj,
Storage_Error FSD_BinaryFile::EndReadInfoSection()
{
if (!fseek(myStream,myHeader.einfo,SEEK_SET)) return Storage_VSOk;
else return Storage_VSSectionNotFound;
if ( Device()->Seek(myHeader.einfo))
return Storage_VSOk;
else
return Storage_VSSectionNotFound;
}
//=======================================================================
@@ -550,7 +614,7 @@ Storage_Error FSD_BinaryFile::EndReadInfoSection()
Storage_Error FSD_BinaryFile::BeginWriteCommentSection()
{
myHeader.bcomment = ftell(myStream);
myHeader.bcomment = Device()->Tell();
return Storage_VSOk;
}
@@ -577,7 +641,7 @@ void FSD_BinaryFile::WriteComment(const TColStd_SequenceOfExtendedString& aCom)
Storage_Error FSD_BinaryFile::EndWriteCommentSection()
{
myHeader.ecomment = ftell(myStream);
myHeader.ecomment = Device()->Tell();
return Storage_VSOk;
}
@@ -589,8 +653,10 @@ Storage_Error FSD_BinaryFile::EndWriteCommentSection()
Storage_Error FSD_BinaryFile::BeginReadCommentSection()
{
if (!fseek(myStream,myHeader.bcomment,SEEK_SET)) return Storage_VSOk;
else return Storage_VSSectionNotFound;
if ( Device()->Seek(myHeader.bcomment) )
return Storage_VSOk;
else
return Storage_VSSectionNotFound;
}
//=======================================================================
@@ -617,8 +683,10 @@ void FSD_BinaryFile::ReadComment(TColStd_SequenceOfExtendedString& aCom)
Storage_Error FSD_BinaryFile::EndReadCommentSection()
{
if (!fseek(myStream,myHeader.ecomment,SEEK_SET)) return Storage_VSOk;
else return Storage_VSSectionNotFound;
if ( Device()->Seek(myHeader.ecomment) )
return Storage_VSOk;
else
return Storage_VSSectionNotFound;
}
//=======================================================================
@@ -628,7 +696,7 @@ Storage_Error FSD_BinaryFile::EndReadCommentSection()
Storage_Error FSD_BinaryFile::BeginWriteTypeSection()
{
myHeader.btype = ftell(myStream);
myHeader.btype = Device()->Tell();
return Storage_VSOk;
}
@@ -662,7 +730,7 @@ void FSD_BinaryFile::WriteTypeInformations(const Standard_Integer typeNum,
Storage_Error FSD_BinaryFile::EndWriteTypeSection()
{
myHeader.etype = ftell(myStream);
myHeader.etype = Device()->Tell();
return Storage_VSOk;
}
@@ -674,8 +742,10 @@ Storage_Error FSD_BinaryFile::EndWriteTypeSection()
Storage_Error FSD_BinaryFile::BeginReadTypeSection()
{
if (!fseek(myStream,myHeader.btype,SEEK_SET)) return Storage_VSOk;
else return Storage_VSSectionNotFound;
if ( Device()->Seek(myHeader.btype) )
return Storage_VSOk;
else
return Storage_VSSectionNotFound;
}
//=======================================================================
@@ -710,8 +780,10 @@ void FSD_BinaryFile::ReadTypeInformations(Standard_Integer& typeNum,TCollection_
Storage_Error FSD_BinaryFile::EndReadTypeSection()
{
if (!fseek(myStream,myHeader.etype,SEEK_SET)) return Storage_VSOk;
else return Storage_VSSectionNotFound;
if ( Device()->Seek(myHeader.etype) )
return Storage_VSOk;
else
return Storage_VSSectionNotFound;
}
//=======================================================================
@@ -721,7 +793,7 @@ Storage_Error FSD_BinaryFile::EndReadTypeSection()
Storage_Error FSD_BinaryFile::BeginWriteRootSection()
{
myHeader.broot = ftell(myStream);
myHeader.broot = Device()->Tell();
return Storage_VSOk;
}
@@ -755,7 +827,7 @@ void FSD_BinaryFile::WriteRoot(const TCollection_AsciiString& rootName, const St
Storage_Error FSD_BinaryFile::EndWriteRootSection()
{
myHeader.eroot = ftell(myStream);
myHeader.eroot = Device()->Tell();
return Storage_VSOk;
}
@@ -767,8 +839,10 @@ Storage_Error FSD_BinaryFile::EndWriteRootSection()
Storage_Error FSD_BinaryFile::BeginReadRootSection()
{
if (!fseek(myStream,myHeader.broot,SEEK_SET)) return Storage_VSOk;
else return Storage_VSSectionNotFound;
if ( Device()->Seek(myHeader.broot) )
return Storage_VSOk;
else
return Storage_VSSectionNotFound;
}
//=======================================================================
@@ -804,8 +878,10 @@ void FSD_BinaryFile::ReadRoot(TCollection_AsciiString& rootName, Standard_Intege
Storage_Error FSD_BinaryFile::EndReadRootSection()
{
if (!fseek(myStream,myHeader.eroot,SEEK_SET)) return Storage_VSOk;
else return Storage_VSSectionNotFound;
if ( Device()->Seek(myHeader.eroot) )
return Storage_VSOk;
else
return Storage_VSSectionNotFound;
}
//=======================================================================
@@ -815,7 +891,7 @@ Storage_Error FSD_BinaryFile::EndReadRootSection()
Storage_Error FSD_BinaryFile::BeginWriteRefSection()
{
myHeader.bref = ftell(myStream);
myHeader.bref = Device()->Tell();
return Storage_VSOk;
}
@@ -848,7 +924,7 @@ void FSD_BinaryFile::WriteReferenceType(const Standard_Integer reference,const S
Storage_Error FSD_BinaryFile::EndWriteRefSection()
{
myHeader.eref = ftell(myStream);
myHeader.eref = Device()->Tell();
return Storage_VSOk;
}
@@ -860,8 +936,10 @@ Storage_Error FSD_BinaryFile::EndWriteRefSection()
Storage_Error FSD_BinaryFile::BeginReadRefSection()
{
if (!fseek(myStream,myHeader.bref,SEEK_SET)) return Storage_VSOk;
else return Storage_VSSectionNotFound;
if ( Device()->Seek(myHeader.bref) )
return Storage_VSOk;
else
return Storage_VSSectionNotFound;
}
//=======================================================================
@@ -897,8 +975,10 @@ void FSD_BinaryFile::ReadReferenceType(Standard_Integer& reference,
Storage_Error FSD_BinaryFile::EndReadRefSection()
{
if (!fseek(myStream,myHeader.eref,SEEK_SET)) return Storage_VSOk;
else return Storage_VSSectionNotFound;
if ( Device()->Seek(myHeader.eref) )
return Storage_VSOk;
else
return Storage_VSSectionNotFound;
}
//=======================================================================
@@ -908,7 +988,7 @@ Storage_Error FSD_BinaryFile::EndReadRefSection()
Storage_Error FSD_BinaryFile::BeginWriteDataSection()
{
myHeader.bdata = ftell(myStream);
myHeader.bdata = Device()->Tell();
return Storage_VSOk;
}
@@ -968,9 +1048,9 @@ void FSD_BinaryFile::EndWritePersistentObjectData()
Storage_Error FSD_BinaryFile::EndWriteDataSection()
{
myHeader.edata = ftell(myStream);
myHeader.edata = Device()->Tell();
fseek(myStream,myHeader.binfo,SEEK_SET);
Device()->Seek(myHeader.binfo);
WriteHeader();
return Storage_VSOk;
}
@@ -982,8 +1062,10 @@ Storage_Error FSD_BinaryFile::EndWriteDataSection()
Storage_Error FSD_BinaryFile::BeginReadDataSection()
{
if (!fseek(myStream,myHeader.bdata,SEEK_SET)) return Storage_VSOk;
else return Storage_VSSectionNotFound;
if ( Device()->Seek(myHeader.bdata) )
return Storage_VSOk;
else
return Storage_VSSectionNotFound;
}
//=======================================================================
@@ -1041,8 +1123,10 @@ void FSD_BinaryFile::EndReadPersistentObjectData()
Storage_Error FSD_BinaryFile::EndReadDataSection()
{
if (!fseek(myStream,myHeader.edata,SEEK_SET)) return Storage_VSOk;
else return Storage_VSSectionNotFound;
if ( Device()->Seek(myHeader.edata) )
return Storage_VSOk;
else
return Storage_VSSectionNotFound;
}
//=======================================================================
@@ -1059,7 +1143,8 @@ void FSD_BinaryFile::WriteString(const TCollection_AsciiString& aString)
PutInteger(size);
if (size > 0) {
if (!fwrite(aString.ToCString(),aString.Length(),1,myStream)) Storage_StreamWriteError::Raise();
if ( Device().IsNull() || Device()->Write((Standard_Address)aString.ToCString(),size) != (Standard_Size)size )
Storage_StreamWriteError::Raise();
}
}
@@ -1075,7 +1160,8 @@ void FSD_BinaryFile::ReadString(TCollection_AsciiString& aString)
GetInteger(size);
if (size > 0) {
Standard_Character *c = (Standard_Character *)Standard::Allocate((size+1) * sizeof(Standard_Character));
if (!fread(c,size,1,myStream)) Storage_StreamWriteError::Raise();
if ( Device().IsNull() || Device()->Read((Standard_Address)c,size) != (Standard_Size)size )
Storage_StreamReadError::Raise();
c[size] = '\0';
aString = c;
Standard::Free(c);
@@ -1113,7 +1199,8 @@ void FSD_BinaryFile::WriteExtendedString(const TCollection_ExtendedString& aStri
#else
anExtStr = aString.ToExtString();
#endif
if (!fwrite(anExtStr,sizeof(Standard_ExtCharacter)*aString.Length(),1,myStream))
Standard_Size aSize = sizeof(Standard_ExtCharacter)*aString.Length();
if ( Device().IsNull() || Device()->Write((Standard_Address)anExtStr,aSize) != aSize )
Storage_StreamWriteError::Raise();
}
}
@@ -1131,7 +1218,7 @@ void FSD_BinaryFile::ReadExtendedString(TCollection_ExtendedString& aString)
if (size > 0) {
Standard_ExtCharacter *c = (Standard_ExtCharacter *)
Standard::Allocate((size+1) * sizeof(Standard_ExtCharacter));
if (!fread(c,size*sizeof(Standard_ExtCharacter),1,myStream))
if ( Device().IsNull() || Device()->Read((Standard_Address)c,size*sizeof(Standard_ExtCharacter)) != size*sizeof(Standard_ExtCharacter) )
Storage_StreamWriteError::Raise();
c[size] = '\0';
#if DO_INVERSE
@@ -1198,5 +1285,5 @@ void FSD_BinaryFile::ReadHeader()
Storage_Position FSD_BinaryFile::Tell()
{
return (Storage_Position) ftell(myStream);
return Device()->Tell();
}

11
src/FSD/FSD_CmpFile.cdl
View File

@@ -21,6 +21,7 @@ inherits BaseDriver from Storage
uses Position from Storage,
Error from Storage,
OpenMode from Storage,
IODevice from Storage,
AsciiString from TCollection,
SequenceOfAsciiString from TColStd,
SequenceOfExtendedString from TColStd,
@@ -35,15 +36,16 @@ raises StreamTypeMismatchError from Storage,
is
Create returns CmpFile from FSD;
Open(me : in out; aName : AsciiString from TCollection; aMode : OpenMode from Storage) returns Error from Storage;
Open(me : in out; aDevice : IODevice from Storage; aMode : OpenMode from Storage)
returns Error from Storage is redefined;
IsEnd(me : in out) returns Boolean from Standard;
Tell( me : in out ) returns Position from Storage;
---Purpose: return position in the file. Return -1 upon error.
IsGoodFileType(myclass; aName : AsciiString from TCollection)
returns Error from Storage;
IsGoodFileType(myclass; aDevice : IODevice from Storage)
returns Error from Storage;
-- INFO SECTION
-- write
@@ -303,6 +305,9 @@ is
raises StreamExtCharParityError
is protected;
---Purpose: read extended chars (unicode) from the current position to the end of line.
WriteLine(me : in out; buffer : AsciiString from TCollection; putNewLine: Boolean from Standard = Standard_True) is protected;
---Purpose: write the line.
WriteExtendedLine(me : in out; buffer : ExtendedString from TCollection) is protected;
---Purpose: write from the current position to the end of line.

433
src/FSD/FSD_CmpFile.cxx
View File

@@ -37,12 +37,12 @@ FSD_CmpFile::FSD_CmpFile()
// write
//=======================================================================
Storage_Error FSD_CmpFile::IsGoodFileType(const TCollection_AsciiString& aName)
Storage_Error FSD_CmpFile::IsGoodFileType(const Handle(Storage_IODevice)& aDevice)
{
FSD_CmpFile f;
Storage_Error s;
s = f.Open(aName,Storage_VSRead);
s = f.Open(aDevice,Storage_VSRead);
if (s == Storage_VSOk) {
TCollection_AsciiString l;
@@ -65,8 +65,16 @@ Storage_Error FSD_CmpFile::IsGoodFileType(const TCollection_AsciiString& aName)
//purpose :
//=======================================================================
Storage_Error FSD_CmpFile::Open(const TCollection_AsciiString& aName,const Storage_OpenMode aMode)
Storage_Error FSD_CmpFile::Open(const Handle(Storage_IODevice)& aDevice,const Storage_OpenMode aMode)
{
SetDevice(aDevice);
if ( Device().IsNull() )
return Storage_VSOpenError;
return Device()->Open(aMode);
/*
Storage_Error result = Storage_VSOk;
SetName(aName);
@@ -119,6 +127,7 @@ Storage_Error FSD_CmpFile::Open(const TCollection_AsciiString& aName,const Stora
result = Storage_VSAlreadyOpen;
}
return result;
*/
}
//=======================================================================
@@ -128,7 +137,7 @@ Storage_Error FSD_CmpFile::Open(const TCollection_AsciiString& aName,const Stora
Standard_Boolean FSD_CmpFile::IsEnd()
{
return myStream.eof();
return !Device().IsNull() ? Device()->IsEnd() : Standard_True;
}
//=======================================================================
@@ -141,8 +150,7 @@ Storage_Error FSD_CmpFile::Close()
Storage_Error result = Storage_VSOk;
if (OpenMode() != Storage_VSNone) {
myStream.close();
SetOpenMode(Storage_VSNone);
Device()->Close();
}
else {
result = Storage_VSNotOpen;
@@ -188,6 +196,22 @@ void FSD_CmpFile::FlushEndOfLine()
*/
}
//=======================================================================
//function : WriteLine
//purpose : write the line.
//=======================================================================
void FSD_CmpFile::WriteLine(const TCollection_AsciiString& aStr, const Standard_Boolean putNewLine)
{
TCollection_AsciiString buffer = aStr;
if ( putNewLine )
buffer += TCollection_AsciiString("\n");
if ( Device()->Write( (Standard_Address)buffer.ToCString(), buffer.Length() ) != (Standard_Size)buffer.Length() )
Storage_StreamWriteError::Raise();
}
//=======================================================================
//function : ReadLine
//purpose : read from the current position to the end of line.
@@ -195,30 +219,25 @@ void FSD_CmpFile::FlushEndOfLine()
void FSD_CmpFile::ReadLine(TCollection_AsciiString& buffer)
{
char Buffer[8193];
//char c;
Standard_Boolean IsEnd = Standard_False;
buffer.Clear();
while (!IsEnd && !FSD_CmpFile::IsEnd()) {
Buffer[0] = '\0';
//myStream.get(Buffer,8192,'\n');
myStream.getline(Buffer,8192,'\n');
for (Standard_Size lv = (strlen(Buffer)- 1); lv > 1 && (Buffer[lv] == '\r' || Buffer[lv] == '\n') ;lv--) {
Buffer[lv] = '\0';
while (!IsEnd && !FSD_CmpFile::IsEnd())
{
Standard_Character c;
Device()->Read( (Standard_Address)&c, 1 );
if ( c != '\n' && c != '\r')
{
buffer += c;
}
// if (myStream.get(c) && c != '\r' && c != '\n') {
// buffer += Buffer;
// buffer += c;
// }
// else {
buffer += Buffer;
else
{
buffer += '\0';
IsEnd = Standard_True;
// }
}
}
}
//=======================================================================
//function : WriteExtendedLine
@@ -227,21 +246,6 @@ void FSD_CmpFile::ReadLine(TCollection_AsciiString& buffer)
void FSD_CmpFile::WriteExtendedLine(const TCollection_ExtendedString& buffer)
{
#if 0
Standard_ExtString extBuffer;
Standard_Integer i,c,d;
extBuffer = buffer.ToExtString();
for (i = 0; i < buffer.Length(); i++) {
c = (extBuffer[i] & 0x0000FF00 ) >> 8 ;
d = extBuffer[i] & 0x000000FF;
myStream << (char)c << (char)d;
}
myStream << (char)0 << "\n";
#endif
Standard_ExtString extBuffer;
Standard_Integer i;
@@ -251,7 +255,7 @@ void FSD_CmpFile::WriteExtendedLine(const TCollection_ExtendedString& buffer)
PutExtCharacter(extBuffer[i]);
}
myStream << "\n";
Device()->Write((Standard_Address)"\n", 1);
}
//=======================================================================
@@ -287,7 +291,7 @@ void FSD_CmpFile::ReadChar(TCollection_AsciiString& buffer, const Standard_Size
buffer.Clear();
while (!IsEnd() && (ccount < rsize)) {
myStream.get(c);
Device()->Read( (Standard_Address)&c, sizeof( char ) );
buffer += c;
ccount++;
}
@@ -300,38 +304,37 @@ void FSD_CmpFile::ReadChar(TCollection_AsciiString& buffer, const Standard_Size
void FSD_CmpFile::ReadString(TCollection_AsciiString& buffer)
{
char Buffer[8193];
char *bpos;
Standard_Boolean IsEnd = Standard_False,isFirstTime = Standard_True;
buffer.Clear();
while (!IsEnd && !FSD_CmpFile::IsEnd()) {
Buffer[0] = '\0';
//myStream.get(Buffer,8192,'\n');
myStream.getline(Buffer,8192,'\n');
for (Standard_Size lv = (strlen(Buffer)- 1); lv > 1 && (Buffer[lv] == '\r' || Buffer[lv] == '\n') ;lv--) {
Buffer[lv] = '\0';
while (!IsEnd && !FSD_CmpFile::IsEnd())
{
char c;
Device()->Read((Standard_Address)&c, sizeof(c));
if (isFirstTime)
{
if (c == '\n' || c == ' ')
{
continue;
}
bpos = Buffer;
// LeftAdjust
//
if (isFirstTime) {
else
{
isFirstTime = Standard_False;
while (*bpos == '\n' || *bpos == ' ') bpos++;
}
// char c;
// if (myStream.get(c) && c != '\n') {
// buffer += bpos;
// buffer += c;
// }
// else {
buffer += bpos;
}
if (c != '\n')
{
buffer += c;
}
else
{
buffer += '\0';
IsEnd = Standard_True;
// }
}
}
}
//=======================================================================
//function : ReadWord
@@ -350,8 +353,11 @@ void FSD_CmpFile::ReadWord(TCollection_AsciiString& buffer)
buffer.Clear();
while (!IsEnd && !FSD_CmpFile::IsEnd()) {
myStream.get(c);
if ((c != ' ') && (c != '\n')) IsEnd = Standard_True;
Device()->Read( (Standard_Address)&c, sizeof(char) );
if ((c != ' ') && (c != '\n'))
{
IsEnd = Standard_True;
}
}
IsEnd = Standard_False;
@@ -366,8 +372,11 @@ void FSD_CmpFile::ReadWord(TCollection_AsciiString& buffer)
}
*tmpb = c;
tmpb++; i++;
myStream.get(c);
if ((c == '\n') || (c == ' ')) IsEnd = Standard_True;
Device()->Read( (Standard_Address)&c, sizeof(char) );
if ((c == '\n') || (c == ' '))
{
IsEnd = Standard_True;
}
}
buffer += b;
@@ -413,8 +422,9 @@ void FSD_CmpFile::SkipObject()
Storage_BaseDriver& FSD_CmpFile::PutReference(const Standard_Integer aValue)
{
myStream << aValue << " ";
if (myStream.bad()) Storage_StreamWriteError::Raise();
TCollection_AsciiString aStr = TCollection_AsciiString( aValue ) + " ";
if ( Device()->Write( (Standard_Address)aStr.ToCString(), aStr.Length() ) != (Standard_Size)aStr.Length() )
Storage_StreamWriteError::Raise();
return *this;
}
@@ -425,11 +435,11 @@ Storage_BaseDriver& FSD_CmpFile::PutReference(const Standard_Integer aValue)
Storage_BaseDriver& FSD_CmpFile::PutCharacter(const Standard_Character aValue)
{
unsigned short i;
Standard_Integer i = aValue;
TCollection_AsciiString aStr = TCollection_AsciiString( i ) + " ";
if ( Device()->Write( (Standard_Address)aStr.ToCString(), aStr.Length() ) != (Standard_Size)aStr.Length() )
Storage_StreamWriteError::Raise();
i = aValue;
myStream << i << " ";
if (myStream.bad()) Storage_StreamWriteError::Raise();
return *this;
}
@@ -440,8 +450,11 @@ Storage_BaseDriver& FSD_CmpFile::PutCharacter(const Standard_Character aValue)
Storage_BaseDriver& FSD_CmpFile::PutExtCharacter(const Standard_ExtCharacter aValue)
{
myStream << aValue << " ";
if (myStream.bad()) Storage_StreamWriteError::Raise();
Standard_Integer i = aValue;
TCollection_AsciiString aStr = TCollection_AsciiString( i ) + " ";
if ( Device()->Write( (Standard_Address)aStr.ToCString(), aStr.Length() ) != (Standard_Size)aStr.Length() )
Storage_StreamWriteError::Raise();
return *this;
}
@@ -452,8 +465,10 @@ Storage_BaseDriver& FSD_CmpFile::PutExtCharacter(const Standard_ExtCharacter aVa
Storage_BaseDriver& FSD_CmpFile::PutInteger(const Standard_Integer aValue)
{
myStream << aValue << " ";
if (myStream.bad()) Storage_StreamWriteError::Raise();
TCollection_AsciiString aStr = TCollection_AsciiString( aValue ) + " ";
if ( Device()->Write( (Standard_Address)aStr.ToCString(), aStr.Length() ) != (Standard_Size)aStr.Length() )
Storage_StreamWriteError::Raise();
return *this;
}
@@ -464,8 +479,10 @@ Storage_BaseDriver& FSD_CmpFile::PutInteger(const Standard_Integer aValue)
Storage_BaseDriver& FSD_CmpFile::PutBoolean(const Standard_Boolean aValue)
{
myStream << ((Standard_Integer)aValue) << " ";
if (myStream.bad()) Storage_StreamWriteError::Raise();
TCollection_AsciiString aStr = TCollection_AsciiString( (Standard_Integer)aValue ) + " ";
if ( Device()->Write( (Standard_Address)aStr.ToCString(), aStr.Length() ) != (Standard_Size)aStr.Length() )
Storage_StreamWriteError::Raise();
return *this;
}
@@ -476,8 +493,10 @@ Storage_BaseDriver& FSD_CmpFile::PutBoolean(const Standard_Boolean aValue)
Storage_BaseDriver& FSD_CmpFile::PutReal(const Standard_Real aValue)
{
myStream << ((Standard_Real)aValue) << " ";
if (myStream.bad()) Storage_StreamWriteError::Raise();
TCollection_AsciiString aStr = TCollection_AsciiString( aValue ) + " ";
if ( Device()->Write( (Standard_Address)aStr.ToCString(), aStr.Length() ) != (Standard_Size)aStr.Length() )
Storage_StreamWriteError::Raise();
return *this;
}
@@ -488,8 +507,10 @@ Storage_BaseDriver& FSD_CmpFile::PutReal(const Standard_Real aValue)
Storage_BaseDriver& FSD_CmpFile::PutShortReal(const Standard_ShortReal aValue)
{
myStream << aValue << " ";
if (myStream.bad()) Storage_StreamWriteError::Raise();
TCollection_AsciiString aStr = TCollection_AsciiString( aValue ) + " ";
if ( Device()->Write( (Standard_Address)aStr.ToCString(), aStr.Length() ) != (Standard_Size)aStr.Length() )
Storage_StreamWriteError::Raise();
return *this;
}
@@ -500,7 +521,12 @@ Storage_BaseDriver& FSD_CmpFile::PutShortReal(const Standard_ShortReal aValue)
Storage_BaseDriver& FSD_CmpFile::GetReference(Standard_Integer& aValue)
{
if (!(myStream >> aValue)) Storage_StreamTypeMismatchError::Raise();
TCollection_AsciiString aStr;
ReadWord( aStr );
if ( aStr.IsIntegerValue() )
aValue = aStr.IntegerValue();
else
Storage_StreamTypeMismatchError::Raise();
return *this;
}
@@ -513,13 +539,13 @@ Storage_BaseDriver& FSD_CmpFile::GetReference(Standard_Integer& aValue)
Storage_BaseDriver& FSD_CmpFile::GetCharacter(Standard_Character& aValue)
{
unsigned short i = 0;
if (!(myStream >> i)) {
// SGI : donne une erreur mais a une bonne valeur pour les caracteres ecrits
// signes (-80 fait ios::badbit, mais la variable i est initialisee)
//
if (i == 0) Storage_StreamTypeMismatchError::Raise();
myStream.clear(ios::goodbit);
}
TCollection_AsciiString aStr;
ReadWord( aStr );
if ( aStr.IsIntegerValue() )
i = (unsigned short)aStr.IntegerValue();
else
Storage_StreamTypeMismatchError::Raise();
aValue = (char)i;
return *this;
@@ -532,7 +558,15 @@ Storage_BaseDriver& FSD_CmpFile::GetCharacter(Standard_Character& aValue)
Storage_BaseDriver& FSD_CmpFile::GetExtCharacter(Standard_ExtCharacter& aValue)
{
if (!(myStream >> aValue)) Storage_StreamTypeMismatchError::Raise();
unsigned short i = 0;
TCollection_AsciiString aStr;
ReadWord( aStr );
if ( aStr.IsIntegerValue() )
i = (unsigned short)aStr.IntegerValue();
else
Storage_StreamTypeMismatchError::Raise();
aValue = (Standard_ExtCharacter)i;
return *this;
}
@@ -544,7 +578,12 @@ Storage_BaseDriver& FSD_CmpFile::GetExtCharacter(Standard_ExtCharacter& aValue)
Storage_BaseDriver& FSD_CmpFile::GetInteger(Standard_Integer& aValue)
{
if (!(myStream >> aValue)) Storage_StreamTypeMismatchError::Raise();
TCollection_AsciiString aStr;
ReadWord( aStr );
if ( aStr.IsIntegerValue() )
aValue = aStr.IntegerValue();
else
Storage_StreamTypeMismatchError::Raise();
return *this;
}
@@ -556,7 +595,12 @@ Storage_BaseDriver& FSD_CmpFile::GetInteger(Standard_Integer& aValue)
Storage_BaseDriver& FSD_CmpFile::GetBoolean(Standard_Boolean& aValue)
{
if (!(myStream >> aValue)) Storage_StreamTypeMismatchError::Raise();
TCollection_AsciiString aStr;
ReadWord( aStr );
if ( aStr.IsIntegerValue() )
aValue = (Standard_Boolean)aStr.IntegerValue();
else
Storage_StreamTypeMismatchError::Raise();
return *this;
}
@@ -568,23 +612,12 @@ Storage_BaseDriver& FSD_CmpFile::GetBoolean(Standard_Boolean& aValue)
Storage_BaseDriver& FSD_CmpFile::GetReal(Standard_Real& aValue)
{
char realbuffer[100];
realbuffer[0] = '\0';
if (!(myStream >> realbuffer)) {
#ifdef OCCT_DEBUG
cerr << "%%%ERROR: read error of double at offset " << myStream.tellg() << endl;
cerr << "\t buffer is" << realbuffer<< endl;
#endif
TCollection_AsciiString aStr;
ReadWord( aStr );
if ( aStr.IsRealValue() )
aValue = aStr.RealValue();
else
Storage_StreamTypeMismatchError::Raise();
}
if (!OSD::CStringToReal(realbuffer,aValue)) {
#ifdef OCCT_DEBUG
cerr << "%%%ERROR: read error of double at offset " << myStream.tellg() << endl;
cerr << "\t buffer is" << realbuffer<< endl;
#endif
Storage_StreamTypeMismatchError::Raise();
}
return *this;
}
@@ -596,16 +629,13 @@ Storage_BaseDriver& FSD_CmpFile::GetReal(Standard_Real& aValue)
Storage_BaseDriver& FSD_CmpFile::GetShortReal(Standard_ShortReal& aValue)
{
char realbuffer[100];
Standard_Real r = 0.0;
realbuffer[0] = '\0';
if (!(myStream >> realbuffer)) Storage_StreamTypeMismatchError::Raise();
if (!OSD::CStringToReal(realbuffer,r))
TCollection_AsciiString aStr;
ReadWord( aStr );
if ( aStr.IsRealValue() )
aValue = (Standard_ShortReal)aStr.RealValue();
else
Storage_StreamTypeMismatchError::Raise();
aValue = (Standard_ShortReal)r;
return *this;
}
@@ -628,9 +658,8 @@ void FSD_CmpFile::Destroy()
Storage_Error FSD_CmpFile::BeginWriteInfoSection()
{
myStream << FSD_CmpFile::MagicNumber() << '\n';
myStream << "BEGIN_INFO_SECTION\n";
if (myStream.bad()) Storage_StreamWriteError::Raise();
WriteLine( FSD_CmpFile::MagicNumber() );
WriteLine( "BEGIN_INFO_SECTION" );
return Storage_VSOk;
}
@@ -652,24 +681,21 @@ void FSD_CmpFile::WriteInfo(const Standard_Integer nbObj,
{
Standard_Integer i;
myStream << nbObj;
myStream << "\n";
myStream << dbVersion.ToCString() << "\n";
myStream << date.ToCString() << "\n";
myStream << schemaName.ToCString() << "\n";
myStream << schemaVersion.ToCString() << "\n";
PutInteger( nbObj );
WriteLine( "" );
WriteLine( dbVersion );
WriteLine( date );
WriteLine( schemaName );
WriteLine( schemaVersion );
WriteExtendedLine(appName);
myStream << appVersion.ToCString() << "\n";
WriteLine( appVersion );
WriteExtendedLine(dataType);
myStream << userInfo.Length() << "\n";
PutInteger( userInfo.Length() );
WriteLine( "" );
if (myStream.bad()) Storage_StreamWriteError::Raise();
for (i = 1; i <= userInfo.Length(); i++) {
myStream << userInfo.Value(i).ToCString() << "\n";
if (myStream.bad()) Storage_StreamWriteError::Raise();
for (i = 1; i <= userInfo.Length(); i++)
WriteLine( userInfo.Value(i) );
}
}
//=======================================================================
//function : EndWriteInfoSection
@@ -678,8 +704,7 @@ void FSD_CmpFile::WriteInfo(const Standard_Integer nbObj,
Storage_Error FSD_CmpFile::EndWriteInfoSection()
{
myStream << "END_INFO_SECTION\n";
if (myStream.bad()) Storage_StreamWriteError::Raise();
WriteLine( "END_INFO_SECTION" );
return Storage_VSOk;
}
@@ -721,7 +746,7 @@ void FSD_CmpFile::ReadInfo(Standard_Integer& nbObj,
TCollection_ExtendedString& dataType,
TColStd_SequenceOfAsciiString& userInfo)
{
if (!(myStream >> nbObj)) Storage_StreamTypeMismatchError::Raise();
GetInteger( nbObj );
FlushEndOfLine();
@@ -735,7 +760,7 @@ void FSD_CmpFile::ReadInfo(Standard_Integer& nbObj,
Standard_Integer i,len = 0;
if (!(myStream >> len)) Storage_StreamTypeMismatchError::Raise();
GetInteger( len );
FlushEndOfLine();
@@ -766,8 +791,8 @@ Storage_Error FSD_CmpFile::EndReadInfoSection()
Storage_Error FSD_CmpFile::BeginWriteCommentSection()
{
myStream << "BEGIN_COMMENT_SECTION\n";
if (myStream.bad()) Storage_StreamWriteError::Raise();
WriteLine( "BEGIN_COMMENT_SECTION" );
return Storage_VSOk;
}
@@ -781,12 +806,10 @@ void FSD_CmpFile::WriteComment(const TColStd_SequenceOfExtendedString& aCom)
Standard_Integer i,aSize;
aSize = aCom.Length();
myStream << aSize << "\n";
if (myStream.bad()) Storage_StreamWriteError::Raise();
WriteLine (aSize);
for (i = 1; i <= aSize; i++) {
WriteExtendedLine(aCom.Value(i));
if (myStream.bad()) Storage_StreamWriteError::Raise();
}
}
@@ -797,8 +820,8 @@ void FSD_CmpFile::WriteComment(const TColStd_SequenceOfExtendedString& aCom)
Storage_Error FSD_CmpFile::EndWriteCommentSection()
{
myStream << "END_COMMENT_SECTION\n";
if (myStream.bad()) Storage_StreamWriteError::Raise();
WriteLine ("END_COMMENT_SECTION");
return Storage_VSOk;
}
@@ -822,7 +845,7 @@ void FSD_CmpFile::ReadComment(TColStd_SequenceOfExtendedString& aCom)
TCollection_ExtendedString line;
Standard_Integer len,i;
if (!(myStream >> len)) Storage_StreamTypeMismatchError::Raise();
GetInteger (len);
FlushEndOfLine();
@@ -850,8 +873,8 @@ Storage_Error FSD_CmpFile::EndReadCommentSection()
Storage_Error FSD_CmpFile::BeginWriteTypeSection()
{
myStream << "BEGIN_TYPE_SECTION\n";
if (myStream.bad()) Storage_StreamWriteError::Raise();
WriteLine ("BEGIN_TYPE_SECTION");
return Storage_VSOk;
}
@@ -862,8 +885,7 @@ Storage_Error FSD_CmpFile::BeginWriteTypeSection()
void FSD_CmpFile::SetTypeSectionSize(const Standard_Integer aSize)
{
myStream << aSize << "\n";
if (myStream.bad()) Storage_StreamWriteError::Raise();
WriteLine (aSize);
}
//=======================================================================
@@ -874,8 +896,8 @@ void FSD_CmpFile::SetTypeSectionSize(const Standard_Integer aSize)
void FSD_CmpFile::WriteTypeInformations(const Standard_Integer typeNum,
const TCollection_AsciiString& typeName)
{
myStream << typeNum << " " << typeName.ToCString() << "\n";
if (myStream.bad()) Storage_StreamWriteError::Raise();
TCollection_AsciiString aLine;
WriteLine (aLine + typeNum + " " + typeName.ToCString());
}
//=======================================================================
@@ -885,8 +907,8 @@ void FSD_CmpFile::WriteTypeInformations(const Standard_Integer typeNum,
Storage_Error FSD_CmpFile::EndWriteTypeSection()
{
myStream << "END_TYPE_SECTION\n";
if (myStream.bad()) Storage_StreamWriteError::Raise();
WriteLine ("END_TYPE_SECTION");
return Storage_VSOk;
}
@@ -909,7 +931,7 @@ Standard_Integer FSD_CmpFile::TypeSectionSize()
{
Standard_Integer i;
if (!(myStream >> i)) Storage_StreamTypeMismatchError::Raise();
GetInteger (i);
FlushEndOfLine();
@@ -924,8 +946,8 @@ Standard_Integer FSD_CmpFile::TypeSectionSize()
void FSD_CmpFile::ReadTypeInformations(Standard_Integer& typeNum,
TCollection_AsciiString& typeName)
{
if (!(myStream >> typeNum)) Storage_StreamTypeMismatchError::Raise();
if (!(myStream >> typeName)) Storage_StreamTypeMismatchError::Raise();
GetInteger (typeNum);
ReadLine(typeName);
FlushEndOfLine();
}
@@ -947,8 +969,8 @@ Storage_Error FSD_CmpFile::EndReadTypeSection()
Storage_Error FSD_CmpFile::BeginWriteRootSection()
{
myStream << "BEGIN_ROOT_SECTION\n";
if (myStream.bad()) Storage_StreamWriteError::Raise();
WriteLine ("BEGIN_ROOT_SECTION");
return Storage_VSOk;
}
@@ -959,8 +981,7 @@ Storage_Error FSD_CmpFile::BeginWriteRootSection()
void FSD_CmpFile::SetRootSectionSize(const Standard_Integer aSize)
{
myStream << aSize << "\n";
if (myStream.bad()) Storage_StreamWriteError::Raise();
WriteLine (aSize);
}
//=======================================================================
@@ -970,8 +991,8 @@ void FSD_CmpFile::SetRootSectionSize(const Standard_Integer aSize)
void FSD_CmpFile::WriteRoot(const TCollection_AsciiString& rootName, const Standard_Integer aRef, const TCollection_AsciiString& rootType)
{
myStream << aRef << " " << rootName.ToCString() << " " << rootType.ToCString() << "\n";
if (myStream.bad()) Storage_StreamWriteError::Raise();
TCollection_AsciiString aLine;
WriteLine (aLine + aRef + " " + rootName.ToCString() + " " + rootType.ToCString());
}
//=======================================================================
@@ -981,8 +1002,8 @@ void FSD_CmpFile::WriteRoot(const TCollection_AsciiString& rootName, const Stand
Storage_Error FSD_CmpFile::EndWriteRootSection()
{
myStream << "END_ROOT_SECTION\n";
if (myStream.bad()) Storage_StreamWriteError::Raise();
WriteLine ("END_ROOT_SECTION");
return Storage_VSOk;
}
@@ -1004,9 +1025,7 @@ Storage_Error FSD_CmpFile::BeginReadRootSection()
Standard_Integer FSD_CmpFile::RootSectionSize()
{
Standard_Integer i;
if (!(myStream >> i)) Storage_StreamTypeMismatchError::Raise();
GetInteger (i);
FlushEndOfLine();
return i;
@@ -1019,7 +1038,7 @@ Standard_Integer FSD_CmpFile::RootSectionSize()
void FSD_CmpFile::ReadRoot(TCollection_AsciiString& rootName, Standard_Integer& aRef,TCollection_AsciiString& rootType)
{
if (!(myStream >> aRef)) Storage_StreamTypeMismatchError::Raise();
GetInteger (aRef);
ReadWord(rootName);
ReadWord(rootType);
}
@@ -1042,8 +1061,7 @@ Storage_Error FSD_CmpFile::EndReadRootSection()
Storage_Error FSD_CmpFile::BeginWriteRefSection()
{
myStream << "BEGIN_REF_SECTION\n";
if (myStream.bad()) Storage_StreamWriteError::Raise();
WriteLine ("BEGIN_REF_SECTION");
return Storage_VSOk;
}
@@ -1054,8 +1072,7 @@ Storage_Error FSD_CmpFile::BeginWriteRefSection()
void FSD_CmpFile::SetRefSectionSize(const Standard_Integer aSize)
{
myStream << aSize << "\n";
if (myStream.bad()) Storage_StreamWriteError::Raise();
WriteLine (aSize);
}
//=======================================================================
@@ -1066,8 +1083,8 @@ void FSD_CmpFile::SetRefSectionSize(const Standard_Integer aSize)
void FSD_CmpFile::WriteReferenceType(const Standard_Integer reference,
const Standard_Integer typeNum)
{
myStream << reference << " " << typeNum << "\n";
if (myStream.bad()) Storage_StreamWriteError::Raise();
TCollection_AsciiString aLine;
WriteLine (aLine + reference + " " + typeNum);
}
//=======================================================================
@@ -1077,8 +1094,8 @@ void FSD_CmpFile::WriteReferenceType(const Standard_Integer reference,
Storage_Error FSD_CmpFile::EndWriteRefSection()
{
myStream << "END_REF_SECTION\n";
if (myStream.bad()) Storage_StreamWriteError::Raise();
WriteLine ("END_REF_SECTION");
return Storage_VSOk;
}
@@ -1101,7 +1118,7 @@ Standard_Integer FSD_CmpFile::RefSectionSize()
{
Standard_Integer i;
if (!(myStream >> i)) Storage_StreamTypeMismatchError::Raise();
GetInteger (i);
FlushEndOfLine();
return i;
@@ -1115,8 +1132,8 @@ Standard_Integer FSD_CmpFile::RefSectionSize()
void FSD_CmpFile::ReadReferenceType(Standard_Integer& reference,
Standard_Integer& typeNum)
{
if (!(myStream >> reference)) Storage_StreamTypeMismatchError::Raise();
if (!(myStream >> typeNum)) Storage_StreamTypeMismatchError::Raise();
GetInteger (reference);
GetInteger (typeNum);
FlushEndOfLine();
}
@@ -1138,8 +1155,7 @@ Storage_Error FSD_CmpFile::EndReadRefSection()
Storage_Error FSD_CmpFile::BeginWriteDataSection()
{
myStream << "BEGIN_DATA_SECTION";
if (myStream.bad()) Storage_StreamWriteError::Raise();
WriteLine ("BEGIN_DATA_SECTION", Standard_False);
return Storage_VSOk;
}
@@ -1151,8 +1167,8 @@ Storage_Error FSD_CmpFile::BeginWriteDataSection()
void FSD_CmpFile::WritePersistentObjectHeader(const Standard_Integer aRef,
const Standard_Integer aType)
{
myStream << "\n#" << aRef << "%" << aType << " ";
if (myStream.bad()) Storage_StreamWriteError::Raise();
TCollection_AsciiString aLine;
WriteLine (aLine + "\n#" + aRef + "%" + aType + " ", Standard_False);
}
//=======================================================================
@@ -1162,7 +1178,7 @@ void FSD_CmpFile::WritePersistentObjectHeader(const Standard_Integer aRef,
void FSD_CmpFile::BeginWritePersistentObjectData()
{
if (myStream.bad()) Storage_StreamWriteError::Raise();
}
//=======================================================================
@@ -1172,7 +1188,7 @@ void FSD_CmpFile::BeginWritePersistentObjectData()
void FSD_CmpFile::BeginWriteObjectData()
{
if (myStream.bad()) Storage_StreamWriteError::Raise();
}
//=======================================================================
@@ -1182,7 +1198,7 @@ void FSD_CmpFile::BeginWriteObjectData()
void FSD_CmpFile::EndWriteObjectData()
{
if (myStream.bad()) Storage_StreamWriteError::Raise();
}
//=======================================================================
@@ -1192,7 +1208,7 @@ void FSD_CmpFile::EndWriteObjectData()
void FSD_CmpFile::EndWritePersistentObjectData()
{
if (myStream.bad()) Storage_StreamWriteError::Raise();
}
//=======================================================================
@@ -1202,8 +1218,8 @@ void FSD_CmpFile::EndWritePersistentObjectData()
Storage_Error FSD_CmpFile::EndWriteDataSection()
{
myStream << "\nEND_DATA_SECTION\n";
if (myStream.bad()) Storage_StreamWriteError::Raise();
WriteLine ("\nEND_DATA_SECTION");
return Storage_VSOk;
}
@@ -1227,28 +1243,27 @@ void FSD_CmpFile::ReadPersistentObjectHeader(Standard_Integer& aRef,
{
char c;
myStream.get(c);
Device()->Read( (Standard_Address)&c, sizeof( char ) );
while (c != '#') {
if (IsEnd() || (c != ' ') || (c == '\r')|| (c == '\n')) {
Storage_StreamFormatError::Raise();
}
myStream.get(c);
Device()->Read( (Standard_Address)&c, sizeof( char ) );
}
if (!(myStream >> aRef)) Storage_StreamTypeMismatchError::Raise();
GetInteger (aRef);
myStream.get(c);
Device()->Read( (Standard_Address)&c, sizeof( char ) );
while (c != '%') {
if (IsEnd() || (c != ' ') || (c == '\r')|| (c == '\n')) {
Storage_StreamFormatError::Raise();
}
myStream.get(c);
Device()->Read( (Standard_Address)&c, sizeof( char ) );
}
if (!(myStream >> aType)) Storage_StreamTypeMismatchError::Raise();
// cout << "REF:" << aRef << " TYPE:"<< aType << endl;
GetInteger (aType);
}
//=======================================================================
@@ -1258,7 +1273,6 @@ void FSD_CmpFile::ReadPersistentObjectHeader(Standard_Integer& aRef,
void FSD_CmpFile::BeginReadPersistentObjectData()
{
//cout << "BeginReadPersistentObjectData" << endl;
}
//=======================================================================
@@ -1268,7 +1282,6 @@ void FSD_CmpFile::BeginReadPersistentObjectData()
void FSD_CmpFile::BeginReadObjectData()
{
// cout << "BeginReadObjectData" << endl;
}
//=======================================================================
@@ -1278,7 +1291,6 @@ void FSD_CmpFile::BeginReadObjectData()
void FSD_CmpFile::EndReadObjectData()
{
// cout << "EndReadObjectData" << endl;
}
//=======================================================================
@@ -1290,17 +1302,16 @@ void FSD_CmpFile::EndReadPersistentObjectData()
{
char c;
myStream.get(c);
Device()->Read( (Standard_Address)&c, sizeof( char ) );
while (c != '\n' && (c != '\r')) {
if (IsEnd() || (c != ' ')) {
Storage_StreamFormatError::Raise();
}
myStream.get(c);
Device()->Read( (Standard_Address)&c, sizeof( char ) );
}
if (c == '\r') {
myStream.get(c);
Device()->Read( (Standard_Address)&c, sizeof( char ) );
}
// cout << "EndReadPersistentObjectData" << endl;
}
//=======================================================================
@@ -1320,19 +1331,5 @@ Storage_Error FSD_CmpFile::EndReadDataSection()
Storage_Position FSD_CmpFile::Tell()
{
switch (OpenMode()) {
case Storage_VSRead:
return (Storage_Position) myStream.tellp();
case Storage_VSWrite:
return (Storage_Position) myStream.tellg();
case Storage_VSReadWrite: {
Storage_Position aPosR = (Storage_Position) myStream.tellp();
Storage_Position aPosW = (Storage_Position) myStream.tellg();
if (aPosR < aPosW)
return aPosW;
else
return aPosR;
return Device()->Tell();
}
default: return -1;
}
}

24
src/FSD/FSD_File.cdl
View File

@@ -23,6 +23,7 @@ inherits BaseDriver from Storage
uses Position from Storage,
Error from Storage,
OpenMode from Storage,
IODevice from Storage,
AsciiString from TCollection,
SequenceOfAsciiString from TColStd,
SequenceOfExtendedString from TColStd,
@@ -36,11 +37,12 @@ raises StreamTypeMismatchError from Storage,
is
Create returns File from FSD;
---Purpose:
-- Constructs a driver defining as a file, the physical
-- container for data to be stored or retrieved.
-- Use the function Open to give the name of the driven file.
Open(me : in out; aName : AsciiString from TCollection; aMode : OpenMode from Storage) returns Error from Storage;
---Purpose: Constructs a driver defining as a file, the physical
-- container for data to be stored or retrieved. Use the
-- function Open to give the driven data device.
Open(me : in out; aDevice : IODevice from Storage; aMode : OpenMode from Storage)
returns Error from Storage is redefined;
---Purpose:
-- Assigns as aName the name of the file to be
-- driven by this driver. aMode precises if the file is
@@ -53,8 +55,8 @@ is
Tell( me : in out ) returns Position from Storage;
---Purpose: return position in the file. Return -1 upon error.
IsGoodFileType(myclass; aName : AsciiString from TCollection)
returns Error from Storage;
IsGoodFileType(myclass; aDevice : IODevice from Storage)
returns Error from Storage;
-- INFO SECTION
-- write
@@ -309,6 +311,9 @@ is
Destroy(me : in out);
---C++: alias ~
WriteLine(me : in out; buffer : AsciiString from TCollection; putNewLine: Boolean from Standard = Standard_True) is protected;
---Purpose: write the line.
ReadLine(me : in out; buffer : in out AsciiString from TCollection) is protected;
---Purpose: read from the current position to the end of line.
@@ -328,7 +333,7 @@ is
ReadString(me : in out; buffer : in out AsciiString from TCollection) is protected;
---Purpose: read from the first none space character position to the end of line.
FlushEndOfLine(me : in out) is protected;
FindTag(me : in out; aTag : CString from Standard) returns Error from Storage is protected;
@@ -337,7 +342,4 @@ is
returns CString from Standard is private;
---C++: return const
fields
myStream : FStream from FSD;
end;

443
src/FSD/FSD_File.cxx
View File

@@ -37,12 +37,12 @@ FSD_File::FSD_File()
// write
//=======================================================================
Storage_Error FSD_File::IsGoodFileType(const TCollection_AsciiString& aName)
Storage_Error FSD_File::IsGoodFileType(const Handle(Storage_IODevice)& aDevice)
{
FSD_File f;
Storage_Error s;
s = f.Open(aName,Storage_VSRead);
s = f.Open(aDevice, Storage_VSRead);
if (s == Storage_VSOk) {
TCollection_AsciiString l;
@@ -65,11 +65,16 @@ Storage_Error FSD_File::IsGoodFileType(const TCollection_AsciiString& aName)
//purpose :
//=======================================================================
Storage_Error FSD_File::Open(const TCollection_AsciiString& aName,const Storage_OpenMode aMode)
Storage_Error FSD_File::Open(const Handle(Storage_IODevice)& aDevice, const Storage_OpenMode aMode)
{
Storage_Error result = Storage_VSOk;
SetDevice(aDevice);
SetName(aName);
if ( Device().IsNull() )
return Storage_VSOpenError;
return Device()->Open(aMode);
/*
Storage_Error result = Storage_VSOk;
if (OpenMode() == Storage_VSNone) {
@@ -109,6 +114,7 @@ Storage_Error FSD_File::Open(const TCollection_AsciiString& aName,const Storage_
}
return result;
*/
}
//=======================================================================
@@ -118,7 +124,7 @@ Storage_Error FSD_File::Open(const TCollection_AsciiString& aName,const Storage_
Standard_Boolean FSD_File::IsEnd()
{
return myStream.eof();
return !Device().IsNull() ? Device()->IsEnd() : Standard_True;
}
//=======================================================================
@@ -131,8 +137,7 @@ Storage_Error FSD_File::Close()
Storage_Error result = Storage_VSOk;
if (OpenMode() != Storage_VSNone) {
myStream.close();
SetOpenMode(Storage_VSNone);
Device()->Close();
}
else {
result = Storage_VSNotOpen;
@@ -176,6 +181,21 @@ void FSD_File::FlushEndOfLine()
}*/
}
//=======================================================================
//function : WriteLine
//purpose : write the line.
//=======================================================================
void FSD_File::WriteLine(const TCollection_AsciiString& aStr, const Standard_Boolean putNewLine)
{
TCollection_AsciiString buffer = aStr;
if ( putNewLine )
buffer += TCollection_AsciiString("\n");
if ( Device()->Write( (Standard_Address)buffer.ToCString(), buffer.Length() ) != (Standard_Size)buffer.Length() )
Storage_StreamWriteError::Raise();
}
//=======================================================================
//function : ReadLine
//purpose : read from the current position to the end of line.
@@ -183,24 +203,24 @@ void FSD_File::FlushEndOfLine()
void FSD_File::ReadLine(TCollection_AsciiString& buffer)
{
char Buffer[8193];
// char Buffer[8193];
Standard_Boolean IsEnd = Standard_False;
buffer.Clear();
while (!IsEnd && !FSD_File::IsEnd()) {
Buffer[0] = '\0';
myStream.getline(Buffer,8192,'\n');
// char c;
// if (myStream.get(c) && c != '\n') {
// buffer += Buffer;
// buffer += c;
// }
// else {
buffer += Buffer;
while ( !IsEnd && !FSD_File::IsEnd() )
{
// Buffer[0] = '\0';
// myStream.getline(Buffer,8192,'\n');
Standard_Character c;
Device()->Read( (Standard_Address)&c, 1 );
if ( c != '\n')
buffer += c;
else
{
buffer += '\0';
IsEnd = Standard_True;
// }
}
}
}
@@ -219,11 +239,15 @@ void FSD_File::WriteExtendedLine(const TCollection_ExtendedString& buffer)
for (i = 0; i < buffer.Length(); i++) {
c = (extBuffer[i] & 0x0000FF00 ) >> 8 ;
d = extBuffer[i] & 0x000000FF;
char cc = (char)c;
char cd = (char)d;
myStream << (char)c << (char)d;
Device()->Write( (Standard_Address)&cc, sizeof(char) );
Device()->Write( (Standard_Address)&cd, sizeof(char) );
}
myStream << (char)0 << "\n";
Device()->Write((Standard_Address)"\0\n", 2);
}
//=======================================================================
@@ -241,7 +265,7 @@ void FSD_File::ReadExtendedLine(TCollection_ExtendedString& buffer)
buffer.Clear();
while (!fin && !IsEnd()) {
myStream.get(c);
Device()->Read( (Standard_Address)&c, sizeof(char) );
if (c == tg[count]) count++;
else count = 0;
@@ -251,7 +275,7 @@ void FSD_File::ReadExtendedLine(TCollection_ExtendedString& buffer)
if (c == '\0') fin = Standard_True;
i = (i << 8);
myStream.get(c);
Device()->Read( (Standard_Address)&c, sizeof(char) );
if (c == tg[count]) count++;
else count = 0;
if (count < SIZEOFNORMALEXTENDEDSECTION) {
@@ -285,7 +309,7 @@ void FSD_File::ReadChar(TCollection_AsciiString& buffer, const Standard_Size rsi
buffer.Clear();
while (!IsEnd() && (ccount < rsize)) {
myStream.get(c);
Device()->Read( (Standard_Address)&c, sizeof( char ) );
buffer += c;
ccount++;
}
@@ -298,34 +322,30 @@ void FSD_File::ReadChar(TCollection_AsciiString& buffer, const Standard_Size rsi
void FSD_File::ReadString(TCollection_AsciiString& buffer)
{
char Buffer[8193];
char *bpos;
Standard_Boolean IsEnd = Standard_False,isFirstTime = Standard_True;
buffer.Clear();
while (!IsEnd && !FSD_File::IsEnd()) {
Buffer[0] = '\0';
myStream.getline(Buffer,8192,'\n');
bpos = Buffer;
// LeftAdjust
//
if (isFirstTime) {
isFirstTime = Standard_False;
while (*bpos == '\n' || *bpos == ' ') bpos++;
char c;
Device()->Read((Standard_Address)&c, sizeof(c));
if ( isFirstTime )
{
if ( c == '\n' || c == ' ' )
continue;
else
isFirstTime = Standard_False;
}
// char c;
// if (myStream.get(c) && c != '\n') {
// buffer += bpos;
// buffer += c;
// }
// else {
buffer += bpos;
if ( c != '\n')
buffer += c;
else
{
buffer += '\0';
IsEnd = Standard_True;
// }
}
}
}
//=======================================================================
@@ -345,8 +365,9 @@ void FSD_File::ReadWord(TCollection_AsciiString& buffer)
buffer.Clear();
while (!IsEnd && !FSD_File::IsEnd()) {
myStream.get(c);
if ((c != ' ') && (c != '\n')) IsEnd = Standard_True;
Device()->Read( (Standard_Address)&c, sizeof(char) );
if ((c != ' ') && (c != '\n'))
IsEnd = Standard_True;
}
IsEnd = Standard_False;
@@ -361,8 +382,9 @@ void FSD_File::ReadWord(TCollection_AsciiString& buffer)
}
*tmpb = c;
tmpb++; i++;
myStream.get(c);
if ((c == '\n') || (c == ' ')) IsEnd = Standard_True;
Device()->Read( (Standard_Address)&c, sizeof(char) );
if ((c == '\n') || (c == ' '))
IsEnd = Standard_True;
}
buffer += b;
@@ -408,8 +430,10 @@ void FSD_File::SkipObject()
Storage_BaseDriver& FSD_File::PutReference(const Standard_Integer aValue)
{
myStream << aValue << " ";
if (myStream.bad()) Storage_StreamWriteError::Raise();
TCollection_AsciiString aStr = TCollection_AsciiString( aValue ) + " ";
if ( Device()->Write( (Standard_Address)aStr.ToCString(), aStr.Length() ) != (Standard_Size)aStr.Length() )
Storage_StreamWriteError::Raise();
return *this;
}
@@ -420,11 +444,10 @@ Storage_BaseDriver& FSD_File::PutReference(const Standard_Integer aValue)
Storage_BaseDriver& FSD_File::PutCharacter(const Standard_Character aValue)
{
unsigned short i;
i = aValue;
myStream << i << " ";
if (myStream.bad()) Storage_StreamWriteError::Raise();
Standard_Integer i = aValue;
TCollection_AsciiString aStr = TCollection_AsciiString( i ) + " ";
if ( Device()->Write( (Standard_Address)aStr.ToCString(), aStr.Length() ) != (Standard_Size)aStr.Length() )
Storage_StreamWriteError::Raise();
return *this;
}
@@ -435,8 +458,10 @@ Storage_BaseDriver& FSD_File::PutCharacter(const Standard_Character aValue)
Storage_BaseDriver& FSD_File::PutExtCharacter(const Standard_ExtCharacter aValue)
{
myStream << aValue << " ";
if (myStream.bad()) Storage_StreamWriteError::Raise();
Standard_Integer i = aValue;
TCollection_AsciiString aStr = TCollection_AsciiString( i ) + " ";
if ( Device()->Write( (Standard_Address)aStr.ToCString(), aStr.Length() ) != (Standard_Size)aStr.Length() )
Storage_StreamWriteError::Raise();
return *this;
}
@@ -447,8 +472,9 @@ Storage_BaseDriver& FSD_File::PutExtCharacter(const Standard_ExtCharacter aValue
Storage_BaseDriver& FSD_File::PutInteger(const Standard_Integer aValue)
{
myStream << aValue << " ";
if (myStream.bad()) Storage_StreamWriteError::Raise();
TCollection_AsciiString aStr = TCollection_AsciiString( aValue ) + " ";
if ( Device()->Write( (Standard_Address)aStr.ToCString(), aStr.Length() ) != (Standard_Size)aStr.Length() )
Storage_StreamWriteError::Raise();
return *this;
}
@@ -459,8 +485,9 @@ Storage_BaseDriver& FSD_File::PutInteger(const Standard_Integer aValue)
Storage_BaseDriver& FSD_File::PutBoolean(const Standard_Boolean aValue)
{
myStream << ((Standard_Integer)aValue) << " ";
if (myStream.bad()) Storage_StreamWriteError::Raise();
TCollection_AsciiString aStr = TCollection_AsciiString( (Standard_Integer)aValue ) + " ";
if ( Device()->Write( (Standard_Address)aStr.ToCString(), aStr.Length() ) != (Standard_Size)aStr.Length() )
Storage_StreamWriteError::Raise();
return *this;
}
@@ -471,8 +498,9 @@ Storage_BaseDriver& FSD_File::PutBoolean(const Standard_Boolean aValue)
Storage_BaseDriver& FSD_File::PutReal(const Standard_Real aValue)
{
myStream << ((Standard_Real)aValue) << " ";
if (myStream.bad()) Storage_StreamWriteError::Raise();
TCollection_AsciiString aStr = TCollection_AsciiString( aValue ) + " ";
if ( Device()->Write( (Standard_Address)aStr.ToCString(), aStr.Length() ) != (Standard_Size)aStr.Length() )
Storage_StreamWriteError::Raise();
return *this;
}
@@ -483,8 +511,9 @@ Storage_BaseDriver& FSD_File::PutReal(const Standard_Real aValue)
Storage_BaseDriver& FSD_File::PutShortReal(const Standard_ShortReal aValue)
{
myStream << aValue << " ";
if (myStream.bad()) Storage_StreamWriteError::Raise();
TCollection_AsciiString aStr = TCollection_AsciiString( aValue ) + " ";
if ( Device()->Write( (Standard_Address)aStr.ToCString(), aStr.Length() ) != (Standard_Size)aStr.Length() )
Storage_StreamWriteError::Raise();
return *this;
}
@@ -495,7 +524,12 @@ Storage_BaseDriver& FSD_File::PutShortReal(const Standard_ShortReal aValue)
Storage_BaseDriver& FSD_File::GetReference(Standard_Integer& aValue)
{
if (!(myStream >> aValue)) Storage_StreamTypeMismatchError::Raise();
TCollection_AsciiString aStr;
ReadWord( aStr );
if ( aStr.IsIntegerValue() )
aValue = aStr.IntegerValue();
else
Storage_StreamTypeMismatchError::Raise();
return *this;
}
@@ -508,13 +542,13 @@ Storage_BaseDriver& FSD_File::GetReference(Standard_Integer& aValue)
Storage_BaseDriver& FSD_File::GetCharacter(Standard_Character& aValue)
{
unsigned short i = 0;
if (!(myStream >> i)) {
// SGI : donne une erreur mais a une bonne valeur pour les caracteres ecrits
// signes (-80 fait ios::badbit, mais la variable i est initialisee)
//
if (i == 0) Storage_StreamTypeMismatchError::Raise();
myStream.clear(ios::goodbit); // .clear(0) is not portable
}
TCollection_AsciiString aStr;
ReadWord( aStr );
if ( aStr.IsIntegerValue() )
i = (unsigned short)aStr.IntegerValue();
else
Storage_StreamTypeMismatchError::Raise();
aValue = (char)i;
return *this;
@@ -527,8 +561,16 @@ Storage_BaseDriver& FSD_File::GetCharacter(Standard_Character& aValue)
Storage_BaseDriver& FSD_File::GetExtCharacter(Standard_ExtCharacter& aValue)
{
if (!(myStream >> aValue)) Storage_StreamTypeMismatchError::Raise();
unsigned short i = 0;
TCollection_AsciiString aStr;
ReadWord( aStr );
if ( aStr.IsIntegerValue() )
i = (unsigned short)aStr.IntegerValue();
else
Storage_StreamTypeMismatchError::Raise();
aValue = (Standard_ExtCharacter)i;
return *this;
}
@@ -539,7 +581,12 @@ Storage_BaseDriver& FSD_File::GetExtCharacter(Standard_ExtCharacter& aValue)
Storage_BaseDriver& FSD_File::GetInteger(Standard_Integer& aValue)
{
if (!(myStream >> aValue)) Storage_StreamTypeMismatchError::Raise();
TCollection_AsciiString aStr;
ReadWord( aStr );
if ( aStr.IsIntegerValue() )
aValue = aStr.IntegerValue();
else
Storage_StreamTypeMismatchError::Raise();
return *this;
}
@@ -551,7 +598,12 @@ Storage_BaseDriver& FSD_File::GetInteger(Standard_Integer& aValue)
Storage_BaseDriver& FSD_File::GetBoolean(Standard_Boolean& aValue)
{
if (!(myStream >> aValue)) Storage_StreamTypeMismatchError::Raise();
TCollection_AsciiString aStr;
ReadWord( aStr );
if ( aStr.IsIntegerValue() )
aValue = (Standard_Boolean)aStr.IntegerValue();
else
Storage_StreamTypeMismatchError::Raise();
return *this;
}
@@ -563,19 +615,14 @@ Storage_BaseDriver& FSD_File::GetBoolean(Standard_Boolean& aValue)
Storage_BaseDriver& FSD_File::GetReal(Standard_Real& aValue)
{
#ifdef USEOSDREAL
char realbuffer[100];
realbuffer[0] = '\0';
if (!(myStream >> realbuffer)) Storage_StreamTypeMismatchError::Raise();
if (!OSD::CStringToReal(realbuffer,aValue)) Storage_StreamTypeMismatchError::Raise();
TCollection_AsciiString aStr;
ReadWord( aStr );
if ( aStr.IsRealValue() )
aValue = aStr.RealValue();
else
Storage_StreamTypeMismatchError::Raise();
return *this;
#else
if (!(myStream >> aValue)) Storage_StreamTypeMismatchError::Raise();
return *this;
#endif
}
//=======================================================================
@@ -585,21 +632,13 @@ Storage_BaseDriver& FSD_File::GetReal(Standard_Real& aValue)
Storage_BaseDriver& FSD_File::GetShortReal(Standard_ShortReal& aValue)
{
#ifdef USEOSDREAL
char realbuffer[100];
Standard_Real r = 0.0;
realbuffer[0] = '\0';
if (!(myStream >> realbuffer)) Storage_StreamTypeMismatchError::Raise();
if (!OSD::CStringToReal(realbuffer,r)) Storage_StreamTypeMismatchError::Raise();
aValue = r;
return *this;
#else
if (!(myStream >> aValue)) Storage_StreamTypeMismatchError::Raise();
TCollection_AsciiString aStr;
ReadWord( aStr );
if ( aStr.IsRealValue() )
aValue = (Standard_ShortReal)aStr.RealValue();
else
Storage_StreamTypeMismatchError::Raise();
return *this;
#endif
}
//=======================================================================
@@ -621,9 +660,8 @@ void FSD_File::Destroy()
Storage_Error FSD_File::BeginWriteInfoSection()
{
myStream << FSD_File::MagicNumber() << '\n';
myStream << "BEGIN_INFO_SECTION\n";
if (myStream.bad()) Storage_StreamWriteError::Raise();
WriteLine( FSD_File::MagicNumber() );
WriteLine( "BEGIN_INFO_SECTION" );
return Storage_VSOk;
}
@@ -645,23 +683,20 @@ void FSD_File::WriteInfo(const Standard_Integer nbObj,
{
Standard_Integer i;
myStream << nbObj;
myStream << "\n";
myStream << dbVersion.ToCString() << "\n";
myStream << date.ToCString() << "\n";
myStream << schemaName.ToCString() << "\n";
myStream << schemaVersion.ToCString() << "\n";
PutInteger( nbObj );
WriteLine( "" );
WriteLine( dbVersion );
WriteLine( date );
WriteLine( schemaName );
WriteLine( schemaVersion );
WriteExtendedLine(appName);
myStream << appVersion.ToCString() << "\n";
WriteLine( appVersion );
WriteExtendedLine(dataType);
myStream << userInfo.Length() << "\n";
PutInteger( userInfo.Length() );
WriteLine( "" );
if (myStream.bad()) Storage_StreamWriteError::Raise();
for (i = 1; i <= userInfo.Length(); i++) {
myStream << userInfo.Value(i).ToCString() << "\n";
if (myStream.bad()) Storage_StreamWriteError::Raise();
}
for (i = 1; i <= userInfo.Length(); i++)
WriteLine( userInfo.Value(i) );
}
//=======================================================================
@@ -671,8 +706,8 @@ void FSD_File::WriteInfo(const Standard_Integer nbObj,
Storage_Error FSD_File::EndWriteInfoSection()
{
myStream << "END_INFO_SECTION\n";
if (myStream.bad()) Storage_StreamWriteError::Raise();
WriteLine( "END_INFO_SECTION" );
return Storage_VSOk;
}
@@ -714,7 +749,7 @@ void FSD_File::ReadInfo(Standard_Integer& nbObj,
TCollection_ExtendedString& dataType,
TColStd_SequenceOfAsciiString& userInfo)
{
if (!(myStream >> nbObj)) Storage_StreamTypeMismatchError::Raise();
GetInteger( nbObj );
FlushEndOfLine();
@@ -728,7 +763,7 @@ void FSD_File::ReadInfo(Standard_Integer& nbObj,
Standard_Integer i,len = 0;
if (!(myStream >> len)) Storage_StreamTypeMismatchError::Raise();
GetInteger( len );
FlushEndOfLine();
@@ -759,8 +794,8 @@ Storage_Error FSD_File::EndReadInfoSection()
Storage_Error FSD_File::BeginWriteCommentSection()
{
myStream << "BEGIN_COMMENT_SECTION\n";
if (myStream.bad()) Storage_StreamWriteError::Raise();
WriteLine( "BEGIN_COMMENT_SECTION" );
return Storage_VSOk;
}
@@ -774,12 +809,10 @@ void FSD_File::WriteComment(const TColStd_SequenceOfExtendedString& aCom)
Standard_Integer i,aSize;
aSize = aCom.Length();
myStream << aSize << "\n";
if (myStream.bad()) Storage_StreamWriteError::Raise();
PutInteger( aSize );
for (i = 1; i <= aSize; i++) {
WriteExtendedLine(aCom.Value(i));
if (myStream.bad()) Storage_StreamWriteError::Raise();
}
}
@@ -790,8 +823,8 @@ void FSD_File::WriteComment(const TColStd_SequenceOfExtendedString& aCom)
Storage_Error FSD_File::EndWriteCommentSection()
{
myStream << "END_COMMENT_SECTION\n";
if (myStream.bad()) Storage_StreamWriteError::Raise();
WriteLine( "END_COMMENT_SECTION" );
return Storage_VSOk;
}
@@ -815,7 +848,7 @@ void FSD_File::ReadComment(TColStd_SequenceOfExtendedString& aCom)
TCollection_ExtendedString line;
Standard_Integer len,i;
if (!(myStream >> len)) Storage_StreamTypeMismatchError::Raise();
GetInteger (len);
FlushEndOfLine();
@@ -843,8 +876,7 @@ Storage_Error FSD_File::EndReadCommentSection()
Storage_Error FSD_File::BeginWriteTypeSection()
{
myStream << "BEGIN_TYPE_SECTION\n";
if (myStream.bad()) Storage_StreamWriteError::Raise();
WriteLine ("BEGIN_TYPE_SECTION");
return Storage_VSOk;
}
@@ -855,8 +887,7 @@ Storage_Error FSD_File::BeginWriteTypeSection()
void FSD_File::SetTypeSectionSize(const Standard_Integer aSize)
{
myStream << aSize << "\n";
if (myStream.bad()) Storage_StreamWriteError::Raise();
WriteLine (aSize);
}
//=======================================================================
@@ -867,8 +898,8 @@ void FSD_File::SetTypeSectionSize(const Standard_Integer aSize)
void FSD_File::WriteTypeInformations(const Standard_Integer typeNum,
const TCollection_AsciiString& typeName)
{
myStream << typeNum << " " << typeName.ToCString() << "\n";
if (myStream.bad()) Storage_StreamWriteError::Raise();
TCollection_AsciiString aLine;
WriteLine (aLine + typeNum + " " + typeName.ToCString());
}
//=======================================================================
@@ -878,8 +909,8 @@ void FSD_File::WriteTypeInformations(const Standard_Integer typeNum,
Storage_Error FSD_File::EndWriteTypeSection()
{
myStream << "END_TYPE_SECTION\n";
if (myStream.bad()) Storage_StreamWriteError::Raise();
WriteLine ("END_TYPE_SECTION");
return Storage_VSOk;
}
@@ -901,11 +932,8 @@ Storage_Error FSD_File::BeginReadTypeSection()
Standard_Integer FSD_File::TypeSectionSize()
{
Standard_Integer i;
if (!(myStream >> i)) Storage_StreamTypeMismatchError::Raise();
GetInteger (i);
FlushEndOfLine();
return i;
}
@@ -917,8 +945,8 @@ Standard_Integer FSD_File::TypeSectionSize()
void FSD_File::ReadTypeInformations(Standard_Integer& typeNum,
TCollection_AsciiString& typeName)
{
if (!(myStream >> typeNum)) Storage_StreamTypeMismatchError::Raise();
if (!(myStream >> typeName)) Storage_StreamTypeMismatchError::Raise();
GetInteger (typeNum);
ReadLine(typeName);
FlushEndOfLine();
}
@@ -940,8 +968,7 @@ Storage_Error FSD_File::EndReadTypeSection()
Storage_Error FSD_File::BeginWriteRootSection()
{
myStream << "BEGIN_ROOT_SECTION\n";
if (myStream.bad()) Storage_StreamWriteError::Raise();
WriteLine ("BEGIN_ROOT_SECTION");
return Storage_VSOk;
}
@@ -952,8 +979,7 @@ Storage_Error FSD_File::BeginWriteRootSection()
void FSD_File::SetRootSectionSize(const Standard_Integer aSize)
{
myStream << aSize << "\n";
if (myStream.bad()) Storage_StreamWriteError::Raise();
WriteLine (aSize);
}
//=======================================================================
@@ -963,8 +989,8 @@ void FSD_File::SetRootSectionSize(const Standard_Integer aSize)
void FSD_File::WriteRoot(const TCollection_AsciiString& rootName, const Standard_Integer aRef, const TCollection_AsciiString& rootType)
{
myStream << aRef << " " << rootName.ToCString() << " " << rootType.ToCString() << "\n";
if (myStream.bad()) Storage_StreamWriteError::Raise();
TCollection_AsciiString aLine;
WriteLine (aLine + aRef + " " + rootName.ToCString() + " " + rootType.ToCString());
}
//=======================================================================
@@ -974,8 +1000,7 @@ void FSD_File::WriteRoot(const TCollection_AsciiString& rootName, const Standard
Storage_Error FSD_File::EndWriteRootSection()
{
myStream << "END_ROOT_SECTION\n";
if (myStream.bad()) Storage_StreamWriteError::Raise();
WriteLine ("END_ROOT_SECTION");
return Storage_VSOk;
}
@@ -997,11 +1022,8 @@ Storage_Error FSD_File::BeginReadRootSection()
Standard_Integer FSD_File::RootSectionSize()
{
Standard_Integer i;
if (!(myStream >> i)) Storage_StreamTypeMismatchError::Raise();
GetInteger (i);
FlushEndOfLine();
return i;
}
@@ -1012,7 +1034,7 @@ Standard_Integer FSD_File::RootSectionSize()
void FSD_File::ReadRoot(TCollection_AsciiString& rootName, Standard_Integer& aRef,TCollection_AsciiString& rootType)
{
if (!(myStream >> aRef)) Storage_StreamTypeMismatchError::Raise();
GetInteger (aRef);
ReadWord(rootName);
ReadWord(rootType);
}
@@ -1035,8 +1057,7 @@ Storage_Error FSD_File::EndReadRootSection()
Storage_Error FSD_File::BeginWriteRefSection()
{
myStream << "BEGIN_REF_SECTION\n";
if (myStream.bad()) Storage_StreamWriteError::Raise();
WriteLine ("BEGIN_REF_SECTION");
return Storage_VSOk;
}
@@ -1047,8 +1068,7 @@ Storage_Error FSD_File::BeginWriteRefSection()
void FSD_File::SetRefSectionSize(const Standard_Integer aSize)
{
myStream << aSize << "\n";
if (myStream.bad()) Storage_StreamWriteError::Raise();
WriteLine (aSize);
}
//=======================================================================
@@ -1059,8 +1079,8 @@ void FSD_File::SetRefSectionSize(const Standard_Integer aSize)
void FSD_File::WriteReferenceType(const Standard_Integer reference,
const Standard_Integer typeNum)
{
myStream << reference << " " << typeNum << "\n";
if (myStream.bad()) Storage_StreamWriteError::Raise();
TCollection_AsciiString aLine;
WriteLine (aLine + reference + " " + typeNum);
}
//=======================================================================
@@ -1070,8 +1090,7 @@ void FSD_File::WriteReferenceType(const Standard_Integer reference,
Storage_Error FSD_File::EndWriteRefSection()
{
myStream << "END_REF_SECTION\n";
if (myStream.bad()) Storage_StreamWriteError::Raise();
WriteLine ("END_REF_SECTION");
return Storage_VSOk;
}
@@ -1093,10 +1112,8 @@ Storage_Error FSD_File::BeginReadRefSection()
Standard_Integer FSD_File::RefSectionSize()
{
Standard_Integer i;
if (!(myStream >> i)) Storage_StreamTypeMismatchError::Raise();
GetInteger (i);
FlushEndOfLine();
return i;
}
@@ -1108,8 +1125,8 @@ Standard_Integer FSD_File::RefSectionSize()
void FSD_File::ReadReferenceType(Standard_Integer& reference,
Standard_Integer& typeNum)
{
if (!(myStream >> reference)) Storage_StreamTypeMismatchError::Raise();
if (!(myStream >> typeNum)) Storage_StreamTypeMismatchError::Raise();
GetInteger (reference);
GetInteger (typeNum);
FlushEndOfLine();
}
@@ -1131,8 +1148,7 @@ Storage_Error FSD_File::EndReadRefSection()
Storage_Error FSD_File::BeginWriteDataSection()
{
myStream << "BEGIN_DATA_SECTION";
if (myStream.bad()) Storage_StreamWriteError::Raise();
WriteLine ("BEGIN_DATA_SECTION", Standard_False);
return Storage_VSOk;
}
@@ -1144,8 +1160,8 @@ Storage_Error FSD_File::BeginWriteDataSection()
void FSD_File::WritePersistentObjectHeader(const Standard_Integer aRef,
const Standard_Integer aType)
{
myStream << "\n#" << aRef << "=%" << aType;
if (myStream.bad()) Storage_StreamWriteError::Raise();
TCollection_AsciiString aLine;
WriteLine (aLine + "\n#" + aRef + "=%" + aType);
}
//=======================================================================
@@ -1155,8 +1171,7 @@ void FSD_File::WritePersistentObjectHeader(const Standard_Integer aRef,
void FSD_File::BeginWritePersistentObjectData()
{
myStream << "( ";
if (myStream.bad()) Storage_StreamWriteError::Raise();
WriteLine ("( ", Standard_False);
}
//=======================================================================
@@ -1166,8 +1181,7 @@ void FSD_File::BeginWritePersistentObjectData()
void FSD_File::BeginWriteObjectData()
{
myStream << "( ";
if (myStream.bad()) Storage_StreamWriteError::Raise();
WriteLine ("( ", Standard_False);
}
//=======================================================================
@@ -1177,8 +1191,7 @@ void FSD_File::BeginWriteObjectData()
void FSD_File::EndWriteObjectData()
{
myStream << ") ";
if (myStream.bad()) Storage_StreamWriteError::Raise();
WriteLine (") ", Standard_False);
}
//=======================================================================
@@ -1188,8 +1201,7 @@ void FSD_File::EndWriteObjectData()
void FSD_File::EndWritePersistentObjectData()
{
myStream << ")";
if (myStream.bad()) Storage_StreamWriteError::Raise();
WriteLine (")", Standard_False);
}
//=======================================================================
@@ -1199,8 +1211,7 @@ void FSD_File::EndWritePersistentObjectData()
Storage_Error FSD_File::EndWriteDataSection()
{
myStream << "\nEND_DATA_SECTION\n";
if (myStream.bad()) Storage_StreamWriteError::Raise();
WriteLine ("\nEND_DATA_SECTION");
return Storage_VSOk;
}
@@ -1224,38 +1235,37 @@ void FSD_File::ReadPersistentObjectHeader(Standard_Integer& aRef,
{
char c;
myStream.get(c);
Device()->Read( (Standard_Address)&c, sizeof(char) );
while (c != '#') {
if (IsEnd() || (c != ' ') || (c == '\n')) {
Storage_StreamFormatError::Raise();
}
myStream.get(c);
Device()->Read( (Standard_Address)&c, sizeof(char) );
}
if (!(myStream >> aRef)) Storage_StreamTypeMismatchError::Raise();
GetInteger (aRef);
myStream.get(c);
Device()->Read( (Standard_Address)&c, sizeof(char) );
while (c != '=') {
if (IsEnd() || (c != ' ') || (c == '\n')) {
Storage_StreamFormatError::Raise();
}
myStream.get(c);
Device()->Read( (Standard_Address)&c, sizeof(char) );
}
myStream.get(c);
Device()->Read( (Standard_Address)&c, sizeof(char) );
while (c != '%') {
if (IsEnd() || (c != ' ') || (c == '\n')) {
Storage_StreamFormatError::Raise();
}
myStream.get(c);
Device()->Read( (Standard_Address)&c, sizeof(char) );
}
if (!(myStream >> aType)) Storage_StreamTypeMismatchError::Raise();
// cout << "REF:" << aRef << " TYPE:"<< aType << endl;
GetInteger (aType);
}
//=======================================================================
@@ -1266,15 +1276,13 @@ void FSD_File::ReadPersistentObjectHeader(Standard_Integer& aRef,
void FSD_File::BeginReadPersistentObjectData()
{
char c;
myStream.get(c);
Device()->Read( (Standard_Address)&c, sizeof(char) );
while (c != '(') {
if (IsEnd() || (c != ' ') || (c == '\n')) {
Storage_StreamFormatError::Raise();
}
myStream.get(c);
Device()->Read( (Standard_Address)&c, sizeof(char) );
}
//cout << "BeginReadPersistentObjectData" << endl;
}
//=======================================================================
@@ -1286,15 +1294,13 @@ void FSD_File::BeginReadObjectData()
{
char c;
myStream.get(c);
Device()->Read( (Standard_Address)&c, sizeof(char) );
while (c != '(') {
if (IsEnd() || (c != ' ') || (c == '\n')) {
Storage_StreamFormatError::Raise();
}
myStream.get(c);
Device()->Read( (Standard_Address)&c, sizeof(char) );
}
// cout << "BeginReadObjectData" << endl;
}
//=======================================================================
@@ -1306,15 +1312,13 @@ void FSD_File::EndReadObjectData()
{
char c;
myStream.get(c);
Device()->Read( (Standard_Address)&c, sizeof(char) );
while (c != ')') {
if (IsEnd() || (c != ' ') || (c == '\n')) {
Storage_StreamFormatError::Raise();
}
myStream.get(c);
Device()->Read( (Standard_Address)&c, sizeof(char) );
}
// cout << "EndReadObjectData" << endl;
}
//=======================================================================
@@ -1327,22 +1331,21 @@ void FSD_File::EndReadPersistentObjectData()
char c;
myStream.get(c);
Device()->Read( (Standard_Address)&c, sizeof(char) );
while (c != ')') {
if (IsEnd() || (c != ' ') || (c == '\n')) {
Storage_StreamFormatError::Raise();
}
myStream.get(c);
Device()->Read( (Standard_Address)&c, sizeof(char) );
}
myStream.get(c);
Device()->Read( (Standard_Address)&c, sizeof(char) );
while (c != '\n') {
if (IsEnd() || (c != ' ')) {
Storage_StreamFormatError::Raise();
}
myStream.get(c);
Device()->Read( (Standard_Address)&c, sizeof(char) );
}
// cout << "EndReadPersistentObjectData" << endl;
}
//=======================================================================
@@ -1362,19 +1365,5 @@ Storage_Error FSD_File::EndReadDataSection()
Storage_Position FSD_File::Tell()
{
switch (OpenMode()) {
case Storage_VSRead:
return (Storage_Position) myStream.tellp();
case Storage_VSWrite:
return (Storage_Position) myStream.tellg();
case Storage_VSReadWrite: {
Storage_Position aPosR = (Storage_Position) myStream.tellp();
Storage_Position aPosW = (Storage_Position) myStream.tellg();
if (aPosR < aPosW)
return aPosW;
else
return aPosR;
}
default: return -1;
}
return Device()->Tell();
}

80
src/LDOM/LDOM_XmlWriter.cxx
View File

@@ -184,6 +184,19 @@ LDOM_XmlWriter::LDOM_XmlWriter (FILE * aFile,
myABufferLen (0)
{}
LDOM_XmlWriter::LDOM_XmlWriter(const Handle(Storage_IODevice)& theDevice,
const char * theEncoding )
: myFile (NULL),
myEncodingName (::getEncodingName (theEncoding)),
myIndent (0),
myCurIndent (0),
myABuffer (NULL),
myABufferLen (0)
{
myDevice = theDevice;
}
//=======================================================================
//function : ~LDOM_XmlWriter
//purpose : Destructor
@@ -222,7 +235,16 @@ inline LDOM_XmlWriter& LDOM_XmlWriter::operator <<
{
Standard_Integer aValue;
aString.GetInteger (aValue);
fprintf (myFile, "%d", aValue);
if (!myDevice.IsNull() && myDevice->CanWrite())
{
TCollection_AsciiString aStrValue (aValue);
myDevice->Write ((Standard_Address)aStrValue.ToCString(), strlen (aStrValue.ToCString()));
}
else
{
fprintf (myFile, "%d", aValue);
}
break;
}
case LDOMBasicString::LDOM_AsciiHashed: // attr names and element tags
@@ -231,7 +253,17 @@ inline LDOM_XmlWriter& LDOM_XmlWriter::operator <<
const char * str = aString.GetString();
if (str) {
const Standard_Size aLen = strlen (str);
if (aLen > 0) fwrite (str, aLen, 1, myFile);
if (aLen > 0)
{
if (!myDevice.IsNull() && myDevice->CanWrite())
{
myDevice->Write((Standard_Address)str, aLen);
}
else
{
fwrite (str, aLen, 1, myFile);
}
}
}
}
break;
@@ -242,7 +274,17 @@ inline LDOM_XmlWriter& LDOM_XmlWriter::operator <<
if (str) {
Standard_Integer aLen;
char * encStr = LDOM_CharReference::Encode(str, aLen, Standard_False);
if (aLen > 0) fwrite (encStr, aLen, 1, myFile);
if (aLen > 0)
{
if (!myDevice.IsNull() && myDevice->CanWrite())
{
myDevice->Write(encStr, aLen);
}
else
{
fwrite (encStr, aLen, 1, myFile);
}
}
if (encStr != str) delete [] encStr;
}
}
@@ -258,7 +300,17 @@ inline LDOM_XmlWriter& LDOM_XmlWriter::operator <<
inline LDOM_XmlWriter& LDOM_XmlWriter::operator << (const LXMLCh * aString)
{
Standard_Size aLength = strlen (aString);
if (aLength > 0) fwrite ((void *) aString, aLength, 1, myFile);
if (aLength > 0)
{
if (!myDevice.IsNull() && myDevice->CanWrite())
{
myDevice->Write((Standard_Address)aString, aLength);
}
else
{
fwrite ((void *) aString, aLength, 1, myFile);
}
}
return * this;
}
@@ -268,7 +320,15 @@ inline LDOM_XmlWriter& LDOM_XmlWriter::operator << (const LXMLCh * aString)
//=======================================================================
inline LDOM_XmlWriter& LDOM_XmlWriter::operator << (const LXMLCh aChar)
{
fputc (aChar, myFile);
if (!myDevice.IsNull() && myDevice->CanWrite())
{
LXMLCh atmp = aChar;
myDevice->Write (&atmp, sizeof(LXMLCh));
}
else
{
fputc (aChar, myFile);
}
return * this;
}
@@ -316,7 +376,15 @@ void LDOM_XmlWriter::WriteAttribute (const LDOM_Node& theAtt)
chEqual, chDoubleQuote, encStr, chDoubleQuote);
if (encStr != aValue) delete [] encStr;
}
fwrite ((void *) myABuffer, aLength, 1, myFile);
if (!myDevice.IsNull() && myDevice->CanWrite())
{
myDevice->Write(myABuffer, aLength);
}
else
{
fwrite ((void *) myABuffer, aLength, 1, myFile);
}
}
//=======================================================================

8
src/LDOM/LDOM_XmlWriter.hxx
View File

@@ -16,6 +16,8 @@
#ifndef LDOM_XmlWriter_HeaderFile
#define LDOM_XmlWriter_HeaderFile
#include <Storage_IODevice.hxx>
#include <Standard_TypeDef.hxx>
#include <stdio.h>
@@ -29,9 +31,12 @@ class LDOM_XmlWriter
{
public:
Standard_EXPORT LDOM_XmlWriter (FILE * aFile, const char * theEncoding= NULL);
Standard_EXPORT LDOM_XmlWriter (FILE * aFile, const char* theEncoding = NULL);
// Constructor
Standard_EXPORT LDOM_XmlWriter(const Handle(Storage_IODevice)& theDevice,
const char * theEncoding = NULL );
Standard_EXPORT ~LDOM_XmlWriter ();
// Destructor
@@ -73,6 +78,7 @@ class LDOM_XmlWriter
Standard_Integer myCurIndent;
char * myABuffer; // for WriteAttribute()
Standard_Integer myABufferLen; // for WriteAttribute()
Handle(Storage_IODevice) myDevice;
};
#endif

9
src/MDataXtd/MDataXtd.cdl
View File

@@ -55,6 +55,9 @@ is
class PatternStdStorageDriver;
class PresentationStorageDriver;
class PositionStorageDriver;
---Category: Retrieval drivers for PDataXtd attributes
@@ -76,6 +79,12 @@ is
class PatternStdRetrievalDriver;
class PresentationRetrievalDriver;
class PresentationRetrievalDriver_1;
class PositionRetrievalDriver;
AddStorageDrivers(aDriverSeq : ASDriverHSequence from MDF; theMessageDriver : MessageDriver from CDM);

10
src/MDataXtd/MDataXtd.cxx
View File

@@ -34,6 +34,8 @@
#include <MDataXtd_ConstraintStorageDriver.hxx>
#include <MDataXtd_PlacementStorageDriver.hxx>
#include <MDataXtd_PatternStdStorageDriver.hxx>
#include <MDataXtd_PositionStorageDriver.hxx>
#include <MDataXtd_PositionRetrievalDriver.hxx>
// Retrieval
#include <MDataXtd_ShapeRetrievalDriver.hxx>
@@ -44,6 +46,9 @@
#include <MDataXtd_ConstraintRetrievalDriver.hxx>
#include <MDataXtd_PlacementRetrievalDriver.hxx>
#include <MDataXtd_PatternStdRetrievalDriver.hxx>
#include <MDataXtd_PresentationStorageDriver.hxx>
#include <MDataXtd_PresentationRetrievalDriver.hxx>
#include <MDataXtd_PresentationRetrievalDriver_1.hxx>
// enums
#include <TDataStd_RealEnum.hxx>
@@ -83,6 +88,8 @@ void MDataXtd::AddStorageDrivers
aDriverSeq->Append(new MDataXtd_ConstraintStorageDriver(theMsgDriver));
aDriverSeq->Append(new MDataXtd_PlacementStorageDriver(theMsgDriver));
aDriverSeq->Append(new MDataXtd_PatternStdStorageDriver(theMsgDriver));
aDriverSeq->Append(new MDataXtd_PresentationStorageDriver(theMsgDriver));
aDriverSeq->Append(new MDataXtd_PositionStorageDriver(theMsgDriver));
}
@@ -102,6 +109,9 @@ void MDataXtd::AddRetrievalDrivers
aDriverSeq->Append(new MDataXtd_ConstraintRetrievalDriver(theMsgDriver));
aDriverSeq->Append(new MDataXtd_PlacementRetrievalDriver(theMsgDriver));
aDriverSeq->Append(new MDataXtd_PatternStdRetrievalDriver(theMsgDriver));
aDriverSeq->Append(new MDataXtd_PresentationRetrievalDriver(theMsgDriver));
aDriverSeq->Append(new MDataXtd_PresentationRetrievalDriver_1(theMsgDriver));
aDriverSeq->Append(new MDataXtd_PositionRetrievalDriver(theMsgDriver));
}
//=======================================================================

6
src/MPrsStd/MPrsStd_PositionRetrievalDriver.cdl → src/MDataXtd/MDataXtd_PositionRetrievalDriver.cdl
View File

@@ -14,9 +14,9 @@
-- Alternatively, this file may be used under the terms of Open CASCADE
-- commercial license or contractual agreement.
class PositionRetrievalDriver from MPrsStd inherits ARDriver from MDF
class PositionRetrievalDriver from MDataXtd inherits ARDriver from MDF
---Purpose: Retrieval drivers for graphic attributes from
-- PPrsStd
-- PDataXtd
uses RRelocationTable from MDF,
@@ -28,7 +28,7 @@ is
Create(theMessageDriver : MessageDriver from CDM) -- Version 0
returns PositionRetrievalDriver from MPrsStd;
returns PositionRetrievalDriver from MDataXtd;
VersionNumber(me) returns Integer from Standard;

35
src/MPrsStd/MPrsStd_PositionRetrievalDriver.cxx → src/MDataXtd/MDataXtd_PositionRetrievalDriver.cxx
View File

@@ -14,50 +14,57 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <MPrsStd_PositionRetrievalDriver.ixx>
#include <MDataXtd_PositionRetrievalDriver.ixx>
#include <PDataXtd_Position.hxx>
#include <TDataXtd_Position.hxx>
#include <CDM_MessageDriver.hxx>
//=======================================================================
//function : MPrsStd_PositionRetrievalDriver
//function : MDataXtd_PositionRetrievalDriver
//purpose :
//=======================================================================
MPrsStd_PositionRetrievalDriver::MPrsStd_PositionRetrievalDriver(const Handle(CDM_MessageDriver)& theMsgDriver):MDF_ARDriver(theMsgDriver)
MDataXtd_PositionRetrievalDriver::MDataXtd_PositionRetrievalDriver(const Handle(CDM_MessageDriver)& theMsgDriver)
: MDF_ARDriver(theMsgDriver)
{}
//=======================================================================
//function : VersionNumber
//purpose :
//=======================================================================
Standard_Integer MPrsStd_PositionRetrievalDriver::VersionNumber() const
{ return 0; }
Standard_Integer MDataXtd_PositionRetrievalDriver::VersionNumber() const
{
return 0;
}
//=======================================================================
//function : SourceType
//purpose :
//=======================================================================
Handle(Standard_Type) MPrsStd_PositionRetrievalDriver::SourceType() const
{ return STANDARD_TYPE(PDataXtd_Position); }
Handle(Standard_Type) MDataXtd_PositionRetrievalDriver::SourceType() const
{
return STANDARD_TYPE(PDataXtd_Position);
}
//=======================================================================
//function : NewEmpty
//purpose :
//=======================================================================
Handle(TDF_Attribute) MPrsStd_PositionRetrievalDriver::NewEmpty() const
{ return new TDataXtd_Position; }
Handle(TDF_Attribute) MDataXtd_PositionRetrievalDriver::NewEmpty() const
{
return new TDataXtd_Position;
}
//=======================================================================
//function : Paste
//purpose :
//=======================================================================
void MPrsStd_PositionRetrievalDriver::Paste(const Handle(PDF_Attribute)& Source,
const Handle(TDF_Attribute)& Target,
const Handle(MDF_RRelocationTable)& /*RelocTable*/) const
void MDataXtd_PositionRetrievalDriver::Paste(const Handle(PDF_Attribute)& Source,
const Handle(TDF_Attribute)& Target,
const Handle(MDF_RRelocationTable)& /*RelocTable*/) const
{
Handle(PDataXtd_Position) S = Handle(PDataXtd_Position)::DownCast (Source);
Handle(TDataXtd_Position) T = Handle(TDataXtd_Position)::DownCast (Target);
Handle(PDataXtd_Position) S = Handle(PDataXtd_Position)::DownCast(Source);
Handle(TDataXtd_Position) T = Handle(TDataXtd_Position)::DownCast(Target);
T->SetPosition(S->GetPosition());
}

4
src/MPrsStd/MPrsStd_PositionStorageDriver.cdl → src/MDataXtd/MDataXtd_PositionStorageDriver.cdl
View File

@@ -14,7 +14,7 @@
-- Alternatively, this file may be used under the terms of Open CASCADE
-- commercial license or contractual agreement.
class PositionStorageDriver from MPrsStd inherits ASDriver from MDF
class PositionStorageDriver from MDataXtd inherits ASDriver from MDF
---Purpose: Storage driver for graphic attributes from
-- TPrsStd
@@ -28,7 +28,7 @@ uses SRelocationTable from MDF,
is
Create(theMessageDriver : MessageDriver from CDM)
returns PositionStorageDriver from MPrsStd;
returns PositionStorageDriver from MDataXtd;
VersionNumber(me) returns Integer from Standard;

18
src/MPrsStd/MPrsStd_PositionStorageDriver.cxx → src/MDataXtd/MDataXtd_PositionStorageDriver.cxx
View File

@@ -14,17 +14,17 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <MPrsStd_PositionStorageDriver.ixx>
#include <MDataXtd_PositionStorageDriver.ixx>
#include <PDataXtd_Position.hxx>
#include <TDataXtd_Position.hxx>
#include <CDM_MessageDriver.hxx>
//=======================================================================
//function : MPrsStd_PositionStorageDriver
//function : MDataXtd_PositionStorageDriver
//purpose :
//=======================================================================
MPrsStd_PositionStorageDriver::MPrsStd_PositionStorageDriver(const Handle(CDM_MessageDriver)& theMsgDriver):MDF_ASDriver(theMsgDriver)
MDataXtd_PositionStorageDriver::MDataXtd_PositionStorageDriver(const Handle(CDM_MessageDriver)& theMsgDriver):MDF_ASDriver(theMsgDriver)
{
}
@@ -32,30 +32,30 @@ MPrsStd_PositionStorageDriver::MPrsStd_PositionStorageDriver(const Handle(CDM_Me
//function : VersionNumber
//purpose :
//=======================================================================
Standard_Integer MPrsStd_PositionStorageDriver::VersionNumber() const
Standard_Integer MDataXtd_PositionStorageDriver::VersionNumber() const
{ return 0; }
//=======================================================================
//function : SourceType
//purpose :
//=======================================================================
Handle(Standard_Type) MPrsStd_PositionStorageDriver::SourceType() const
Handle(Standard_Type) MDataXtd_PositionStorageDriver::SourceType() const
{ return STANDARD_TYPE(TDataXtd_Position); }
//=======================================================================
//function : NewEmpty
//purpose :
//=======================================================================
Handle(PDF_Attribute) MPrsStd_PositionStorageDriver::NewEmpty() const
Handle(PDF_Attribute) MDataXtd_PositionStorageDriver::NewEmpty() const
{ return new PDataXtd_Position; }
//=======================================================================
//function : Paste
//purpose :
//=======================================================================
void MPrsStd_PositionStorageDriver::Paste(const Handle(TDF_Attribute)& Source,
const Handle(PDF_Attribute)& Target,
const Handle(MDF_SRelocationTable)& /*RelocTable*/) const
void MDataXtd_PositionStorageDriver::Paste(const Handle(TDF_Attribute)& Source,
const Handle(PDF_Attribute)& Target,
const Handle(MDF_SRelocationTable)& /*RelocTable*/) const
{
Handle(TDataXtd_Position) S = Handle(TDataXtd_Position)::DownCast (Source);
Handle(PDataXtd_Position) T = Handle(PDataXtd_Position)::DownCast (Target);

13
src/MPrsStd/MPrsStd_AISPresentationRetrievalDriver.cdl → src/MDataXtd/MDataXtd_PresentationRetrievalDriver.cdl
View File

@@ -14,10 +14,10 @@
-- Alternatively, this file may be used under the terms of Open CASCADE
-- commercial license or contractual agreement.
class AISPresentationRetrievalDriver from MPrsStd inherits ARDriver from MDF
class PresentationRetrievalDriver from MDataXtd inherits ARDriver from MDF
---Purpose: Retrieval drivers for graphic attributes from
-- PPrsStd
-- MDataXtd
uses RRelocationTable from MDF,
Attribute from PDF,
@@ -26,9 +26,8 @@ uses RRelocationTable from MDF,
is
Create(theMessageDriver : MessageDriver from CDM) -- Version 0
returns AISPresentationRetrievalDriver from MPrsStd;
returns PresentationRetrievalDriver from MDataXtd;
VersionNumber(me) returns Integer from Standard;
@@ -36,14 +35,14 @@ is
-- is available: 0.
SourceType(me) returns Type from Standard;
---Purpose: Returns the type: AISPresentation from PPrsStd.
---Purpose: Returns the type: Presentation from PDataXtd.
NewEmpty (me) returns Attribute from TDF;
Paste(me;
Source : Attribute from PDF;
Source : Attribute from PDF;
Target : Attribute from TDF;
RelocTable : RRelocationTable from MDF);
end AISPresentationRetrievalDriver;
end PresentationRetrievalDriver;

52
src/MPrsStd/MPrsStd_AISPresentationRetrievalDriver.cxx → src/MDataXtd/MDataXtd_PresentationRetrievalDriver.cxx
View File

@@ -14,51 +14,58 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <MPrsStd_AISPresentationRetrievalDriver.ixx>
#include <MDataXtd_PresentationRetrievalDriver.ixx>
#include <PPrsStd_AISPresentation.hxx>
#include <TPrsStd_AISPresentation.hxx>
#include <PDataXtd_Presentation.hxx>
#include <TDataXtd_Presentation.hxx>
#include <TCollection_ExtendedString.hxx>
#include <PCollection_HExtendedString.hxx>
#include <Quantity_NameOfColor.hxx>
#include <Graphic3d_NameOfMaterial.hxx>
#include <CDM_MessageDriver.hxx>
//=======================================================================
//function : MPrsStd_AISPresentationRetrievalDriver
//function : MDataXtd_PresentationRetrievalDriver
//purpose :
//=======================================================================
MPrsStd_AISPresentationRetrievalDriver::MPrsStd_AISPresentationRetrievalDriver(const Handle(CDM_MessageDriver)& theMsgDriver):MDF_ARDriver(theMsgDriver)
{}
MDataXtd_PresentationRetrievalDriver::MDataXtd_PresentationRetrievalDriver
(const Handle(CDM_MessageDriver)& theMsgDriver)
: MDF_ARDriver(theMsgDriver)
{
}
Standard_Integer MPrsStd_AISPresentationRetrievalDriver::VersionNumber() const
{ return 0; }
Standard_Integer MDataXtd_PresentationRetrievalDriver::VersionNumber() const
{
return 0;
}
Handle(Standard_Type) MPrsStd_AISPresentationRetrievalDriver::SourceType() const
{ return STANDARD_TYPE(PPrsStd_AISPresentation); }
Handle(Standard_Type) MDataXtd_PresentationRetrievalDriver::SourceType() const
{
return STANDARD_TYPE(PDataXtd_Presentation);
}
Handle(TDF_Attribute) MPrsStd_AISPresentationRetrievalDriver::NewEmpty() const
{ return new TPrsStd_AISPresentation; }
Handle(TDF_Attribute) MDataXtd_PresentationRetrievalDriver::NewEmpty() const
{
return new TDataXtd_Presentation;
}
void MPrsStd_AISPresentationRetrievalDriver::Paste(const Handle(PDF_Attribute)& Source,
void MDataXtd_PresentationRetrievalDriver::Paste(const Handle(PDF_Attribute)& Source,
const Handle(TDF_Attribute)& Target,
const Handle(MDF_RRelocationTable)& /*RelocTable*/) const
{
Handle(PPrsStd_AISPresentation) S = Handle(PPrsStd_AISPresentation)::DownCast (Source);
Handle(TPrsStd_AISPresentation) T = Handle(TPrsStd_AISPresentation)::DownCast (Target);
Handle(PDataXtd_Presentation) S = Handle(PDataXtd_Presentation)::DownCast (Source);
Handle(TDataXtd_Presentation) T = Handle(TDataXtd_Presentation)::DownCast (Target);
T->SetDisplayed( S->IsDisplayed() );
T->SetDisplayed( S->IsDisplayed() );
TCollection_ExtendedString extstr = (S->GetDriverGUID())->Convert();
Standard_GUID guid( extstr.ToExtString() );
TCollection_ExtendedString extstr = (S->GetDriverGUID())->Convert();
Standard_GUID guid( extstr.ToExtString() );
T->SetDriverGUID( guid );
if( S->Color() != -1 ) T->SetColor( (Quantity_NameOfColor)(S->Color()) );
if( S->Color() != -1 ) T->SetColor( S->Color() );
else T->UnsetColor();
if( S->Material() != -1 ) T->SetMaterial( (Graphic3d_NameOfMaterial)(S->Material()) );
if( S->Material() != -1 ) T->SetMaterial( S->Material() );
else T->UnsetMaterial();
if( S->Transparency() != -1. ) T->SetTransparency( S->Transparency() );
@@ -73,4 +80,3 @@ void MPrsStd_AISPresentationRetrievalDriver::Paste(const Handle(PDF_Attribute)&
cout << endl;
#endif
}

10
src/MPrsStd/MPrsStd_AISPresentationRetrievalDriver_1.cdl → src/MDataXtd/MDataXtd_PresentationRetrievalDriver_1.cdl
View File

@@ -14,10 +14,10 @@
-- Alternatively, this file may be used under the terms of Open CASCADE
-- commercial license or contractual agreement.
class AISPresentationRetrievalDriver_1 from MPrsStd inherits ARDriver from MDF
class PresentationRetrievalDriver_1 from MDataXtd inherits ARDriver from MDF
---Purpose: Retrieval drivers for graphic attributes from
-- PPrsStd
-- PDataXtd
uses RRelocationTable from MDF,
Attribute from PDF,
@@ -28,7 +28,7 @@ is
Create (theMessageDriver : MessageDriver from CDM) -- Version 1
returns AISPresentationRetrievalDriver_1 from MPrsStd;
returns PresentationRetrievalDriver_1 from MDataXtd;
VersionNumber(me) returns Integer from Standard;
@@ -36,7 +36,7 @@ is
-- is available: 1.
SourceType(me) returns Type from Standard;
---Purpose: Returns the type: AISPresentation from PPrsStd.
---Purpose: Returns the type: Presentation from PDataXtd.
NewEmpty (me) returns Attribute from TDF;
@@ -47,4 +47,4 @@ is
RelocTable : RRelocationTable from MDF);
end AISPresentationRetrievalDriver_1;
end PresentationRetrievalDriver_1;

60
src/MPrsStd/MPrsStd_AISPresentationRetrievalDriver_1.cxx → src/MDataXtd/MDataXtd_PresentationRetrievalDriver_1.cxx
View File

@@ -14,66 +14,68 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <MPrsStd_AISPresentationRetrievalDriver_1.ixx>
#include <MDataXtd_PresentationRetrievalDriver_1.ixx>
#include <PPrsStd_AISPresentation_1.hxx>
#include <TPrsStd_AISPresentation.hxx>
#include <PDataXtd_Presentation_1.hxx>
#include <TDataXtd_Presentation.hxx>
#include <TCollection_ExtendedString.hxx>
#include <PCollection_HExtendedString.hxx>
#include <Quantity_NameOfColor.hxx>
#include <Graphic3d_NameOfMaterial.hxx>
#include <CDM_MessageDriver.hxx>
//=======================================================================
//function : MPrsStd_AISPresentationRetrievalDriver_1
//function : MDataXtd_PresentationRetrievalDriver_1
//purpose :
//=======================================================================
MPrsStd_AISPresentationRetrievalDriver_1::MPrsStd_AISPresentationRetrievalDriver_1(const Handle(CDM_MessageDriver)& theMsgDriver):MDF_ARDriver(theMsgDriver)
MDataXtd_PresentationRetrievalDriver_1::MDataXtd_PresentationRetrievalDriver_1(const Handle(CDM_MessageDriver)& theMsgDriver)
:MDF_ARDriver(theMsgDriver)
{}
Standard_Integer MPrsStd_AISPresentationRetrievalDriver_1::VersionNumber() const
{ return 1; }
Standard_Integer MDataXtd_PresentationRetrievalDriver_1::VersionNumber() const
{
return 1;
}
Handle(Standard_Type) MPrsStd_AISPresentationRetrievalDriver_1::SourceType() const
{ return STANDARD_TYPE(PPrsStd_AISPresentation_1); }
Handle(Standard_Type) MDataXtd_PresentationRetrievalDriver_1::SourceType() const
{
return STANDARD_TYPE(PDataXtd_Presentation_1);
}
Handle(TDF_Attribute) MPrsStd_AISPresentationRetrievalDriver_1::NewEmpty() const
{ return new TPrsStd_AISPresentation; }
Handle(TDF_Attribute) MDataXtd_PresentationRetrievalDriver_1::NewEmpty() const
{
return new TDataXtd_Presentation;
}
void MPrsStd_AISPresentationRetrievalDriver_1::Paste(const Handle(PDF_Attribute)& Source,
void MDataXtd_PresentationRetrievalDriver_1::Paste(const Handle(PDF_Attribute)& Source,
const Handle(TDF_Attribute)& Target,
const Handle(MDF_RRelocationTable)& /*RelocTable*/) const
{
Handle(PPrsStd_AISPresentation_1) S = Handle(PPrsStd_AISPresentation_1)::DownCast (Source);
Handle(TPrsStd_AISPresentation) T = Handle(TPrsStd_AISPresentation)::DownCast (Target);
Handle(PDataXtd_Presentation_1) S = Handle(PDataXtd_Presentation_1)::DownCast (Source);
Handle(TDataXtd_Presentation) T = Handle(TDataXtd_Presentation)::DownCast (Target);
T->SetDisplayed( S->IsDisplayed() );
T->SetDisplayed( S->IsDisplayed() );
TCollection_ExtendedString extstr = (S->GetDriverGUID())->Convert();
Standard_GUID guid( extstr.ToExtString() );
T->SetDriverGUID( guid );
TCollection_ExtendedString extstr = (S->GetDriverGUID())->Convert();
Standard_GUID guid( extstr.ToExtString() );
if( S->Color() != -1 ) T->SetColor( (Quantity_NameOfColor)(S->Color()) );
T->SetDriverGUID( guid );
if( S->Color() != -1 ) T->SetColor( S->Color() );
else T->UnsetColor();
if( S->Material() != -1 ) T->SetMaterial( (Graphic3d_NameOfMaterial)(S->Material()) );
else T->UnsetMaterial();
if( S->Material() != -1 ) T->SetMaterial( S->Material() );
else T->UnsetMaterial();
if( S->Transparency() != -1. ) T->SetTransparency( S->Transparency() );
else T->UnsetTransparency();
if( S->Width() != -1. ) T->SetWidth( S->Width() );
else T->UnsetWidth();
else T->UnsetWidth();
T->SetMode(S->Mode());
#ifdef OCCT_DEBUG
cout << "AISPresentationRetrievalDriver " << "retrieved DriverGUID ==> ";
guid.ShallowDump(cout);
cout << endl;
#endif
}

10
src/MPrsStd/MPrsStd_AISPresentationStorageDriver.cdl → src/MDataXtd/MDataXtd_PresentationStorageDriver.cdl
View File

@@ -14,10 +14,10 @@
-- Alternatively, this file may be used under the terms of Open CASCADE
-- commercial license or contractual agreement.
class AISPresentationStorageDriver from MPrsStd inherits ASDriver from MDF
class PresentationStorageDriver from MDataXtd inherits ASDriver from MDF
---Purpose: Storage driver for graphic attributes from
-- TPrsStd
-- TDataXtd
uses SRelocationTable from MDF,
Attribute from TDF,
@@ -28,7 +28,7 @@ uses SRelocationTable from MDF,
is
Create (theMessageDriver : MessageDriver from CDM)
returns AISPresentationStorageDriver from MPrsStd;
returns PresentationStorageDriver from MDataXtd;
VersionNumber(me) returns Integer from Standard;
@@ -36,7 +36,7 @@ is
-- is available: 0.
SourceType(me) returns Type from Standard;
---Purpose: Returns the type: AISPresentation from TPrsStd.
---Purpose: Returns the type: Presentation from TDataXtd.
NewEmpty (me) returns Attribute from PDF;
@@ -47,5 +47,5 @@ is
RelocTable : SRelocationTable from MDF);
end AISPresentationStorageDriver;
end PresentationStorageDriver;

85
src/MDataXtd/MDataXtd_PresentationStorageDriver.cxx Normal file
View File

@@ -0,0 +1,85 @@
// Created on: 1997-07-08
// Created by: Sergey RUIN
// Copyright (c) 1997-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.
#include <MDataXtd_PresentationStorageDriver.ixx>
#include <PDataXtd_Presentation.hxx>
#include <PDataXtd_Presentation_1.hxx>
#include <TDataXtd_Presentation.hxx>
#include <TCollection_ExtendedString.hxx>
#include <PCollection_HExtendedString.hxx>
#include <CDM_MessageDriver.hxx>
//=======================================================================
//function : MDataXtd_PresentationStorageDriver
//purpose :
//=======================================================================
MDataXtd_PresentationStorageDriver::MDataXtd_PresentationStorageDriver(const Handle(CDM_MessageDriver)& theMsgDriver)
: MDF_ASDriver(theMsgDriver)
{
}
Standard_Integer MDataXtd_PresentationStorageDriver::VersionNumber() const
{
return 0;
}
Handle(Standard_Type) MDataXtd_PresentationStorageDriver::SourceType() const
{
return STANDARD_TYPE(TDataXtd_Presentation);
}
Handle(PDF_Attribute) MDataXtd_PresentationStorageDriver::NewEmpty() const
{
return new PDataXtd_Presentation_1;
}
void MDataXtd_PresentationStorageDriver::Paste(const Handle(TDF_Attribute)& Source,
const Handle(PDF_Attribute)& Target,
const Handle(MDF_SRelocationTable)& /*RelocTable*/) const
{
Handle(TDataXtd_Presentation) S = Handle(TDataXtd_Presentation)::DownCast(Source);
Handle(PDataXtd_Presentation_1) T = Handle(PDataXtd_Presentation_1)::DownCast(Target);
T->SetDisplayed( S->IsDisplayed() );
TCollection_ExtendedString extstr("00000000-0000-0000-0000-000000000000"); //covert GUID into ExtendedString
Standard_PExtCharacter pStr = const_cast<Standard_PExtCharacter>(extstr.ToExtString());
S->GetDriverGUID().ToExtString(pStr);
Handle(PCollection_HExtendedString) guid = new PCollection_HExtendedString ( extstr );
T->SetDriverGUID ( guid );
if( S->IsHasOwnColor() ) T->SetColor( S->Color() );
else T->SetColor(-1);
if( S->IsHasOwnMaterial() ) T->SetMaterial( S->Material() );
else T->SetMaterial(-1);
if( S->IsHasOwnTransparency() ) T->SetTransparency( S->Transparency() );
else T->SetTransparency(-1.);
if( S->IsHasOwnWidth() ) T->SetWidth( S->Width() );
else T->SetWidth(-1.);
T->SetMode(S->Mode());
#ifdef OCCT_DEBUG
cout << "AISPresentationStorageDriver " << "storaged DriverGUID ==> " << guid->Convert() << endl;
#endif
}

56
src/MPrsStd/MPrsStd.cdl
View File

@@ -1,56 +0,0 @@
-- Created on: 1997-08-26
-- Created by: SMO
-- Copyright (c) 1997-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.
package MPrsStd
---Purpose: Storage and Retrieval drivers for graphic
-- attributes. Transient attributes are defined in
-- package TPrsStd and persistent one are defined in
-- package PPrsStd
uses TDF,
PDF,
MDF,
CDM
is
---Category: StorageDriver
class AISPresentationStorageDriver;
class PositionStorageDriver;
---Category: RetrievalDriver
class AISPresentationRetrievalDriver;
class AISPresentationRetrievalDriver_1;
class PositionRetrievalDriver;
AddStorageDrivers(aDriverTable : ASDriverHSequence from MDF;theMessageDriver : MessageDriver from CDM);
---Purpose: Adds the attribute storage drivers to <aDriverTable>.
---Category: StorageDriversTable
AddRetrievalDrivers(aDriverTable : ARDriverHSequence from MDF;theMessageDriver : MessageDriver from CDM);
---Purpose: Adds the attribute retrieval drivers to <aDriverTable>.
---Category: RetrievalDriversTable
end MPrsStd;

56
src/MPrsStd/MPrsStd.cxx
View File

@@ -1,56 +0,0 @@
// Created on: 1997-08-26
// Created by: Guest Design
// Copyright (c) 1997-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.
#include <MPrsStd.ixx>
#include <MDF_ASDriverHSequence.hxx>
#include <MDF_ARDriverHSequence.hxx>
#include <MPrsStd_AISPresentationStorageDriver.hxx>
#include <MPrsStd_AISPresentationRetrievalDriver.hxx>
#include <MPrsStd_AISPresentationRetrievalDriver_1.hxx>
//#include <MPrsStd_AISViewerStorageDriver.hxx>
//#include <MPrsStd_AISViewerRetrievalDriver.hxx>
#include <MPrsStd_PositionStorageDriver.hxx>
#include <MPrsStd_PositionRetrievalDriver.hxx>
//=======================================================================
//function : AddStorageDriver
//purpose :
//=======================================================================
void MPrsStd::AddStorageDrivers
(const Handle(MDF_ASDriverHSequence)& aDriverSeq, const Handle(CDM_MessageDriver)& theMsgDriver)
{
aDriverSeq->Append(new MPrsStd_AISPresentationStorageDriver(theMsgDriver));
// aDriverSeq->Append(new MPrsStd_AISViewerStorageDriver());
aDriverSeq->Append(new MPrsStd_PositionStorageDriver(theMsgDriver));
}
//=======================================================================
//function : AddRetrievalDriver
//purpose :
//=======================================================================
void MPrsStd::AddRetrievalDrivers
(const Handle(MDF_ARDriverHSequence)& aDriverSeq, const Handle(CDM_MessageDriver)& theMsgDriver)
{
aDriverSeq->Append(new MPrsStd_AISPresentationRetrievalDriver(theMsgDriver));
aDriverSeq->Append(new MPrsStd_AISPresentationRetrievalDriver_1(theMsgDriver));
// aDriverSeq->Append(new MPrsStd_AISViewerRetrievalDriver());
aDriverSeq->Append(new MPrsStd_PositionRetrievalDriver(theMsgDriver));
}

90
src/MPrsStd/MPrsStd_AISPresentationStorageDriver.cxx
View File

@@ -1,90 +0,0 @@
// Created on: 1997-07-08
// Created by: Sergey RUIN
// Copyright (c) 1997-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.
#include <MPrsStd_AISPresentationStorageDriver.ixx>
#include <PPrsStd_AISPresentation.hxx>
#include <PPrsStd_AISPresentation_1.hxx>
#include <TPrsStd_AISPresentation.hxx>
#include <AIS_InteractiveObject.hxx>
#include <AIS_InteractiveContext.hxx>
#include <V3d_Viewer.hxx>
#include <TCollection_ExtendedString.hxx>
#include <PCollection_HExtendedString.hxx>
#include <CDM_MessageDriver.hxx>
//=======================================================================
//function : MPrsStd_AISPresentationStorageDriver
//purpose :
//=======================================================================
MPrsStd_AISPresentationStorageDriver::MPrsStd_AISPresentationStorageDriver(const Handle(CDM_MessageDriver)& theMsgDriver):MDF_ASDriver(theMsgDriver)
{
}
Standard_Integer MPrsStd_AISPresentationStorageDriver::VersionNumber() const
{ return 0; }
Handle(Standard_Type) MPrsStd_AISPresentationStorageDriver::SourceType() const
{ return STANDARD_TYPE(TPrsStd_AISPresentation); }
Handle(PDF_Attribute) MPrsStd_AISPresentationStorageDriver::NewEmpty() const
{
// return new PPrsStd_AISPresentation;
return new PPrsStd_AISPresentation_1;
}
void MPrsStd_AISPresentationStorageDriver::Paste(const Handle(TDF_Attribute)& Source,
const Handle(PDF_Attribute)& Target,
const Handle(MDF_SRelocationTable)& /*RelocTable*/) const
{
Handle(TPrsStd_AISPresentation) S = Handle(TPrsStd_AISPresentation)::DownCast (Source);
// Handle(PPrsStd_AISPresentation) T = Handle(PPrsStd_AISPresentation)::DownCast (Target);
Handle(PPrsStd_AISPresentation_1) T = Handle(PPrsStd_AISPresentation_1)::DownCast (Target);
T->SetDisplayed( S->IsDisplayed() );
TCollection_ExtendedString extstr("00000000-0000-0000-0000-000000000000"); //covert GUID into ExtendedString
Standard_PExtCharacter pStr;
//
pStr=(Standard_PExtCharacter)extstr.ToExtString();
S->GetDriverGUID().ToExtString(pStr);
Handle(PCollection_HExtendedString) guid = new PCollection_HExtendedString ( extstr );
T->SetDriverGUID ( guid );
if( S->HasOwnColor() ) T->SetColor( (Standard_Integer)(S->Color()) );
else T->SetColor(-1);
if( S->HasOwnMaterial() ) T->SetMaterial( (Standard_Integer)(S->Material()) );
else T->SetMaterial(-1);
if( S->HasOwnTransparency() ) T->SetTransparency( S->Transparency() );
else T->SetTransparency(-1.);
if( S->HasOwnWidth() ) T->SetWidth( S->Width() );
else T->SetWidth(-1.);
T->SetMode(S->Mode());
#ifdef OCCT_DEBUG
cout << "AISPresentationStorageDriver " << "storaged DriverGUID ==> " << guid->Convert() << endl;
#endif
}

2
src/OS/ApplicationFramework.tcl
View File

@@ -58,7 +58,7 @@ proc ApplicationFramework:alias { } {
return CAF
}
proc ApplicationFramework:depends { } {
return [list Visualization]
return [list ModelingAlgorithms]
}
;#
;# Pre-requis pour la compilation ( -I ... )

2
src/OS/Draw.tcl
View File

@@ -15,7 +15,7 @@
;# Liste des toolkits WOK sous forme de full path
;#
proc Draw:toolkits { } {
set aResult [list TKDraw TKTopTest TKViewerTest TKXSDRAW TKDCAF TKXDEDRAW TKTObjDRAW TKQADraw]
set aResult [list TKDraw TKTopTest TKViewerTest TKVCAF TKXSDRAW TKDCAF TKXDEDRAW TKTObjDRAW TKQADraw]
if { [info exists ::env(HAVE_VTK)] && $::env(HAVE_VTK) == "true" } {
lappend aResult "TKIVtkDraw"

7
src/PCDM/PCDM.cdl
View File

@@ -20,7 +20,6 @@ uses
CDM,TColStd,TCollection,Storage
is
enumeration ReaderStatus is
@@ -70,7 +69,8 @@ is
---Category: exceptions
exception DriverError inherits Failure from Standard;
exception WriteError inherits Failure from Standard;
exception ReadError inherits Failure from Standard;
---Category: classes for versioning reading/writing og the headers.
private class Reference;
@@ -105,7 +105,8 @@ is
-- the SchemaName method.
returns Schema from Storage;
FileDriverType(aFileName: AsciiString from TCollection; aBaseDriver: out BaseDriverPointer from PCDM)
FileDriverType(aDevice: IODevice from Storage; aBaseDriver: out BaseDriverPointer from PCDM)
returns TypeOfFileDriver from PCDM
is private;
end PCDM;

8
src/PCDM/PCDM.cxx
View File

@@ -79,16 +79,16 @@ Handle(Storage_Schema) PCDM::Schema(const TCollection_ExtendedString& aSchemaNam
//purpose :
//=======================================================================
PCDM_TypeOfFileDriver PCDM::FileDriverType(const TCollection_AsciiString& aFileName, PCDM_BaseDriverPointer& aBaseDriver) {
if(FSD_CmpFile::IsGoodFileType(aFileName) == Storage_VSOk) {
PCDM_TypeOfFileDriver PCDM::FileDriverType(const Handle(Storage_IODevice)& aDevice, PCDM_BaseDriverPointer& aBaseDriver) {
if(FSD_CmpFile::IsGoodFileType(aDevice) == Storage_VSOk) {
aBaseDriver=new FSD_CmpFile;
return PCDM_TOFD_CmpFile;
}
else if(FSD_File::IsGoodFileType(aFileName) == Storage_VSOk) {
else if(FSD_File::IsGoodFileType(aDevice) == Storage_VSOk) {
aBaseDriver=new FSD_File;
return PCDM_TOFD_File;
}
else if(FSD_BinaryFile::IsGoodFileType(aFileName) == Storage_VSOk) {
else if(FSD_BinaryFile::IsGoodFileType(aDevice) == Storage_VSOk) {
aBaseDriver=new FSD_BinaryFile;
return PCDM_TOFD_File;
}

34
src/PCDM/PCDM_DOMHeaderParser.cxx
View File

@@ -15,6 +15,40 @@
#include <PCDM_DOMHeaderParser.hxx>
#include <Storage_File.hxx>
#include <Storage_IStream.hxx>
Standard_Boolean PCDM_DOMHeaderParser::parse( const Handle(Storage_IODevice)& anInput )
{
Standard_Boolean aRes = Standard_True;
Handle(Storage_File) aFile = Handle(Storage_File)::DownCast(anInput);
if ( !aFile.IsNull() )
{
TCollection_AsciiString aPath( aFile->Path() );
aRes = LDOMParser::parse( aPath.ToCString() );
}
else if ( !anInput.IsNull() && anInput->CanRead() )
{
Standard_Size aSize = 8000;
char* aBuf = (char*)malloc( aSize );
anInput->Open(Storage_VSRead);
std::string aStr;
while ( !anInput->IsEnd() )
{
Standard_Size aNum = anInput->Read( aBuf, aSize );
aStr.append( aBuf, aNum );
}
anInput->Close();
free( aBuf );
Standard_SStream aStream( std::ios::in );
aStream.str( aStr );
aRes = LDOMParser::parse( aStream );
}
return aRes;
}
//=======================================================================
//function : SetStartElementName
//purpose : set the name of the element which would stop parsing when detected

4
src/PCDM/PCDM_DOMHeaderParser.hxx
View File

@@ -18,6 +18,8 @@
#include <LDOMParser.hxx>
#include <Storage_IODevice.hxx>
// Block of comments describing class PCDM_DOMHeaderParser
class PCDM_DOMHeaderParser : public LDOMParser
@@ -25,6 +27,8 @@ class PCDM_DOMHeaderParser : public LDOMParser
public:
// ---------- PUBLIC METHODS ----------
Standard_Boolean parse (const Handle(Storage_IODevice)& anInput);
void SetStartElementName (const TCollection_AsciiString& aStartElementName);
// set the name of the element which would stop parsing when detected

18
src/PCDM/PCDM_ReadWriter.cdl
View File

@@ -25,6 +25,7 @@ uses
SequenceOfExtendedString from TColStd,
BaseDriver from Storage,
OpenMode from Storage,
IODevice from Storage,
SequenceOfReference from PCDM
is
@@ -37,7 +38,7 @@ is
WriteReferenceCounter(me; aData: Data from Storage; aDocument: Document from CDM)
is deferred;
WriteReferences(me; aData: Data from Storage; aDocument: Document from CDM; theReferencerFileName: ExtendedString from TCollection)
WriteReferences(me; aData: Data from Storage; aDocument: Document from CDM; theReferencer: IODevice from Storage)
is deferred;
@@ -49,27 +50,27 @@ is
is deferred;
ReadReferenceCounter(me; theFileName: ExtendedString from TCollection;
ReadReferenceCounter(me; theDevice: IODevice from Storage;
theMsgDriver: MessageDriver from CDM)
returns Integer from Standard
is deferred;
ReadReferences(me; aFileName: ExtendedString from TCollection; theReferences: in out SequenceOfReference from PCDM; theMsgDriver: MessageDriver from CDM)
ReadReferences(me; aDevice: IODevice from Storage; theReferences: in out SequenceOfReference from PCDM; theMsgDriver: MessageDriver from CDM)
is deferred;
ReadExtensions(me; aFileName: ExtendedString from TCollection; theExtensions: in out SequenceOfExtendedString from TColStd; theMsgDriver: MessageDriver from CDM)
ReadExtensions(me; aDevice: IODevice from Storage; theExtensions: in out SequenceOfExtendedString from TColStd; theMsgDriver: MessageDriver from CDM)
is deferred;
ReadDocumentVersion(me; aFileName: ExtendedString from TCollection; theMsgDriver: MessageDriver from CDM)
ReadDocumentVersion(me; aDevice: IODevice from Storage; theMsgDriver: MessageDriver from CDM)
returns Integer from Standard
is deferred;
---Category: commom methods
Open(myclass; aDriver: in out BaseDriver from Storage; aFileName: ExtendedString from TCollection; anOpenMode: OpenMode from Storage);
Open(myclass; aDriver: in out BaseDriver from Storage; aDevice: IODevice from Storage; anOpenMode: OpenMode from Storage);
Reader(myclass; aFileName: ExtendedString from TCollection)
Reader(myclass; aDevice: IODevice from Storage)
returns ReadWriter from PCDM;
---Purpose: returns the convenient Reader for a File.
--
@@ -80,9 +81,10 @@ is
WriteFileFormat(myclass; aData: Data from Storage; aDocument: Document from CDM);
FileFormat(myclass; aFileName: ExtendedString from TCollection)
FileFormat(myclass; aDevice: IODevice from Storage)
returns ExtendedString from TCollection;
---Purpose: tries to get a format in the file. returns an empty
-- string if the file could not be read or does not have
-- a FileFormat information.
end ReadWriter from PCDM;

36
src/PCDM/PCDM_ReadWriter.cxx
View File

@@ -27,8 +27,7 @@
#define FILE_FORMAT "FILE_FORMAT: "
static TCollection_ExtendedString TryXmlDriverType
(const TCollection_AsciiString& theFileName);
static TCollection_ExtendedString TryXmlDriverType(const Handle(Storage_IODevice)& theDevice);
//=======================================================================
//function : Open
@@ -36,13 +35,14 @@ static TCollection_ExtendedString TryXmlDriverType
//=======================================================================
void PCDM_ReadWriter::Open (Storage_BaseDriver& aDriver,
const TCollection_ExtendedString& aFileName,
const Handle(Storage_IODevice)& aDevice,
const Storage_OpenMode aMode)
{
Storage_Error error = UTL::OpenFile(aDriver,aFileName,aMode);
Storage_Error error = aDriver.Open(aDevice, aMode);
if(error != Storage_VSOk) {
Standard_SStream aMsg; aMsg << "could not open the file: ";
aMsg << aFileName;
aMsg << aDevice;
switch (error) {
case Storage_VSOpenError: aMsg << "; file was not found or permission denied"; break;
case Storage_VSAlreadyOpen: aMsg<< "; file was already opened";
@@ -61,8 +61,7 @@ void PCDM_ReadWriter::Open (Storage_BaseDriver& aDriver,
//Handle(PCDM_ReadWriter) PCDM_ReadWriter::Reader(const TCollection_ExtendedString& aFileName) {
Handle(PCDM_ReadWriter) PCDM_ReadWriter::Reader
(const TCollection_ExtendedString&)
Handle(PCDM_ReadWriter) PCDM_ReadWriter::Reader(const Handle(Storage_IODevice)&)
{
static Handle(PCDM_ReadWriter_1) theReader=new PCDM_ReadWriter_1;
return theReader;
@@ -98,26 +97,24 @@ void PCDM_ReadWriter::WriteFileFormat (const Handle(Storage_Data)& aData,
//purpose :
//=======================================================================
TCollection_ExtendedString PCDM_ReadWriter::FileFormat
(const TCollection_ExtendedString& aFileName)
TCollection_ExtendedString PCDM_ReadWriter::FileFormat(const Handle(Storage_IODevice)& aDevice)
{
TCollection_ExtendedString theFormat;
PCDM_BaseDriverPointer theFileDriver;
// conversion to UTF-8 is done inside
TCollection_AsciiString theFileName (aFileName);
if (PCDM::FileDriverType (theFileName, theFileDriver) == PCDM_TOFD_Unknown)
return ::TryXmlDriverType (theFileName);
if (PCDM::FileDriverType (aDevice, theFileDriver) == PCDM_TOFD_Unknown)
return ::TryXmlDriverType (aDevice);
static Standard_Boolean theFileIsOpen;
theFileIsOpen=Standard_False;
static Standard_Boolean aDeviceIsOpen;
aDeviceIsOpen = Standard_False;
try {
OCC_CATCH_SIGNALS
Open(*theFileDriver,aFileName,Storage_VSRead);
theFileIsOpen=Standard_True;
Open(*theFileDriver, aDevice, Storage_VSRead);
aDeviceIsOpen = Standard_True;
Handle(Storage_Schema) s = new Storage_Schema;
Handle(Storage_HeaderData) hd = s->ReadHeaderSection(*theFileDriver);
const TColStd_SequenceOfAsciiString &refUserInfo = hd->UserInfo();
@@ -134,7 +131,7 @@ TCollection_ExtendedString PCDM_ReadWriter::FileFormat
catch (Standard_Failure) {}
if(theFileIsOpen)theFileDriver->Close();
if(aDeviceIsOpen)theFileDriver->Close();
delete theFileDriver;
@@ -146,8 +143,7 @@ TCollection_ExtendedString PCDM_ReadWriter::FileFormat
//purpose : called from FileFormat()
//=======================================================================
static TCollection_ExtendedString TryXmlDriverType
(const TCollection_AsciiString& theFileName)
static TCollection_ExtendedString TryXmlDriverType(const Handle(Storage_IODevice)& theDevice)
{
TCollection_ExtendedString theFormat;
PCDM_DOMHeaderParser aParser;
@@ -156,7 +152,7 @@ static TCollection_ExtendedString TryXmlDriverType
// Parse the file; if there is no error or an error appears before retrieval
// of the DocumentElement, the XML format cannot be defined
if (aParser.parse (theFileName.ToCString()))
if (aParser.parse (theDevice))
{
LDOM_Element anElement = aParser.GetElement();
if (anElement.getTagName().equals (LDOMString(aDocumentElementName)))

17
src/PCDM/PCDM_ReadWriter_1.cdl
View File

@@ -20,6 +20,7 @@ uses
ExtendedString from TCollection,
AsciiString from TCollection,
Data from Storage,
IODevice from Storage,
Document from CDM,
MessageDriver from CDM,
SequenceOfExtendedString from TColStd,
@@ -34,28 +35,24 @@ is
WriteReferenceCounter(me; aData: Data from Storage; aDocument: Document from CDM);
WriteReferences(me; aData: Data from Storage; aDocument: Document from CDM; theReferencerFileName: ExtendedString from TCollection);
WriteReferences(me; aData: Data from Storage; aDocument: Document from CDM; theReferencer: IODevice from Storage);
WriteExtensions(me; aData: Data from Storage; aDocument: Document from CDM);
WriteVersion(me; aData: Data from Storage; aDocument: Document from CDM);
ReadReferenceCounter(me; aFileName: ExtendedString from TCollection; theMsgDriver: MessageDriver from CDM)
ReadReferenceCounter(me; aDevice: IODevice from Storage; theMsgDriver: MessageDriver from CDM)
returns Integer from Standard;
ReadReferences(me; aFileName: ExtendedString from TCollection; theReferences: in out SequenceOfReference from PCDM; theMsgDriver: MessageDriver from CDM);
ReadReferences(me; aDevice: IODevice from Storage; theReferences: in out SequenceOfReference from PCDM; theMsgDriver: MessageDriver from CDM);
ReadExtensions(me; aFileName: ExtendedString from TCollection; theExtensions: in out SequenceOfExtendedString from TColStd; theMsgDriver: MessageDriver from CDM);
ReadExtensions(me; aDevice: IODevice from Storage; theExtensions: in out SequenceOfExtendedString from TColStd; theMsgDriver: MessageDriver from CDM);
ReadUserInfo(myclass; aFileName: ExtendedString from TCollection; Start, End: AsciiString from TCollection; theUserInfo:in out SequenceOfExtendedString from TColStd;theMsgDriver: MessageDriver from CDM)
ReadUserInfo(myclass; aDevice: IODevice from Storage; Start, End: AsciiString from TCollection; theUserInfo:in out SequenceOfExtendedString from TColStd;theMsgDriver: MessageDriver from CDM)
is private;
ReadDocumentVersion(me; aFileName: ExtendedString from TCollection; theMsgDriver: MessageDriver from CDM)
ReadDocumentVersion(me; aDevice: IODevice from Storage; theMsgDriver: MessageDriver from CDM)
returns Integer from Standard;
end ReadWriter_1 from PCDM;

71
src/PCDM/PCDM_ReadWriter_1.cxx
View File

@@ -25,6 +25,7 @@
#include <TColStd_SequenceOfExtendedString.hxx>
#include <Storage_Schema.hxx>
#include <Storage_HeaderData.hxx>
#include <Storage_File.hxx>
#include <TColStd_SequenceOfAsciiString.hxx>
#include <PCDM_Reference.hxx>
#include <Standard_ErrorHandler.hxx>
@@ -32,6 +33,8 @@
#include <PCDM_BaseDriverPointer.hxx>
#include <PCDM.hxx>
#include <PCDM_TypeOfFileDriver.hxx>
#include <PCDM_WriteError.hxx>
#include <PCDM_ReadError.hxx>
#define START_REF "START_REF"
#define END_REF "END_REF"
@@ -153,18 +156,24 @@ void PCDM_ReadWriter_1::WriteReferenceCounter(const Handle(Storage_Data)& aData,
//purpose :
//=======================================================================
void PCDM_ReadWriter_1::WriteReferences(const Handle(Storage_Data)& aData, const Handle(CDM_Document)& aDocument,const TCollection_ExtendedString& theReferencerFileName) const {
void PCDM_ReadWriter_1::WriteReferences(const Handle(Storage_Data)& aData, const Handle(CDM_Document)& aDocument,const Handle(Storage_IODevice)& theReferencer) const {
Standard_Integer theNumber = aDocument->ToReferencesNumber();
if(theNumber > 0) {
Handle(Storage_File) aFileDevice = Handle(Storage_File)::DownCast(theReferencer);
if ( aFileDevice.IsNull() )
{
PCDM_WriteError::Raise( "Can't save references of document which was not stored to file" );
}
aData->AddToUserInfo(START_REF);
CDM_ReferenceIterator it(aDocument);
TCollection_ExtendedString ligne;
TCollection_AsciiString theAbsoluteDirectory=GetDirFromFile(theReferencerFileName);
TCollection_AsciiString theAbsoluteDirectory=GetDirFromFile(aFileDevice->Path());
for (;it.More();it.Next()) {
ligne = TCollection_ExtendedString(it.ReferenceIdentifier());
@@ -172,7 +181,14 @@ void PCDM_ReadWriter_1::WriteReferences(const Handle(Storage_Data)& aData, const
ligne += TCollection_ExtendedString(it.Document()->Modifications());
ligne += " ";
TCollection_AsciiString thePath(it.Document()->MetaData()->FileName());
Handle(Storage_File) aFileDevice = Handle(Storage_File)::DownCast(it.Document()->MetaData()->Device());
if ( aFileDevice.IsNull() )
{
PCDM_WriteError::Raise( "Can't save reference to document which was not retrieved from file" );
}
TCollection_AsciiString thePath = aFileDevice->Path();
TCollection_AsciiString theRelativePath;
if(!theAbsoluteDirectory.IsEmpty()) {
theRelativePath=OSD_Path::RelativePath(theAbsoluteDirectory,thePath);
@@ -219,15 +235,14 @@ void PCDM_ReadWriter_1::WriteVersion(const Handle(Storage_Data)& aData, const Ha
//purpose :
//=======================================================================
Standard_Integer PCDM_ReadWriter_1::ReadReferenceCounter(const TCollection_ExtendedString& aFileName, const Handle(CDM_MessageDriver)& theMsgDriver) const {
Standard_Integer PCDM_ReadWriter_1::ReadReferenceCounter(const Handle(Storage_IODevice)& aDevice, const Handle(CDM_MessageDriver)& theMsgDriver) const {
static Standard_Integer theReferencesCounter ;
theReferencesCounter=0;
static Standard_Integer i ;
PCDM_BaseDriverPointer theFileDriver;
TCollection_AsciiString aFileNameU(aFileName);
if(PCDM::FileDriverType(aFileNameU, theFileDriver) == PCDM_TOFD_Unknown)
if(PCDM::FileDriverType(aDevice, theFileDriver) == PCDM_TOFD_Unknown)
return theReferencesCounter;
static Standard_Boolean theFileIsOpen ;
@@ -235,7 +250,7 @@ Standard_Integer PCDM_ReadWriter_1::ReadReferenceCounter(const TCollection_Exten
try {
OCC_CATCH_SIGNALS
PCDM_ReadWriter::Open(*theFileDriver,aFileName,Storage_VSRead);
PCDM_ReadWriter::Open(*theFileDriver,aDevice,Storage_VSRead);
theFileIsOpen=Standard_True;
Handle(Storage_Schema) s = new Storage_Schema;
@@ -248,13 +263,12 @@ Standard_Integer PCDM_ReadWriter_1::ReadReferenceCounter(const TCollection_Exten
catch (Standard_Failure) {
// cout << "warning: could not read the reference counter in " << aFileName << endl;
TCollection_ExtendedString aMsg("Warning: ");
aMsg = aMsg.Cat("could not read the reference counter in ").Cat(aFileName).Cat("\0");
aMsg = aMsg.Cat("could not read the reference counter in ").Cat("\0");
if(!theMsgDriver.IsNull())
theMsgDriver->Write(aMsg.ToExtString());
}
}
}
}
catch (Standard_Failure) {}
@@ -269,17 +283,25 @@ Standard_Integer PCDM_ReadWriter_1::ReadReferenceCounter(const TCollection_Exten
//purpose :
//=======================================================================
void PCDM_ReadWriter_1::ReadReferences(const TCollection_ExtendedString& aFileName, PCDM_SequenceOfReference& theReferences, const Handle(CDM_MessageDriver)& theMsgDriver) const {
void PCDM_ReadWriter_1::ReadReferences(const Handle(Storage_IODevice)& aDevice, PCDM_SequenceOfReference& theReferences, const Handle(CDM_MessageDriver)& theMsgDriver) const {
TColStd_SequenceOfExtendedString ReadReferences;
ReadUserInfo(aFileName,START_REF,END_REF,ReadReferences, theMsgDriver);
ReadUserInfo(aDevice,START_REF,END_REF,ReadReferences, theMsgDriver);
Standard_Integer theReferenceIdentifier;
TCollection_ExtendedString theFileName;
Standard_Integer theDocumentVersion;
TCollection_AsciiString theAbsoluteDirectory=GetDirFromFile(aFileName);
Handle(Storage_File) aFileDevice = Handle(Storage_File)::DownCast(aDevice);
if ( aFileDevice.IsNull() )
{
return;
//PCDM_ReadError::Raise( "Can't read references for document which was not retrieved from file" );
}
TCollection_AsciiString theAbsoluteDirectory = GetDirFromFile(aFileDevice->Path());
for (Standard_Integer i=1; i<=ReadReferences.Length(); i++) {
Standard_Integer pos=ReadReferences(i).Search(" ");
@@ -304,8 +326,8 @@ void PCDM_ReadWriter_1::ReadReferences(const TCollection_ExtendedString& aFileNa
aMsg = aMsg.Cat("reference found; ReferenceIdentifier: ").Cat(theReferenceIdentifier).Cat("; File:").Cat(thePath).Cat(", version:").Cat(theDocumentVersion).Cat("\0");
theMsgDriver->Write(aMsg.ToExtString());
}
TCollection_ExtendedString aPathW(thePath);
theReferences.Append(PCDM_Reference (theReferenceIdentifier,aPathW,theDocumentVersion));
;
theReferences.Append(PCDM_Reference (theReferenceIdentifier,new Storage_File( TCollection_ExtendedString( thePath ) ),theDocumentVersion));
}
}
@@ -317,9 +339,9 @@ void PCDM_ReadWriter_1::ReadReferences(const TCollection_ExtendedString& aFileNa
//purpose :
//=======================================================================
void PCDM_ReadWriter_1::ReadExtensions(const TCollection_ExtendedString& aFileName, TColStd_SequenceOfExtendedString& theExtensions, const Handle(CDM_MessageDriver)& theMsgDriver) const {
void PCDM_ReadWriter_1::ReadExtensions(const Handle(Storage_IODevice)& aDevice, TColStd_SequenceOfExtendedString& theExtensions, const Handle(CDM_MessageDriver)& theMsgDriver) const {
ReadUserInfo(aFileName,START_EXT,END_EXT,theExtensions, theMsgDriver);
ReadUserInfo(aDevice,START_EXT,END_EXT,theExtensions, theMsgDriver);
}
@@ -328,7 +350,7 @@ void PCDM_ReadWriter_1::ReadExtensions(const TCollection_ExtendedString& aFileNa
//purpose :
//=======================================================================
void PCDM_ReadWriter_1::ReadUserInfo(const TCollection_ExtendedString& aFileName,
void PCDM_ReadWriter_1::ReadUserInfo(const Handle(Storage_IODevice)& aDevice,
const TCollection_AsciiString& Start,
const TCollection_AsciiString& End,
TColStd_SequenceOfExtendedString& theUserInfo,
@@ -336,11 +358,10 @@ void PCDM_ReadWriter_1::ReadUserInfo(const TCollection_ExtendedString& aFileName
static Standard_Integer i ;
PCDM_BaseDriverPointer theFileDriver;
TCollection_AsciiString aFileNameU(aFileName);
if(PCDM::FileDriverType(aFileNameU, theFileDriver) == PCDM_TOFD_Unknown)
if(PCDM::FileDriverType(aDevice, theFileDriver) == PCDM_TOFD_Unknown)
return;
PCDM_ReadWriter::Open(*theFileDriver,aFileName,Storage_VSRead);
PCDM_ReadWriter::Open(*theFileDriver,aDevice,Storage_VSRead);
Handle(Storage_Schema) s = new Storage_Schema;
Handle(Storage_HeaderData) hd = s->ReadHeaderSection(*theFileDriver);
const TColStd_SequenceOfAsciiString &refUserInfo = hd->UserInfo();
@@ -367,14 +388,13 @@ void PCDM_ReadWriter_1::ReadUserInfo(const TCollection_ExtendedString& aFileName
//purpose :
//=======================================================================
Standard_Integer PCDM_ReadWriter_1::ReadDocumentVersion(const TCollection_ExtendedString& aFileName, const Handle(CDM_MessageDriver)& theMsgDriver) const {
Standard_Integer PCDM_ReadWriter_1::ReadDocumentVersion(const Handle(Storage_IODevice)& aDevice, const Handle(CDM_MessageDriver)& theMsgDriver) const {
static Standard_Integer theVersion ;
theVersion=-1;
PCDM_BaseDriverPointer theFileDriver;
TCollection_AsciiString aFileNameU(aFileName);
if(PCDM::FileDriverType(aFileNameU, theFileDriver) == PCDM_TOFD_Unknown)
if(PCDM::FileDriverType(aDevice, theFileDriver) == PCDM_TOFD_Unknown)
return theVersion;
static Standard_Boolean theFileIsOpen ;
@@ -382,7 +402,7 @@ Standard_Integer PCDM_ReadWriter_1::ReadDocumentVersion(const TCollection_Extend
try {
OCC_CATCH_SIGNALS
PCDM_ReadWriter::Open(*theFileDriver,aFileName,Storage_VSRead);
PCDM_ReadWriter::Open(*theFileDriver,aDevice,Storage_VSRead);
theFileIsOpen=Standard_True;
Handle(Storage_Schema) s = new Storage_Schema;
Handle(Storage_HeaderData) hd = s->ReadHeaderSection(*theFileDriver);
@@ -395,11 +415,10 @@ Standard_Integer PCDM_ReadWriter_1::ReadDocumentVersion(const TCollection_Extend
catch (Standard_Failure) {
// cout << "warning: could not read the version in " << aFileName << endl;
TCollection_ExtendedString aMsg("Warning: ");
aMsg = aMsg.Cat("could not read the version in ").Cat(aFileName).Cat("\0");
aMsg = aMsg.Cat("could not read the version in ").Cat("\0");
if(!theMsgDriver.IsNull())
theMsgDriver->Write(aMsg.ToExtString());
}
}
}
}

5
src/PCDM/PCDM_Reader.cdl
View File

@@ -21,7 +21,8 @@ uses
Document from CDM,
ExtendedString from TCollection,
Application from CDM,
ReaderStatus from PCDM
ReaderStatus from PCDM,
IODevice from Storage
raises DriverError from PCDM
@@ -32,7 +33,7 @@ is
is deferred;
---Purpose: this method is called by the framework before the read method.
Read(me: mutable; aFileName: ExtendedString from TCollection;
Read(me: mutable; aDevice: IODevice from Storage;
aNewDocument: Document from CDM;
anApplication: Application from CDM)
raises DriverError from PCDM

13
src/PCDM/PCDM_Reference.cdl
View File

@@ -15,22 +15,23 @@
-- commercial license or contractual agreement.
private class Reference from PCDM
uses ExtendedString from TCollection
uses ExtendedString from TCollection, IODevice from Storage
is
Create returns Reference from PCDM;
Create(aReferenceIdentifier: Integer from Standard; aFileName: ExtendedString from TCollection; aDocumentVersion: Integer from Standard)
Create(aReferenceIdentifier: Integer from Standard; aDevice: IODevice from Storage; aDocumentVersion: Integer from Standard)
returns Reference from PCDM;
ReferenceIdentifier(me) returns Integer from Standard;
FileName(me) returns ExtendedString from TCollection;
Device(me) returns IODevice from Storage;
DocumentVersion(me) returns Integer from Standard;
fields
myReferenceIdentifier: Integer from Standard;
myFileName: ExtendedString from TCollection;
myDocumentVersion: Integer from Standard;
myDevice: IODevice from Storage;
myDocumentVersion: Integer from Standard;
end Reference from PCDM;

15
src/PCDM/PCDM_Reference.cxx
View File

@@ -16,16 +16,23 @@
#include <PCDM_Reference.ixx>
PCDM_Reference::PCDM_Reference(){}
PCDM_Reference::PCDM_Reference(const Standard_Integer aReferenceIdentifier, const TCollection_ExtendedString& aFileName, const Standard_Integer aDocumentVersion):myReferenceIdentifier(aReferenceIdentifier),myFileName(aFileName),myDocumentVersion(aDocumentVersion) {}
PCDM_Reference::PCDM_Reference()
{
}
PCDM_Reference::PCDM_Reference(const Standard_Integer aReferenceIdentifier, const Handle(Storage_IODevice)& aDevice, const Standard_Integer aDocumentVersion)
: myReferenceIdentifier(aReferenceIdentifier),
myDevice(aDevice),
myDocumentVersion(aDocumentVersion)
{
}
Standard_Integer PCDM_Reference::ReferenceIdentifier() const {
return myReferenceIdentifier;
}
TCollection_ExtendedString PCDM_Reference::FileName() const {
return myFileName;
Handle(Storage_IODevice) PCDM_Reference::Device() const {
return myDevice;
}
Standard_Integer PCDM_Reference::DocumentVersion() const {

12
src/PCDM/PCDM_ReferenceIterator.cxx
View File

@@ -16,6 +16,7 @@
#include <PCDM_ReferenceIterator.ixx>
#include <Storage_Data.hxx>
#include <Storage_IODevice.hxx>
#include <UTL.hxx>
#include <CDM_Document.hxx>
#include <CDM_Application.hxx>
@@ -62,8 +63,7 @@ void PCDM_ReferenceIterator::Init(const Handle(CDM_MetaData)& theMetaData) {
myReferences.Clear();
// mod. by szy
PCDM_RetrievalDriver::References(theMetaData->FileName(), myReferences,
myMessageDriver);
PCDM_RetrievalDriver::References(theMetaData->Device(), myReferences, myMessageDriver);
myIterator=1;
}
@@ -92,8 +92,9 @@ void PCDM_ReferenceIterator::Next() {
Handle(CDM_MetaData) PCDM_ReferenceIterator::MetaData(const Standard_Boolean ) const {
TCollection_ExtendedString theFolder,theName;
TCollection_ExtendedString theFile=myReferences(myIterator).FileName();
// TCollection_ExtendedString theFolder,theName;
Handle(Storage_IODevice) theDevice = myReferences(myIterator).Device();
/*
TCollection_ExtendedString f(theFile);
#ifndef WNT
@@ -133,8 +134,9 @@ Handle(CDM_MetaData) PCDM_ReferenceIterator::MetaData(const Standard_Boolean ) c
theFolder = dirRet;
theName = UTL::Name(p); theName+= UTL::Extension(p);
#endif // WNT
return CDM_MetaData::LookUp(theFolder,theName,theFile,theFile,UTL::IsReadOnly(theFile));
*/
return CDM_MetaData::LookUp(theDevice,!theDevice->CanWrite());
}
//=======================================================================
//function : ReferenceIdentifier

19
src/PCDM/PCDM_RetrievalDriver.cdl
View File

@@ -14,9 +14,7 @@
-- Alternatively, this file may be used under the terms of Open CASCADE
-- commercial license or contractual agreement.
deferred class RetrievalDriver from PCDM
inherits Reader from PCDM
deferred class RetrievalDriver from PCDM inherits Reader from PCDM
uses
Document from PCDM,
@@ -26,6 +24,7 @@ uses
AsciiString from TCollection,
SequenceOfReference from PCDM,
Schema from Storage,
IODevice from Storage,
MessageDriver from CDM,
Application from CDM
@@ -34,7 +33,7 @@ raises NoSuchObject from Standard, DriverError from PCDM
is
Read(me: mutable; aFileName: ExtendedString from TCollection;
Read(me: mutable; aDevice: IODevice from Storage;
aNewDocument: Document from CDM;
anApplication: Application from CDM)
raises DriverError from PCDM
@@ -61,21 +60,21 @@ is
---Category: private methods.
References(myclass; aFileName: ExtendedString from TCollection; theReferences: out SequenceOfReference from PCDM; theMsgDriver: MessageDriver from CDM)
References(myclass; aDevice: IODevice from Storage; theReferences: out SequenceOfReference from PCDM; theMsgDriver: MessageDriver from CDM)
is private;
Extensions(myclass; aFileName: ExtendedString from TCollection; theExtensions: in out SequenceOfExtendedString from TColStd; theMsgDriver: MessageDriver from CDM)
Extensions(myclass; aDevice: IODevice from Storage; theExtensions: in out SequenceOfExtendedString from TColStd; theMsgDriver: MessageDriver from CDM)
is private;
UserInfo(myclass; aFileName: ExtendedString from TCollection; Start, End: AsciiString from TCollection; theUserInfo:in out SequenceOfExtendedString from TColStd; theMsgDriver: MessageDriver from CDM)
UserInfo(myclass; aDevice: IODevice from Storage; Start, End: AsciiString from TCollection; theUserInfo:in out SequenceOfExtendedString from TColStd; theMsgDriver: MessageDriver from CDM)
is private;
RaiseIfUnknownTypes(myclass; aSchema: Schema from Storage; aFileName: ExtendedString from TCollection);
RaiseIfUnknownTypes(myclass; aSchema: Schema from Storage; aDevice: IODevice from Storage);
DocumentVersion(myclass; aFileName: ExtendedString from TCollection; theMsgDriver: MessageDriver from CDM)
DocumentVersion(myclass; aDevice: IODevice from Storage; theMsgDriver: MessageDriver from CDM)
returns Integer from Standard;
ReferenceCounter(myclass; aFileName: ExtendedString from TCollection; theMsgDriver: MessageDriver from CDM)
ReferenceCounter(myclass; aDevice: IODevice from Storage; theMsgDriver: MessageDriver from CDM)
returns Integer from Standard;
SetFormat (me : mutable; aformat : ExtendedString from TCollection);

48
src/PCDM/PCDM_RetrievalDriver.cxx
View File

@@ -22,6 +22,7 @@
#include <Storage_HeaderData.hxx>
#include <Storage_Schema.hxx>
#include <Storage_Root.hxx>
#include <Storage_IODevice.hxx>
#include <TCollection_AsciiString.hxx>
#include <TColStd_SequenceOfAsciiString.hxx>
@@ -34,14 +35,14 @@
#include <Storage_HSeqOfRoot.hxx>
#include <locale.h>
void PCDM_RetrievalDriver::RaiseIfUnknownTypes(const Handle(Storage_Schema)& aSchema, const TCollection_ExtendedString& aFileName) {
void PCDM_RetrievalDriver::RaiseIfUnknownTypes(const Handle(Storage_Schema)& aSchema, const Handle(Storage_IODevice)& aDevice) {
PCDM_BaseDriverPointer theFileDriver;
TCollection_AsciiString aFileNameU(aFileName);
if(PCDM::FileDriverType(aFileNameU, theFileDriver) == PCDM_TOFD_Unknown)
// TCollection_AsciiString aFileNameU(aFileName);
if(PCDM::FileDriverType(aDevice, theFileDriver) == PCDM_TOFD_Unknown)
return;
PCDM_ReadWriter::Open(*theFileDriver,aFileName,Storage_VSRead);
PCDM_ReadWriter::Open(*theFileDriver, aDevice, Storage_VSRead);
TColStd_SequenceOfAsciiString theUnknownTypes;
Standard_Boolean unknowns = aSchema->HasUnknownType(*theFileDriver,theUnknownTypes);
@@ -50,7 +51,7 @@ void PCDM_RetrievalDriver::RaiseIfUnknownTypes(const Handle(Storage_Schema)& aSc
delete theFileDriver;
if(unknowns) {
Standard_SStream aMsg; aMsg << "cannot read: `" << aFileName << "', because the following types: ";
Standard_SStream aMsg; aMsg << "cannot read: `" << aDevice << "', because the following types: ";
for (Standard_Integer i=1; i <= theUnknownTypes.Length(); i++) {
aMsg << theUnknownTypes(i);
if(i< theUnknownTypes.Length()) aMsg <<",";
@@ -65,7 +66,7 @@ void PCDM_RetrievalDriver::RaiseIfUnknownTypes(const Handle(Storage_Schema)& aSc
//purpose :
//=======================================================================
void PCDM_RetrievalDriver::Read(const TCollection_ExtendedString& theFileName,
void PCDM_RetrievalDriver::Read(const Handle(Storage_IODevice)& aDevice,
const Handle(CDM_Document)& aNewDocument,
const Handle(CDM_Application)& theApplication)
{
@@ -78,8 +79,8 @@ void PCDM_RetrievalDriver::Read(const TCollection_ExtendedString& theFileName,
try {
OCC_CATCH_SIGNALS
aSchema=PCDM::Schema(SchemaName(),theApplication);
Extensions(theFileName, theExtensions, theApplication->MessageDriver());
LoadExtensions(aSchema,theExtensions, theApplication->MessageDriver());
Extensions(aDevice, theExtensions, theApplication->MessageDriver());
LoadExtensions(aSchema, theExtensions, theApplication->MessageDriver());
}
catch (Standard_NoSuchObject) {
aMsg << Standard_NoSuchObject::Caught() << endl;
@@ -95,16 +96,16 @@ void PCDM_RetrievalDriver::Read(const TCollection_ExtendedString& theFileName,
}
PCDM_BaseDriverPointer theFileDriver;
TCollection_AsciiString aFileNameU(theFileName);
if(PCDM::FileDriverType(aFileNameU, theFileDriver) == PCDM_TOFD_Unknown) {
// TCollection_AsciiString aFileNameU(theFileName);
if(PCDM::FileDriverType(aDevice, theFileDriver) == PCDM_TOFD_Unknown) {
myReaderStatus = PCDM_RS_UnknownFileDriver;
return;
}
{
try {
OCC_CATCH_SIGNALS
RaiseIfUnknownTypes(aSchema, theFileName);
PCDM_ReadWriter::Open(*theFileDriver,theFileName,Storage_VSRead);
RaiseIfUnknownTypes(aSchema, aDevice);
PCDM_ReadWriter::Open(*theFileDriver, aDevice, Storage_VSRead);
}
catch (Standard_TypeMismatch) {
aMsg << Standard_TypeMismatch::Caught() << endl;
@@ -195,28 +196,29 @@ void PCDM_RetrievalDriver::Read(const TCollection_ExtendedString& theFileName,
PCDM_DriverError_Raise_if(Failure,aMsg);
}
void PCDM_RetrievalDriver::References(const TCollection_ExtendedString& aFileName, PCDM_SequenceOfReference& theReferences, const Handle(CDM_MessageDriver)& theMsgDriver) {
void PCDM_RetrievalDriver::References(const Handle(Storage_IODevice)& aDevice, PCDM_SequenceOfReference& theReferences, const Handle(CDM_MessageDriver)& theMsgDriver) {
PCDM_ReadWriter::Reader(aFileName)->ReadReferences(aFileName, theReferences, theMsgDriver);
PCDM_ReadWriter::Reader(aDevice)->ReadReferences(aDevice, theReferences, theMsgDriver);
}
void PCDM_RetrievalDriver::Extensions(const TCollection_ExtendedString& aFileName, TColStd_SequenceOfExtendedString& theExtensions, const Handle(CDM_MessageDriver)& theMsgDriver) {
void PCDM_RetrievalDriver::Extensions(const Handle(Storage_IODevice)& aDevice, TColStd_SequenceOfExtendedString& theExtensions, const Handle(CDM_MessageDriver)& theMsgDriver) {
PCDM_ReadWriter::Reader(aFileName)->ReadExtensions(aFileName,theExtensions, theMsgDriver);
PCDM_ReadWriter::Reader(aDevice)->ReadExtensions(aDevice,theExtensions, theMsgDriver);
}
Standard_Integer PCDM_RetrievalDriver::DocumentVersion(const Handle(Storage_IODevice)& aDevice, const Handle(CDM_MessageDriver)& theMsgDriver) {
Standard_Integer PCDM_RetrievalDriver::DocumentVersion(const TCollection_ExtendedString& aFileName, const Handle(CDM_MessageDriver)& theMsgDriver) {
return PCDM_ReadWriter::Reader(aFileName)->ReadDocumentVersion(aFileName, theMsgDriver);
return PCDM_ReadWriter::Reader(aDevice)->ReadDocumentVersion(aDevice, theMsgDriver);
}
Standard_Integer PCDM_RetrievalDriver::ReferenceCounter(const TCollection_ExtendedString& aFileName, const Handle(CDM_MessageDriver)& theMsgDriver) {
return PCDM_ReadWriter::Reader(aFileName)->ReadReferenceCounter(aFileName, theMsgDriver);
Standard_Integer PCDM_RetrievalDriver::ReferenceCounter(const Handle(Storage_IODevice)& aDevice, const Handle(CDM_MessageDriver)& theMsgDriver) {
return PCDM_ReadWriter::Reader(aDevice)->ReadReferenceCounter(aDevice, theMsgDriver);
}
void PCDM_RetrievalDriver::LoadExtensions(const Handle(Storage_Schema)& , const TColStd_SequenceOfExtendedString& , const Handle(CDM_MessageDriver)&) {}
void PCDM_RetrievalDriver::LoadExtensions(const Handle(Storage_Schema)& , const TColStd_SequenceOfExtendedString& , const Handle(CDM_MessageDriver)&)
{
}
//=======================================================================
//function : Format

3
src/PCDM/PCDM_StorageDriver.cdl
View File

@@ -39,6 +39,7 @@ uses
Data from Storage,
ExtendedString from TCollection,
Schema from Storage,
IODevice from Storage,
SequenceOfExtendedString from TColStd,
SequenceOfDocument from PCDM,
StoreStatus from PCDM
@@ -65,7 +66,7 @@ is
LoadExtensions(me: mutable; aSchema: Schema from Storage; Extensions: SequenceOfExtendedString from TColStd)
is virtual;
Write(me: mutable; aDocument: Document from CDM; aFileName: ExtendedString from TCollection)
Write(me: mutable; aDocument: Document from CDM; aDevice: IODevice from Storage)
raises DriverError
---Purpose: Warning! raises DriverError if an error occurs during inside the
-- Make method.

7
src/PCDM/PCDM_StorageDriver.cxx
View File

@@ -33,7 +33,7 @@
void PCDM_StorageDriver::Write(const Handle(CDM_Document)& aDocument, const TCollection_ExtendedString& aFileName)
void PCDM_StorageDriver::Write(const Handle(CDM_Document)& aDocument, const Handle(Storage_IODevice)& aDevice)
{
Handle(Storage_Schema) theSchema=PCDM::Schema(SchemaName(),aDocument->Application());
@@ -41,7 +41,6 @@ void PCDM_StorageDriver::Write(const Handle(CDM_Document)& aDocument, const TCol
aDocument->Extensions(theExtensions);
LoadExtensions(theSchema,theExtensions);
Handle(Storage_Data) theData = new Storage_Data;
static Standard_Boolean Failure;
@@ -74,7 +73,7 @@ void PCDM_StorageDriver::Write(const Handle(CDM_Document)& aDocument, const TCol
PCDM_ReadWriter::WriteFileFormat(theData,aDocument);
PCDM_ReadWriter::Writer()->WriteReferenceCounter(theData,aDocument);
PCDM_ReadWriter::Writer()->WriteReferences(theData,aDocument,aFileName);
PCDM_ReadWriter::Writer()->WriteReferences(theData,aDocument,aDevice);
PCDM_ReadWriter::Writer()->WriteExtensions(theData,aDocument);
PCDM_ReadWriter::Writer()->WriteVersion(theData,aDocument);
@@ -88,7 +87,7 @@ void PCDM_StorageDriver::Write(const Handle(CDM_Document)& aDocument, const TCol
}
FSD_CmpFile theFile;
PCDM_ReadWriter::Open(theFile,aFileName,Storage_VSWrite);
PCDM_ReadWriter::Open(theFile,aDevice,Storage_VSWrite);
theSchema->Write(theFile,theData);
theFile.Close();

4
src/PCDM/PCDM_Writer.cdl
View File

@@ -16,12 +16,12 @@
deferred class Writer from PCDM inherits Transient from Standard
uses Document from CDM, ExtendedString from TCollection
uses Document from CDM, ExtendedString from TCollection, IODevice from Storage
raises DriverError from PCDM
is
Write(me: mutable; aDocument: Document from CDM; aFileName: ExtendedString from TCollection)
Write(me: mutable; aDocument: Document from CDM; aDevice: IODevice from Storage)
raises DriverError
is deferred;

6
src/PDataXtd/PDataXtd.cdl
View File

@@ -58,7 +58,11 @@ is
class PatternStd;
class Shape;
class Shape;
class Presentation;
class Presentation_1;
end PDataXtd;

6
src/PPrsStd/PPrsStd_AISPresentation.cdl → src/PDataXtd/PDataXtd_Presentation.cdl
View File

@@ -14,7 +14,7 @@
-- Alternatively, this file may be used under the terms of Open CASCADE
-- commercial license or contractual agreement.
class AISPresentation from PPrsStd
class Presentation from PDataXtd
inherits Attribute from PDF
---Purpose:
@@ -22,7 +22,7 @@ class AISPresentation from PPrsStd
uses HExtendedString from PCollection
is
Create returns AISPresentation from PPrsStd;
Create returns Presentation from PDataXtd;
IsDisplayed(me) returns Boolean from Standard;
SetDisplayed(me : mutable; B : Boolean from Standard);
@@ -51,4 +51,4 @@ fields
myColor : Integer from Standard;
myMaterial : Integer from Standard;
myWidth : Real from Standard;
end AISPresentation;
end Presentation;

46
src/PPrsStd/PPrsStd_AISPresentation.cxx → src/PDataXtd/PDataXtd_Presentation.cxx
View File

@@ -14,20 +14,20 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <PPrsStd_AISPresentation.ixx>
#include <PDataXtd_Presentation.ixx>
//=======================================================================
//function : PPrsStd_AISPresentation
//function : PDataXtd_Presentation
//purpose :
//=======================================================================
PPrsStd_AISPresentation::PPrsStd_AISPresentation() :
myIsDisplayed(Standard_False),
myTransparency(0.),
myColor(0),
myMaterial(0),
myWidth(0.)
PDataXtd_Presentation::PDataXtd_Presentation() :
myIsDisplayed(Standard_False),
myTransparency(0.),
myColor(0),
myMaterial(0),
myWidth(0.)
{}
@@ -36,7 +36,7 @@ PPrsStd_AISPresentation::PPrsStd_AISPresentation() :
//purpose :
//=======================================================================
void PPrsStd_AISPresentation::SetDisplayed (const Standard_Boolean B)
void PDataXtd_Presentation::SetDisplayed (const Standard_Boolean B)
{
myIsDisplayed = B ;
}
@@ -46,9 +46,9 @@ void PPrsStd_AISPresentation::SetDisplayed (const Standard_Boolean B)
//purpose :
//=======================================================================
Standard_Boolean PPrsStd_AISPresentation::IsDisplayed() const
Standard_Boolean PDataXtd_Presentation::IsDisplayed() const
{
return myIsDisplayed;
return myIsDisplayed;
}
@@ -56,7 +56,7 @@ Standard_Boolean PPrsStd_AISPresentation::IsDisplayed() const
//function : SetDriverGUID
//purpose :
//=======================================================================
void PPrsStd_AISPresentation::SetDriverGUID( const Handle(PCollection_HExtendedString)& guid)
void PDataXtd_Presentation::SetDriverGUID( const Handle(PCollection_HExtendedString)& guid)
{
myDriverGUID = guid;
}
@@ -65,7 +65,7 @@ void PPrsStd_AISPresentation::SetDriverGUID( const Handle(PCollection_HExtendedS
//function : GetDriverGUID
//purpose :
//=======================================================================
Handle(PCollection_HExtendedString) PPrsStd_AISPresentation::GetDriverGUID( void ) const
Handle(PCollection_HExtendedString) PDataXtd_Presentation::GetDriverGUID( void ) const
{
return myDriverGUID;
}
@@ -74,7 +74,7 @@ Handle(PCollection_HExtendedString) PPrsStd_AISPresentation::GetDriverGUID( void
//function : Color
//purpose :
//=======================================================================
Standard_Integer PPrsStd_AISPresentation::Color() const
Standard_Integer PDataXtd_Presentation::Color() const
{
return myColor;
}
@@ -83,7 +83,7 @@ Standard_Integer PPrsStd_AISPresentation::Color() const
//function : SetColor
//purpose :
//=======================================================================
void PPrsStd_AISPresentation::SetColor(const Standard_Integer C)
void PDataXtd_Presentation::SetColor(const Standard_Integer C)
{
myColor = C;
}
@@ -92,7 +92,7 @@ void PPrsStd_AISPresentation::SetColor(const Standard_Integer C)
//function : Transparency
//purpose :
//=======================================================================
Standard_Real PPrsStd_AISPresentation::Transparency() const
Standard_Real PDataXtd_Presentation::Transparency() const
{
return myTransparency;
}
@@ -101,7 +101,7 @@ Standard_Real PPrsStd_AISPresentation::Transparency() const
//function : SetTransparency
//purpose :
//=======================================================================
void PPrsStd_AISPresentation::SetTransparency(const Standard_Real T)
void PDataXtd_Presentation::SetTransparency(const Standard_Real T)
{
myTransparency = T;
}
@@ -110,7 +110,7 @@ void PPrsStd_AISPresentation::SetTransparency(const Standard_Real T)
//function : Material
//purpose :
//=======================================================================
Standard_Integer PPrsStd_AISPresentation::Material() const
Standard_Integer PDataXtd_Presentation::Material() const
{
return myMaterial;
}
@@ -119,25 +119,25 @@ Standard_Integer PPrsStd_AISPresentation::Material() const
//function : SetMaterial
//purpose :
//=======================================================================
void PPrsStd_AISPresentation::SetMaterial(const Standard_Integer M)
void PDataXtd_Presentation::SetMaterial(const Standard_Integer M)
{
myMaterial = M;
myMaterial = M;
}
//=======================================================================
//function : Width
//purpose :
//=======================================================================
Standard_Real PPrsStd_AISPresentation::Width() const
Standard_Real PDataXtd_Presentation::Width() const
{
return myWidth;
return myWidth;
}
//=======================================================================
//function : SetWidth
//purpose :
//=======================================================================
void PPrsStd_AISPresentation::SetWidth(const Standard_Real W)
void PDataXtd_Presentation::SetWidth(const Standard_Real W)
{
myWidth = W;
}

6
src/PPrsStd/PPrsStd_AISPresentation_1.cdl → src/PDataXtd/PDataXtd_Presentation_1.cdl
View File

@@ -14,7 +14,7 @@
-- Alternatively, this file may be used under the terms of Open CASCADE
-- commercial license or contractual agreement.
class AISPresentation_1 from PPrsStd
class Presentation_1 from PDataXtd
inherits Attribute from PDF
---Purpose:
@@ -22,7 +22,7 @@ class AISPresentation_1 from PPrsStd
uses HExtendedString from PCollection
is
Create returns AISPresentation_1 from PPrsStd;
Create returns Presentation_1 from PDataXtd;
IsDisplayed(me) returns Boolean from Standard;
SetDisplayed(me : mutable; B : Boolean from Standard);
@@ -53,4 +53,4 @@ fields
myMaterial : Integer from Standard;
myWidth : Real from Standard;
myMode : Integer from Standard;
end AISPresentation_1;
end Presentation_1;

34
src/PPrsStd/PPrsStd_AISPresentation_1.cxx → src/PDataXtd/PDataXtd_Presentation_1.cxx
View File

@@ -14,15 +14,15 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <PPrsStd_AISPresentation_1.ixx>
#include <PDataXtd_Presentation_1.ixx>
//=======================================================================
//function : PPrsStd_AISPresentation
//function : PDataXtd_Presentation_1
//purpose :
//=======================================================================
PPrsStd_AISPresentation_1::PPrsStd_AISPresentation_1() :
PDataXtd_Presentation_1::PDataXtd_Presentation_1() :
myIsDisplayed(Standard_False),
myTransparency(0.),
myColor(0),
@@ -38,7 +38,7 @@ PPrsStd_AISPresentation_1::PPrsStd_AISPresentation_1() :
//purpose :
//=======================================================================
void PPrsStd_AISPresentation_1::SetDisplayed (const Standard_Boolean B)
void PDataXtd_Presentation_1::SetDisplayed (const Standard_Boolean B)
{
myIsDisplayed = B ;
}
@@ -48,7 +48,7 @@ void PPrsStd_AISPresentation_1::SetDisplayed (const Standard_Boolean B)
//purpose :
//=======================================================================
Standard_Boolean PPrsStd_AISPresentation_1::IsDisplayed() const
Standard_Boolean PDataXtd_Presentation_1::IsDisplayed() const
{
return myIsDisplayed;
}
@@ -58,7 +58,7 @@ Standard_Boolean PPrsStd_AISPresentation_1::IsDisplayed() const
//function : SetDriverGUID
//purpose :
//=======================================================================
void PPrsStd_AISPresentation_1::SetDriverGUID( const Handle(PCollection_HExtendedString)& guid)
void PDataXtd_Presentation_1::SetDriverGUID( const Handle(PCollection_HExtendedString)& guid)
{
myDriverGUID = guid;
}
@@ -67,7 +67,7 @@ void PPrsStd_AISPresentation_1::SetDriverGUID( const Handle(PCollection_HExtende
//function : GetDriverGUID
//purpose :
//=======================================================================
Handle(PCollection_HExtendedString) PPrsStd_AISPresentation_1::GetDriverGUID( void ) const
Handle(PCollection_HExtendedString) PDataXtd_Presentation_1::GetDriverGUID( void ) const
{
return myDriverGUID;
}
@@ -76,7 +76,7 @@ Handle(PCollection_HExtendedString) PPrsStd_AISPresentation_1::GetDriverGUID( vo
//function : Color
//purpose :
//=======================================================================
Standard_Integer PPrsStd_AISPresentation_1::Color() const
Standard_Integer PDataXtd_Presentation_1::Color() const
{
return myColor;
}
@@ -85,7 +85,7 @@ Standard_Integer PPrsStd_AISPresentation_1::Color() const
//function : SetColor
//purpose :
//=======================================================================
void PPrsStd_AISPresentation_1::SetColor(const Standard_Integer C)
void PDataXtd_Presentation_1::SetColor(const Standard_Integer C)
{
myColor = C;
}
@@ -94,7 +94,7 @@ void PPrsStd_AISPresentation_1::SetColor(const Standard_Integer C)
//function : Transparency
//purpose :
//=======================================================================
Standard_Real PPrsStd_AISPresentation_1::Transparency() const
Standard_Real PDataXtd_Presentation_1::Transparency() const
{
return myTransparency;
}
@@ -103,7 +103,7 @@ Standard_Real PPrsStd_AISPresentation_1::Transparency() const
//function : SetTransparency
//purpose :
//=======================================================================
void PPrsStd_AISPresentation_1::SetTransparency(const Standard_Real T)
void PDataXtd_Presentation_1::SetTransparency(const Standard_Real T)
{
myTransparency = T;
}
@@ -112,7 +112,7 @@ void PPrsStd_AISPresentation_1::SetTransparency(const Standard_Real T)
//function : Material
//purpose :
//=======================================================================
Standard_Integer PPrsStd_AISPresentation_1::Material() const
Standard_Integer PDataXtd_Presentation_1::Material() const
{
return myMaterial;
}
@@ -121,7 +121,7 @@ Standard_Integer PPrsStd_AISPresentation_1::Material() const
//function : SetMaterial
//purpose :
//=======================================================================
void PPrsStd_AISPresentation_1::SetMaterial(const Standard_Integer M)
void PDataXtd_Presentation_1::SetMaterial(const Standard_Integer M)
{
myMaterial = M;
}
@@ -130,7 +130,7 @@ void PPrsStd_AISPresentation_1::SetMaterial(const Standard_Integer M)
//function : Width
//purpose :
//=======================================================================
Standard_Real PPrsStd_AISPresentation_1::Width() const
Standard_Real PDataXtd_Presentation_1::Width() const
{
return myWidth;
}
@@ -143,7 +143,7 @@ Standard_Real PPrsStd_AISPresentation_1::Width() const
//purpose :
//=======================================================================
void PPrsStd_AISPresentation_1::SetWidth(const Standard_Real W)
void PDataXtd_Presentation_1::SetWidth(const Standard_Real W)
{
myWidth = W;
}
@@ -155,7 +155,7 @@ void PPrsStd_AISPresentation_1::SetWidth(const Standard_Real W)
//purpose :
//=======================================================================
Standard_Integer PPrsStd_AISPresentation_1::Mode() const
Standard_Integer PDataXtd_Presentation_1::Mode() const
{
return myMode;
}
@@ -166,7 +166,7 @@ Standard_Integer PPrsStd_AISPresentation_1::Mode() const
//purpose :
//=======================================================================
void PPrsStd_AISPresentation_1::SetMode(const Standard_Integer M)
void PDataXtd_Presentation_1::SetMode(const Standard_Integer M)
{
myMode = M;
}

34
src/PPrsStd/PPrsStd.cdl
View File

@@ -1,34 +0,0 @@
-- Created on: 1997-08-26
-- Created by: SMO
-- Copyright (c) 1997-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.
package PPrsStd
uses
Standard,
Quantity,
PDF,
PCollection,
gp
is
class AISPresentation;
class AISPresentation_1;
--class Position; now it is in PDataStd
end PPrsStd;

2
src/QABugs/QABugs_11.cxx
View File

@@ -822,7 +822,7 @@ static Standard_Integer OCC381_SaveAs (Draw_Interpretor& di, Standard_Integer nb
if (!DDocStd::Find(A)) return 1;
TCollection_ExtendedString theStatusMessage;
PCDM_StoreStatus theStatus = A->SaveAs(D,path, theStatusMessage);
PCDM_StoreStatus theStatus = PCDM_SS_Failure; //A->SaveAs(D,path, theStatusMessage);
if (theStatus != PCDM_SS_OK ) {
switch ( theStatus ) {
case PCDM_SS_DriverFailure: {

4
src/QABugs/QABugs_19.cxx
View File

@@ -2146,7 +2146,7 @@ static Standard_Integer OCC24565 (Draw_Interpretor& di, Standard_Integer argc, c
printf("%s: Going to write %d surfaces.\n",__FUNCTION__,max_i+1);
FSD_File f_write;
if(f_write.Open(sFileNameSTOR, Storage_VSWrite)!=Storage_VSOk)
if(true)//f_write.Open(sFileNameSTOR, Storage_VSWrite)!=Storage_VSOk)
{
printf("%s: Error opening file: %s\n", __FUNCTION__,sFileNameSTOR);
return -1;
@@ -2161,7 +2161,7 @@ static Standard_Integer OCC24565 (Draw_Interpretor& di, Standard_Integer argc, c
*
* * * * * * */
FSD_File f_read;
if(f_read.Open(sFileNameSTOR, Storage_VSRead)!=Storage_VSOk)
if(true)//f_read.Open(sFileNameSTOR, Storage_VSRead)!=Storage_VSOk)
{
printf("%s: Error opening file: %s\n", __FUNCTION__,sFileNameSTOR);
return -1;

7
src/Standard/FILES
View File

@@ -28,14 +28,17 @@ Standard_ExtCharacter.hxx
Standard_ExtString.cxx
Standard_ExtString.hxx
Standard_HashCode.cxx
Standard_IStream.hxx
Standard_Integer.hxx
Standard_Macro.hxx
Standard_OStream.hxx
Standard_Persistent_proto.hxx
Standard_PrimitiveTypes.hxx
Standard_Real.cxx
Standard_Real.hxx
Standard_IStream.hxx
Standard_IStreamPtr.hxx
Standard_OStream.hxx
Standard_OStreamPtr.hxx
Standard_FStream.hxx
Standard_SStream.cxx
Standard_SStream.hxx
Standard_ShortReal.cxx

4
src/Standard/Standard.cdl
View File

@@ -49,8 +49,12 @@ is
enumeration HandlerStatus is HandlerVoid, HandlerJumped, HandlerProcessed;
imported IStream;
imported IStreamPtr;
imported OStream;
imported OStreamPtr;
imported SStream;
imported FStream;
imported UUID;
imported JmpBuf;
imported ThreadId;

23
src/Standard/Standard_FStream.hxx Normal file
View File

@@ -0,0 +1,23 @@
// Copyright (c) 1998-1999 Matra Datavision
// Copyright (c) 1999-2015 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef Standard_FStream_HeaderFile
#define Standard_FStream_HeaderFile
#include <Standard_Macro.hxx>
#include <Standard_Stream.hxx>
typedef std::fstream Standard_FStream;
#endif

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