ADriverTable from BinMDF,
Position from Storage,
IStream from Standard,
- DocumentSection from BinLDrivers
+ DocumentSection from BinLDrivers ,
+ IODevice from Storage
is
-- ===== Public methods =====
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;
#include <Standard_Failure.hxx>
#include <Standard_IStream.hxx>
#include <Standard_ErrorHandler.hxx>
+
+#include <string>
+
//=======================================================================
//function : BinDrivers_DocumentRetrievalDriver
//purpose : Constructor
//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);
+ if (myDrivers->GetDriver(STANDARD_TYPE(TNaming_NamedShape), aNamedShapeDriver))
+ {
+ try {
+ OCC_CATCH_SIGNALS
+
+ aBuf = (Standard_Character*)malloc( theSection.Length() + 1 );
+ Standard_Size aSize = theDevice->Read( aBuf, theSection.Length() );
+ if ( aSize == theSection.Length() )
+ {
+ Standard_SStream aStrStream( std::string( aBuf, aSize ), Standard_SStream::in | Standard_SStream::binary );
+ aNamedShapeDriver->ReadShapeSection( aStrStream );
}
- catch(Standard_Failure) {
- Handle(Standard_Failure) aFailure = Standard_Failure::Caught();
- const TCollection_ExtendedString aMethStr
- ("BinDrivers_DocumentRetrievalDriver: ");
- WriteMessage (aMethStr + "error of Shape Section " +
- aFailure->GetMessageString());
+ 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 );
}
//=======================================================================
//purpose :
//=======================================================================
void BinDrivers_DocumentRetrievalDriver::CheckShapeSection(
- const Storage_Position& /*ShapeSectionPos*/,
- Standard_IStream& /*IS*/)
+ const Storage_Position& /*ShapeSectionPos*/,
+ const Handle(Storage_IODevice)& /*theDevice*/)
{}
//=======================================================================
OStream from Standard,
MessageDriver from CDM,
DocumentSection from BinLDrivers,
- ADriverTable from BinMDF
+ ADriverTable from BinMDF,
+ IODevice from Storage
is
-- ===== Public methods =====
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
#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
//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);
}
Persistent from BinObjMgt,
Label from TDF,
IStream from Standard,
+ IODevice from Storage,
MapOfInteger from TColStd,
DocumentSection from BinLDrivers,
VectorOfDocumentSection from BinLDrivers
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.
-- ===== 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
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)
#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();
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;
WriteMessage (aTypeNames(i));
}
+ theDevice->Open (Storage_VSRead);
+
// Open the file stream
-#ifdef _WIN32
- ifstream anIS ((const wchar_t*) theFileName.ToExtString(), ios::in | ios::binary);
-#else
- ifstream anIS (aFileName.ToCString());
-#endif
+//#ifdef _WIN32
+// ifstream anIS ((const wchar_t*) theFileName.ToExtString(), ios::in | ios::binary);
+//#else
+// ifstream anIS (aFileName.ToCString());
+//#endif
- if (!anIS) {
+ 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);
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
// 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);
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();
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);
}
}
}
//=======================================================================
Standard_Integer BinLDrivers_DocumentRetrievalDriver::ReadSubTree
- (Standard_IStream& theIS,
+ (const Handle(Storage_IODevice)& theDevice,
const TDF_Label& theLabel)
{
Standard_Integer nbRead = 0;
("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()) {
+ 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;
// 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
//=======================================================================
Storage_Position BinLDrivers_DocumentRetrievalDriver::ReadInfoSection
- (const TCollection_AsciiString& theFileName,
+ (const Handle(Storage_IODevice)& theDevice,
Handle(Storage_HeaderData)& theData)
{
TCollection_ExtendedString aMsg
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 );
WriteMessage( aMsg + theData->ErrorStatusExtension() );
}
else
- WriteMessage( aMsg + "can not open file " + theFileName);
+ WriteMessage( aMsg + "can not open file " + theDevice->Name());
aFileDriver.Close();
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
}
void BinLDrivers_DocumentRetrievalDriver::ReadShapeSection
(BinLDrivers_DocumentSection& theSection,
- Standard_IStream& /*theIS*/,
+ const Handle(Storage_IODevice)& /*theDevice*/,
const Standard_Boolean isMess)
{
//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. ");
- }
- }
+
}
//=======================================================================
uses
AsciiString from TCollection,
- Size from Standard
+ Size from Standard,
+ IODevice from Storage
is
-- ===== Public methods =====
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.
#include <BinLDrivers_DocumentSection.hxx>
#include <FSD_FileHeader.hxx>
+#include <Storage_IODevice.hxx>
+
//=======================================================================
//function : BinLDrivers_DocumentSection
//purpose : Empty constructor
//purpose :
//=======================================================================
-void BinLDrivers_DocumentSection::WriteTOC (Standard_OStream& theStream)
+void BinLDrivers_DocumentSection::WriteTOC (const Handle(Storage_IODevice)& theDevice)
{
char aBuf[512];
#else
aBufSz[0] = (Standard_Integer)aBufSize;
#endif
- theStream.write (&aBuf[0], aBufSize + sizeof(Standard_Integer));
+ theDevice->Write( &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
aBufSz[0] = 0;
aBufSz[1] = 0;
aBufSz[2] = 0;
- theStream.write (&aBuf[0], 3*sizeof(Standard_Integer));
+ theDevice->Write(&aBuf[0], 3*sizeof(Standard_Integer));
}
}
//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] = {
aVal[2] = InverseSize(aVal[2]);
#endif
- theStream.write((char *)&aVal[0], 3*sizeof(Standard_Integer));
- theStream.seekp(aSectionEnd);
+ theDevice->Write((char*)&aVal[0], 3*sizeof(Standard_Integer));
+ theDevice->Seek(aSectionEnd);
}
//=======================================================================
//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( (char*)&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]);
MapOfTransient from TColStd,
IndexedMapOfTransient from TColStd,
DocumentSection from BinLDrivers,
- VectorOfDocumentSection from BinLDrivers
+ VectorOfDocumentSection from BinLDrivers,
+ IODevice from Storage
is
-- ===== Public methods =====
---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>
-- ===== 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>
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
-- 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
//=======================================================================
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);
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);
FirstPass (aData->Root());
// 1. Write info section (including types table)
- WriteInfoSection(theDocument, aFileName);
+ WriteInfoSection(theDocument, theDevice);
myTypesMap.Clear();
if (IsError())
{
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)
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
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();
}
}
//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) {
#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
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;
}
#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
#if DO_INVERSE
anEndLabel = (BinLDrivers_Marker) InverseInt (anEndLabel);
#endif
- theOS.write ((char*)&anEndLabel, sizeof(anEndLabel));
-
+ theDevice->Write((char*)&anEndLabel, sizeof(anEndLabel));
}
//=======================================================================
#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;
}
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);
}
else {
WriteMessage(TCollection_ExtendedString("Error: Problem writing header "
- "into file ") + theFileName);
+ "into file ") + theDevice->Name());
SetIsError(Standard_True);
}
#ifdef OCCT_DEBUG
//=======================================================================
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
}
//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);
+ }
}
BRepTools,
BinTools,
TDF,
- CDM
+ CDM,
+ Storage
is
MessageDriver from CDM,
Attribute from TDF,
ShapeSet from BinTools,
- LocationSet from BinTools
+ LocationSet from BinTools,
+ IODevice from Storage
is
Create (theMessageDriver:MessageDriver from CDM)
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
#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
else
theIS.seekg(aPos); // no shape section is present, try to return to initial point
}
-
uses
TDF,
Standard,
+ Storage,
TCollection,
TColStd
Address from Standard,
OStream from Standard,
IStream from Standard,
+ IODevice from Storage,
SequenceOfAddress from TColStd,
AsciiString from TCollection,
ExtendedString from TCollection,
-- 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 ~
#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))
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( (char*)myData(i), nbToWrite );
+ nbWritten += nbToWrite;
+ }
+ myIndex = 1;
+ myOffset = BP_HEADSIZE;
+ mySize = BP_HEADSIZE;
+ myIsError = Standard_False;
+}
+
//=======================================================================
//function : Read
//purpose : Retrieves <me> from the stream.
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
package CDF
-uses CDM, PCDM, TCollection, TColStd, Storage, Resource, Quantity, OSD
+uses CDM, PCDM, TCollection, TColStd, Storage, Resource, Quantity, OSD, Storage
is
class Directory;
TypeOfActivation from CDF,
SequenceOfExtendedString from TColStd,
CanCloseStatus from CDM,
- AsciiString from TCollection
+ AsciiString from TCollection,
+ IODevice from Storage
raises NoSuchObject from Standard
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
-- 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
-- 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.
--
---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;
---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;
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;
CanRetrieve(me: mutable; aMetaData: MetaData from CDM)
returns ReaderStatus from PCDM
is private;
+
fields
myDefaultFolder: ExtendedString from TCollection;
//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: ");
//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: ");
? 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);
if(!FindReaderFromFormat(theFormat)) return PCDM_RS_NoDriver;
}
}
- return PCDM_RS_OK;
-
-}
+ aDevice->Close();
+ return PCDM_RS_OK;
+}
//=======================================================================
//function : Activate
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;
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;
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();
//=======================================================================
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());
}
//=======================================================================
//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);
}
//=======================================================================
//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)) {
//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)) {
//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);
}
uses
MetaData from CDM,
Document from CDM,
- ExtendedString from TCollection
+ ExtendedString from TCollection,
+ IODevice from Storage
+
is
Create
returns FWOSDriver from CDF;
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;
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
//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());
}
//==============================================================================
//==============================================================================
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();
}
//==============================================================================
//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);
n += UTL::Extension(p);
return CDM_MetaData::LookUp(f,n,aFileName,aFileName,UTL::IsReadOnly(aFileName));
+*/
+ return CDM_MetaData::LookUp(aDevice,!aDevice->CanWrite());
}
//==============================================================================
uses
Document from CDM, MetaData from CDM,
ExtendedString from TCollection,
- ReferenceIterator from PCDM
+ ReferenceIterator from PCDM,
+ IODevice from Storage
raises
NotImplemented from Standard
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
- 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
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;
//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 :
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)
--
-- 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;
---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);
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.
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
myLastName: ExtendedString from TCollection;
- myPath: ExtendedString from TCollection;
+-- myPath: ExtendedString from TCollection;
myText: ExtendedString from TCollection;
myStatus: StoreStatus from PCDM;
-
end Store from CDF;
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::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;
+Standard_Boolean CDF_Store::SetDevice(const Handle(Storage_IODevice)& aDevice) {
+ myCurrentDocument->SetRequestedDevice(aDevice);
+ return Standard_True;
}
-
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;
}
Standard_Boolean CDF_Store::CurrentIsConsistent() const {
if(!myCurrentDocument->IsStored())
- return myCurrentDocument->HasRequestedFolder();
+ return myCurrentDocument->HasRequestedDevice();
return Standard_True;
}
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;
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;
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) {
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();
}
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);
package CDM
-uses TCollection,TColStd,Resource
+uses TCollection, TColStd, Resource, Storage
is
-- 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
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;
- 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;
+ HasRequestedDevice(me) returns Boolean from Standard;
+
- HasRequestedFolder(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 --
---Purpose: defines the Comment with which the object should be stored.
RequestedComment(me) returns ExtendedString from TCollection;
-
---Category: resource reading methods
--
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;
myActualReferenceIdentifier (0),
myStorageVersion (0),
myRequestedComment (""),
- myRequestedFolderIsDefined (Standard_False),
- myRequestedNameIsDefined (Standard_False),
myRequestedPreviousVersionIsDefined(Standard_False),
myFileExtensionWasFound (Standard_False),
myDataTypeWasFound (Standard_False),
myMetaData = aMetaData;
- SetRequestedFolder(aMetaData->Folder());
- if(aMetaData->HasVersion()) SetRequestedPreviousVersion(aMetaData->Version());
+ SetRequestedDevice( aMetaData->Device() );
+ if ( aMetaData->HasVersion() )
+ SetRequestedPreviousVersion( aMetaData->Version() );
}
//=======================================================================
}
//=======================================================================
-//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;
- }
-}
-
-//=======================================================================
-//function : RequestedFolder
-//purpose :
-//=======================================================================
-
-TCollection_ExtendedString CDM_Document::RequestedFolder() const
-{
- Standard_NoSuchObject_Raise_if (!myRequestedFolderIsDefined,
- "storage folder is undefined for this document");
- return myRequestedFolder;
+ myRequestedDevice=aDevice;
}
//=======================================================================
-//function : HasRequestedFolder
+//function : RequestedDevice
//purpose :
//=======================================================================
-Standard_Boolean CDM_Document::HasRequestedFolder() const
+Handle(Storage_IODevice) CDM_Document::RequestedDevice() const
{
- return myRequestedFolderIsDefined;
+ return myRequestedDevice;
}
//=======================================================================
-//function : SetRequestedName
+//function : HasRequestedDevice
//purpose :
//=======================================================================
-void CDM_Document::SetRequestedName(const TCollection_ExtendedString& aName)
+Standard_Boolean CDM_Document::HasRequestedDevice() const
{
- myRequestedName=aName;
- myRequestedNameIsDefined=Standard_True;
+ return !myRequestedDevice.IsNull();
}
//=======================================================================
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;
}
//=======================================================================
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.
--
---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)
---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.
--
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;
#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;
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( !getLookUpTable().IsBound(aSig) ) {
+ theMetaData = new CDM_MetaData(aDevice, ReadOnly);
+ getLookUpTable().Bind(aSig, theMetaData);
}
else
- theMetaData = getLookUpTable()(aConventionalPath);
-
+ theMetaData = getLookUpTable()(aSig);
+
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) CDM_MetaData::LookUp(const Handle(Storage_IODevice)& aDevice, const TCollection_ExtendedString& aVersion, 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);
+ TCollection_AsciiString aSig;
+ if ( !aDevice.IsNull() )
+ aSig = aDevice->Signature();
+
+ if( !getLookUpTable().IsBound(aSig) ) {
+ theMetaData = new CDM_MetaData(aDevice, aVersion, ReadOnly);
+ getLookUpTable().Bind(aSig, theMetaData);
}
else
- theMetaData = getLookUpTable()(aConventionalPath);
-
+ 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) {
#include <TDF_RelocationTable.hxx>
#include <TDF_Tool.hxx>
-#include <DDF_IOStream.hxx>
-
+#include <Storage_Error.hxx>
//=======================================================================
//function : Children
+++ /dev/null
-// 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.
-
-// ----------------
-
-// Version: 0.0
-//Version Date Purpose
-// 0.0 Aug 22 1997 Creation
-
-#include <Standard_Stream.hxx>
-
-#include <DDF_IOStream.hxx>
-
-// This file has been written using FSD_File.cxx 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)
-
-
-#include <Storage_StreamTypeMismatchError.hxx>
-#include <Storage_StreamFormatError.hxx>
-#include <Storage_StreamWriteError.hxx>
-#include <Storage_StreamExtCharParityError.hxx>
-
-#include <TCollection_AsciiString.hxx>
-#include <TCollection_ExtendedString.hxx>
-
-#include <TColStd_SequenceOfAsciiString.hxx>
-#include <TColStd_SequenceOfExtendedString.hxx>
-
-const Standard_CString MAGICNUMBER = "FSDFILE";
-
-
-//=======================================================================
-//function : DDF_IOStream
-//purpose :
-//=======================================================================
-
-DDF_IOStream::DDF_IOStream() :
- myIStream(NULL),
- myOStream(NULL)
-{}
-
-//=======================================================================
-//function : Open
-//purpose :
-//=======================================================================
-
-Storage_Error DDF_IOStream::Open(const TCollection_AsciiString& aName,const Storage_OpenMode aMode)
-{
- //myIStream = NULL;
- //myOStream = NULL;
- //return Storage_VSOk;
-
- Storage_Error result = Storage_VSOk;
-
- SetName(aName);
-
- if (OpenMode() == Storage_VSNone) {
- if (aMode == Storage_VSRead) {
- if (myIStream != NULL) delete myIStream;
- myIStream = new ifstream(aName.ToCString(),ios::in); // ios::nocreate is not portable
- if (myIStream->fail()) {
- result = Storage_VSOpenError;
- }
- else {
- myIStream->precision(17);
- myIStream->imbue (std::locale::classic()); // always use C locale
- SetOpenMode(aMode);
- }
- }
- else if (aMode == Storage_VSWrite) {
- if (myOStream != NULL) delete myOStream;
- myOStream = new ofstream(aName.ToCString(),ios::out);
- if (myOStream->fail()) {
- result = Storage_VSOpenError;
- }
- else {
- myOStream->precision(17);
- myOStream->imbue (std::locale::classic()); // make sure to always use C locale
- SetOpenMode(aMode);
- }
- }
- }
- else {
- result = Storage_VSAlreadyOpen;
- }
-
- return result;
-}
-
-//=======================================================================
-//function : Open
-//purpose : "Opens" an istream.
-//=======================================================================
-
-Storage_Error DDF_IOStream::Open(istream* anIStream)
-{
- myOStream = NULL;
- SetOpenMode(Storage_VSRead);
- myIStream = anIStream;
- myIStream->precision(17);
- myIStream->imbue (std::locale::classic()); // use always C locale
- SetName("DDF_IOStream");
- return Storage_VSOk; // ou Storage_VSAlreadyOpen ?
-}
-
-//=======================================================================
-//function : Open
-//purpose : "Opens" an ostream.
-//=======================================================================
-
-Storage_Error DDF_IOStream::Open(ostream* anOStream)
-{
- myIStream = NULL;
- SetOpenMode(Storage_VSWrite);
- myOStream = anOStream;
- myOStream->precision(17);
- myOStream->imbue (std::locale::classic()); // use always C locale
- SetName("DDF_IOStream");
- return Storage_VSOk; // ou Storage_VSAlreadyOpen ?
-}
-
-//=======================================================================
-//function : IsEnd
-//purpose :
-//=======================================================================
-
-Standard_Boolean DDF_IOStream::IsEnd()
-{
- if (OpenMode() == Storage_VSRead) return myIStream->eof();
- else return myOStream->eof();
-}
-
-//=======================================================================
-//function : Close
-//purpose :
-//=======================================================================
-
-Storage_Error DDF_IOStream::Close()
-{ return Storage_VSOk; }
-
-
-// ------------------ PROTECTED
-
-
-//=======================================================================
-//function : MagicNumber
-//purpose :
-//=======================================================================
-
-const Standard_CString DDF_IOStream::MagicNumber()
-{ return MAGICNUMBER; }
-
-//=======================================================================
-//function : FlushEndOfLine
-//purpose :
-//=======================================================================
-
-void DDF_IOStream::FlushEndOfLine()
-{
- static char Buffer[8192];
- char c;
- Standard_Boolean IsEnd = Standard_False;
-
- while (!IsEnd && !DDF_IOStream::IsEnd()) {
- Buffer[0] = '\0';
- myIStream->get(Buffer,8192,'\n');
-
- if (myIStream->get(c) && c != '\n') {
- }
- else {
- IsEnd = Standard_True;
- }
- }
-}
-
-//=======================================================================
-//function : ReadLine
-//purpose :
-//=======================================================================
-
-void DDF_IOStream::ReadLine(TCollection_AsciiString& buffer)
-{
- static char Buffer[8193];
- char c;
- Standard_Boolean IsEnd = Standard_False;
-
- buffer.Clear();
-
- while (!IsEnd && !DDF_IOStream::IsEnd()) {
- Buffer[0] = '\0';
- myIStream->get(Buffer,8192,'\n');
-
- if (myIStream->get(c) && c != '\n') {
- buffer += Buffer;
- buffer += c;
- }
- else {
- buffer += Buffer;
- IsEnd = Standard_True;
- }
- }
-}
-
-
-//=======================================================================
-//function : WriteExtendedLine
-//purpose :
-//=======================================================================
-
-void DDF_IOStream::WriteExtendedLine(const TCollection_ExtendedString& buffer)
-{
- 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;
-
- *myOStream << (char)c << (char)d;
- }
-
- *myOStream << (char)0 << "\n";
-}
-
-//=======================================================================
-//function : ReadExtendedLine
-//purpose :
-//=======================================================================
-
-void DDF_IOStream::ReadExtendedLine(TCollection_ExtendedString& buffer)
-{
- char c = '\0';
- Standard_ExtCharacter i = 0,j,check = 0;
- Standard_Boolean fin = Standard_False;
-
- buffer.Clear();
-
- while (!fin && !IsEnd()) {
- myIStream->get(c);
- check++;
-// if (!(check % 2)) Storage_StreamExtCharParityError::Raise();
- i = (Standard_ExtCharacter)c;
- if (c == '\0') fin = Standard_True;
- i = (i << 8);
-
- myIStream->get(c);
- check++;
-// if ((check % 2) != 0) Storage_StreamExtCharParityError::Raise();
-// cout << check << endl;
- j = (Standard_ExtCharacter)c;
- if (c != '\n') fin = Standard_False;
- i |= (0x00FF & j);
- buffer += (Standard_ExtCharacter)i;
- }
-
-// if ((check % 2) != 0) Storage_StreamExtCharParityError::Raise();
-// cout << check << endl;
-}
-
-//=======================================================================
-//function : ReadChar
-//purpose :
-//=======================================================================
-
-void DDF_IOStream::ReadChar(TCollection_AsciiString& buffer, const Standard_Integer rsize)
-{
- char c;
- Standard_Integer ccount = 0;
-
- buffer.Clear();
-
- while (!IsEnd() && (ccount < rsize)) {
- myIStream->get(c);
- buffer += c;
- ccount++;
- }
-}
-
-//=======================================================================
-//function : ReadString
-//purpose :
-//=======================================================================
-
-void DDF_IOStream::ReadString(TCollection_AsciiString& buffer)
-{
- char c = '\0';
- Standard_Boolean IsEnd = Standard_False;
-
- buffer.Clear();
-
- while (!IsEnd && !DDF_IOStream::IsEnd()) {
- myIStream->get(c);
- if ((c != ' ') && (c != '\n')) IsEnd = Standard_True;
- }
-
- IsEnd = Standard_False;
-
- while (!IsEnd && !DDF_IOStream::IsEnd()) {
- buffer += c;
- myIStream->get(c);
- if (c == '\n') IsEnd = Standard_True;
- }
-}
-
-//=======================================================================
-//function : ReadWord
-//purpose :
-//=======================================================================
-
-void DDF_IOStream::ReadWord(TCollection_AsciiString& buffer)
-{
- char c = '\0';
- Standard_Boolean IsEnd = Standard_False;
-
- buffer.Clear();
-
- while (!IsEnd && !DDF_IOStream::IsEnd()) {
- myIStream->get(c);
- if ((c != ' ') && (c != '\n')) IsEnd = Standard_True;
- }
-
- IsEnd = Standard_False;
-
- while (!IsEnd && !DDF_IOStream::IsEnd()) {
- buffer += c;
- myIStream->get(c);
- if ((c == '\n') || (c == ' ')) IsEnd = Standard_True;
- }
-}
-
-//=======================================================================
-//function : FindTag
-//purpose :
-//=======================================================================
-
-Storage_Error DDF_IOStream::FindTag(const Standard_CString aTag)
-{
- TCollection_AsciiString l;
-
- ReadString(l);
-
- while ((strcmp(l.ToCString(),aTag) != 0) && !IsEnd()) {
- ReadString(l);
- }
-
- if (IsEnd()) {
- return Storage_VSSectionNotFound;
- }
- else {
- return Storage_VSOk;
- }
-}
-
-//=======================================================================
-//function : SkipObject
-//purpose :
-//=======================================================================
-
-void DDF_IOStream::SkipObject()
-{
- FlushEndOfLine();
-}
-
-
-// ---------------------- PUBLIC : PUT
-
-
-//=======================================================================
-//function : PutReference
-//purpose :
-//=======================================================================
-
-Storage_BaseDriver& DDF_IOStream::PutReference(const Standard_Integer aValue)
-{
- *myOStream << aValue << " ";
- if (myOStream->bad()) Storage_StreamWriteError::Raise("PutReference");
- return *this;
-}
-
-//=======================================================================
-//function : PutCharacter
-//purpose :
-//=======================================================================
-
-Storage_BaseDriver& DDF_IOStream::PutCharacter(const Standard_Character aValue)
-{
- *myOStream << aValue << " ";
- if (myOStream->bad()) Storage_StreamWriteError::Raise("PutCharacter");
- return *this;
-}
-
-//=======================================================================
-//function : PutExtCharacter
-//purpose :
-//=======================================================================
-
-Storage_BaseDriver& DDF_IOStream::PutExtCharacter(const Standard_ExtCharacter aValue)
-{
- *myOStream << aValue << " ";
- if (myOStream->bad()) Storage_StreamWriteError::Raise("PutExtCharacter");
- return *this;
-}
-
-//=======================================================================
-//function : PutInteger
-//purpose :
-//=======================================================================
-
-Storage_BaseDriver& DDF_IOStream::PutInteger(const Standard_Integer aValue)
-{
- *myOStream << aValue << " ";
- if (myOStream->bad()) Storage_StreamWriteError::Raise("PutInteger");
- return *this;
-}
-
-//=======================================================================
-//function : PutBoolean
-//purpose :
-//=======================================================================
-
-Storage_BaseDriver& DDF_IOStream::PutBoolean(const Standard_Boolean aValue)
-{
- *myOStream << ((Standard_Integer)aValue) << " ";
- if (myOStream->bad()) Storage_StreamWriteError::Raise("PutBoolean");
- return *this;
-}
-
-//=======================================================================
-//function : PutReal
-//purpose :
-//=======================================================================
-
-Storage_BaseDriver& DDF_IOStream::PutReal(const Standard_Real aValue)
-{
- *myOStream << ((Standard_Real)aValue) << " ";
- if (myOStream->bad()) Storage_StreamWriteError::Raise("PutReal");
- return *this;
-}
-
-//=======================================================================
-//function : PutShortReal
-//purpose :
-//=======================================================================
-
-Storage_BaseDriver& DDF_IOStream::PutShortReal(const Standard_ShortReal aValue)
-{
- *myOStream << aValue << " ";
- if (myOStream->bad()) Storage_StreamWriteError::Raise("PutShortReal");
- return *this;
-}
-
-
-// ----------------- PUBLIC : GET
-
-
-//=======================================================================
-//function : GetReference
-//purpose :
-//=======================================================================
-
-Storage_BaseDriver& DDF_IOStream::GetReference(Standard_Integer& aValue)
-{
- if (!(*myIStream >> aValue)) Storage_StreamTypeMismatchError::Raise("GetReference");
- return *this;
-}
-
-//=======================================================================
-//function : GetCharacter
-//purpose :
-//=======================================================================
-
-Storage_BaseDriver& DDF_IOStream::GetCharacter(Standard_Character& aValue)
-{
- if (!(*myIStream >> aValue)) Storage_StreamTypeMismatchError::Raise("GetCharacter");
- return *this;
-}
-
-//=======================================================================
-//function : GetExtCharacter
-//purpose :
-//=======================================================================
-
-Storage_BaseDriver& DDF_IOStream::GetExtCharacter(Standard_ExtCharacter& aValue)
-{
- if (!(*myIStream >> aValue)) Storage_StreamTypeMismatchError::Raise("GetExtCharacter");
- return *this;
-}
-
-//=======================================================================
-//function : GetInteger
-//purpose :
-//=======================================================================
-
-Storage_BaseDriver& DDF_IOStream::GetInteger(Standard_Integer& aValue)
-{
- if (!(*myIStream >> aValue)) Storage_StreamTypeMismatchError::Raise("GetInteger");
- return *this;
-}
-
-//=======================================================================
-//function : GetBoolean
-//purpose :
-//=======================================================================
-
-Storage_BaseDriver& DDF_IOStream::GetBoolean(Standard_Boolean& aValue)
-{
- if (!(*myIStream >> aValue)) Storage_StreamTypeMismatchError::Raise("GetBoolean");
- return *this;
-}
-
-//=======================================================================
-//function : GetReal
-//purpose :
-//=======================================================================
-
-Storage_BaseDriver& DDF_IOStream::GetReal(Standard_Real& aValue)
-{
- if (!(*myIStream >> aValue)) Storage_StreamTypeMismatchError::Raise("GetReal");
- return *this;
-}
-
-//=======================================================================
-//function : GetShortReal
-//purpose :
-//=======================================================================
-
-Storage_BaseDriver& DDF_IOStream::GetShortReal(Standard_ShortReal& aValue)
-{
- if (!(*myIStream >> aValue)) Storage_StreamTypeMismatchError::Raise("GetShortReal");
- return *this;
-}
-
-// -------------------------- DESTROY
-
-//=======================================================================
-//function : Destroy
-//purpose :
-//=======================================================================
-
-void DDF_IOStream::Destroy()
-{
- if (OpenMode() != Storage_VSNone) Close();
-}
-
-
-// -------------------------- INFO : WRITE
-
-
-//=======================================================================
-//function : BeginWriteInfoSection
-//purpose :
-//=======================================================================
-
-Storage_Error DDF_IOStream::BeginWriteInfoSection()
-{
- *myOStream << DDF_IOStream::MagicNumber() << '\n';
- *myOStream << "BEGIN_INFO_SECTION\n";
- if (myOStream->bad()) Storage_StreamWriteError::Raise();
-
- return Storage_VSOk;
-}
-
-//=======================================================================
-//function : WriteInfo
-//purpose :
-//=======================================================================
-
-void DDF_IOStream::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& dataType,
- const TColStd_SequenceOfAsciiString& userInfo)
-{
- Standard_Integer i;
-// char *extBuffer;
-
- *myOStream << nbObj;
- *myOStream << "\n";
- *myOStream << dbVersion.ToCString() << "\n";
- *myOStream << date.ToCString() << "\n";
- *myOStream << schemaName.ToCString() << "\n";
- *myOStream << schemaVersion.ToCString() << "\n";
- WriteExtendedLine(appName);
- *myOStream << appVersion.ToCString() << "\n";
- WriteExtendedLine(dataType);
- *myOStream << userInfo.Length() << "\n";
-
- if (myOStream->bad()) Storage_StreamWriteError::Raise();
-
- for (i = 1; i <= userInfo.Length(); i++) {
- *myOStream << userInfo.Value(i).ToCString() << "\n";
- if (myOStream->bad()) Storage_StreamWriteError::Raise();
- }
-}
-
-
-//=======================================================================
-//function : EndWriteInfoSection
-//purpose :
-//=======================================================================
-
-Storage_Error DDF_IOStream::EndWriteInfoSection()
-{
- *myOStream << "END_INFO_SECTION\n";
- if (myOStream->bad()) Storage_StreamWriteError::Raise();
- return Storage_VSOk;
-}
-
-//=======================================================================
-//function : BeginReadInfoSection
-//purpose :
-//=======================================================================
-
-Storage_Error DDF_IOStream::BeginReadInfoSection()
-{
- Storage_Error s;
- TCollection_AsciiString l;
- Standard_Integer len = (Standard_Integer) strlen(DDF_IOStream::MagicNumber());
-
- // Added because of Draw:
- // It don't go to next line after reading its own header line information!
- FlushEndOfLine();
- ReadChar(l,len);
-
- if (strncmp(DDF_IOStream::MagicNumber(),l.ToCString(),len) != 0) {
-#ifdef OCCT_DEBUG
- cout<<"BeginReadInfoSection: format error"<<endl;
-#endif
- s = Storage_VSFormatError;
- }
- else {
- s = FindTag("BEGIN_INFO_SECTION");
- }
-
- return s;
-}
-
-
-// ------------------- INFO : READ
-
-
-//=======================================================================
-//function : ReadInfo
-//purpose :
-//=======================================================================
-
-void DDF_IOStream::ReadInfo(Standard_Integer& nbObj,
- TCollection_AsciiString& dbVersion,
- TCollection_AsciiString& date,
- TCollection_AsciiString& schemaName,
- TCollection_AsciiString& schemaVersion,
- TCollection_ExtendedString& appName,
- TCollection_AsciiString& appVersion,
- TCollection_ExtendedString& dataType,
- TColStd_SequenceOfAsciiString& userInfo)
-{
- if (!(*myIStream >> nbObj)) Storage_StreamTypeMismatchError::Raise("ReadInfo 1");
-
- FlushEndOfLine();
-
- ReadLine(dbVersion);
- ReadLine(date);
- ReadLine(schemaName);
- ReadLine(schemaVersion);
- ReadExtendedLine(appName);
- ReadLine(appVersion);
- ReadExtendedLine(dataType);
-
- Standard_Integer i,len = 0;
-
- if (!(*myIStream >> len)) Storage_StreamTypeMismatchError::Raise("ReadInfo 2");
-
- FlushEndOfLine();
-
- TCollection_AsciiString line;
-
- for (i = 1; i <= len && !IsEnd(); i++) {
- ReadLine(line);
- userInfo.Append(line);
- line.Clear();
- }
-}
-
-//=======================================================================
-//function : EndReadInfoSection
-//purpose :
-//=======================================================================
-
-Storage_Error DDF_IOStream::EndReadInfoSection()
-{ return FindTag("END_INFO_SECTION"); }
-
-
-// ---------------- COMMENTS : WRITE
-
-
-//=======================================================================
-//function : BeginWriteCommentSection
-//purpose :
-//=======================================================================
-
-Storage_Error DDF_IOStream::BeginWriteCommentSection()
-{
- *myOStream << "BEGIN_COMMENT_SECTION\n";
- if (myOStream->bad()) Storage_StreamWriteError::Raise();
- return Storage_VSOk;
-}
-
-//=======================================================================
-//function : WriteComment
-//purpose :
-//=======================================================================
-
-void DDF_IOStream::WriteComment(const TColStd_SequenceOfExtendedString& aCom)
-{
- Standard_Integer i,aSize;
-
- aSize = aCom.Length();
- *myOStream << aSize << "\n";
- if (myOStream->bad()) Storage_StreamWriteError::Raise();
-
- for (i = 1; i <= aSize; i++) {
- WriteExtendedLine(aCom.Value(i));
- if (myOStream->bad()) Storage_StreamWriteError::Raise();
- }
-}
-
-//=======================================================================
-//function : EndWriteCommentSection
-//purpose :
-//=======================================================================
-
-Storage_Error DDF_IOStream::EndWriteCommentSection()
-{
- *myOStream << "END_COMMENT_SECTION\n";
- if (myOStream->bad()) Storage_StreamWriteError::Raise();
- return Storage_VSOk;
-}
-
-
-// ---------------- COMMENTS : READ
-
-
-//=======================================================================
-//function : BeginReadCommentSection
-//purpose :
-//=======================================================================
-
-Storage_Error DDF_IOStream::BeginReadCommentSection()
-{
- return FindTag("BEGIN_COMMENT_SECTION");
-}
-
-//=======================================================================
-//function : ReadComment
-//purpose :
-//=======================================================================
-
-void DDF_IOStream::ReadComment(TColStd_SequenceOfExtendedString& aCom)
-{
- TCollection_ExtendedString line;
- Standard_Integer len,i;
-
- if (!(*myIStream >> len)) Storage_StreamTypeMismatchError::Raise("ReadComment");
-
- FlushEndOfLine();
-
- for (i = 1; i <= len && !IsEnd(); i++) {
- ReadExtendedLine(line);
- aCom.Append(line);
- line.Clear();
- }
-}
-
-//=======================================================================
-//function : EndReadCommentSection
-//purpose :
-//=======================================================================
-
-Storage_Error DDF_IOStream::EndReadCommentSection()
-{ return FindTag("END_COMMENT_SECTION"); }
-
-
-// --------------- TYPE : WRITE
-
-
-//=======================================================================
-//function : BeginWriteTypeSection
-//purpose :
-//=======================================================================
-
-Storage_Error DDF_IOStream::BeginWriteTypeSection()
-{
- *myOStream << "BEGIN_TYPE_SECTION\n";
- if (myOStream->bad()) Storage_StreamWriteError::Raise();
- return Storage_VSOk;
-}
-
-//=======================================================================
-//function : SetTypeSectionSize
-//purpose :
-//=======================================================================
-
-void DDF_IOStream::SetTypeSectionSize(const Standard_Integer aSize)
-{
- *myOStream << aSize << "\n";
- if (myOStream->bad()) Storage_StreamWriteError::Raise();
-}
-
-//=======================================================================
-//function : WriteTypeInformations
-//purpose :
-//=======================================================================
-
-void DDF_IOStream::WriteTypeInformations(const Standard_Integer typeNum,
- const TCollection_AsciiString& typeName)
-{
- *myOStream << typeNum << " " << typeName.ToCString() << "\n";
- if (myOStream->bad()) Storage_StreamWriteError::Raise();
-}
-
-//=======================================================================
-//function : EndWriteTypeSection
-//purpose :
-//=======================================================================
-
-Storage_Error DDF_IOStream::EndWriteTypeSection()
-{
- *myOStream << "END_TYPE_SECTION\n";
- if (myOStream->bad()) Storage_StreamWriteError::Raise();
- return Storage_VSOk;
-}
-
-
-// ------------------- TYPE : READ
-
-
-//=======================================================================
-//function : BeginReadTypeSection
-//purpose :
-//=======================================================================
-
-Storage_Error DDF_IOStream::BeginReadTypeSection()
-{ return FindTag("BEGIN_TYPE_SECTION"); }
-
-//=======================================================================
-//function : TypeSectionSize
-//purpose :
-//=======================================================================
-
-Standard_Integer DDF_IOStream::TypeSectionSize()
-{
- Standard_Integer i;
-
- if (!(*myIStream >> i)) Storage_StreamTypeMismatchError::Raise("TypeSectionSize");
-
- FlushEndOfLine();
-
- return i;
-}
-
-//=======================================================================
-//function : ReadTypeInformations
-//purpose :
-//=======================================================================
-
-void DDF_IOStream::ReadTypeInformations(Standard_Integer& typeNum,
- TCollection_AsciiString& typeName)
-{
- if (!(*myIStream >> typeNum)) Storage_StreamTypeMismatchError::Raise("ReadTypeInformations 1");
- if (!(*myIStream >> typeName)) Storage_StreamTypeMismatchError::Raise("ReadTypeInformations 2");
- FlushEndOfLine();
-}
-
-//=======================================================================
-//function : EndReadTypeSection
-//purpose :
-//=======================================================================
-
-Storage_Error DDF_IOStream::EndReadTypeSection()
-{
- return FindTag("END_TYPE_SECTION");
-}
-
-
-// -------------------- ROOT : WRITE
-
-
-//=======================================================================
-//function : BeginWriteRootSection
-//purpose :
-//=======================================================================
-
-Storage_Error DDF_IOStream::BeginWriteRootSection()
-{
- *myOStream << "BEGIN_ROOT_SECTION\n";
- if (myOStream->bad()) Storage_StreamWriteError::Raise();
- return Storage_VSOk;
-}
-
-//=======================================================================
-//function : SetRootSectionSize
-//purpose :
-//=======================================================================
-
-void DDF_IOStream::SetRootSectionSize(const Standard_Integer aSize)
-{
- *myOStream << aSize << "\n";
- if (myOStream->bad()) Storage_StreamWriteError::Raise();
-}
-
-//=======================================================================
-//function : WriteRoot
-//purpose :
-//=======================================================================
-
-void DDF_IOStream::WriteRoot(const TCollection_AsciiString& rootName, const Standard_Integer aRef, const TCollection_AsciiString& rootType)
-{
- *myOStream << aRef << " " << rootName.ToCString() << " " << rootType.ToCString() << "\n";
- if (myOStream->bad()) Storage_StreamWriteError::Raise();
-}
-
-//=======================================================================
-//function : EndWriteRootSection
-//purpose :
-//=======================================================================
-
-Storage_Error DDF_IOStream::EndWriteRootSection()
-{
- *myOStream << "END_ROOT_SECTION\n";
- if (myOStream->bad()) Storage_StreamWriteError::Raise();
- return Storage_VSOk;
-}
-
-
-// ----------------------- ROOT : READ
-
-
-//=======================================================================
-//function : BeginReadRootSection
-//purpose :
-//=======================================================================
-
-Storage_Error DDF_IOStream::BeginReadRootSection()
-{ return FindTag("BEGIN_ROOT_SECTION"); }
-
-//=======================================================================
-//function : RootSectionSize
-//purpose :
-//=======================================================================
-
-Standard_Integer DDF_IOStream::RootSectionSize()
-{
- Standard_Integer i;
-
- if (!(*myIStream >> i)) Storage_StreamTypeMismatchError::Raise("RootSectionSize");
-
- FlushEndOfLine();
-
- return i;
-}
-
-//=======================================================================
-//function : ReadRoot
-//purpose :
-//=======================================================================
-
-void DDF_IOStream::ReadRoot(TCollection_AsciiString& rootName, Standard_Integer& aRef,TCollection_AsciiString& rootType)
-{
- if (!(*myIStream >> aRef)) Storage_StreamTypeMismatchError::Raise("ReadRoot");
- ReadWord(rootName);
- ReadWord(rootType);
-}
-
-//=======================================================================
-//function : EndReadRootSection
-//purpose :
-//=======================================================================
-
-Storage_Error DDF_IOStream::EndReadRootSection()
-{ return FindTag("END_ROOT_SECTION"); }
-
-
-// -------------------------- REF : WRITE
-
-
-//=======================================================================
-//function : BeginWriteRefSection
-//purpose :
-//=======================================================================
-
-Storage_Error DDF_IOStream::BeginWriteRefSection()
-{
- *myOStream << "BEGIN_REF_SECTION\n";
- if (myOStream->bad()) Storage_StreamWriteError::Raise();
- return Storage_VSOk;
-}
-
-//=======================================================================
-//function : SetRefSectionSize
-//purpose :
-//=======================================================================
-
-void DDF_IOStream::SetRefSectionSize(const Standard_Integer aSize)
-{
- *myOStream << aSize << "\n";
- if (myOStream->bad()) Storage_StreamWriteError::Raise();
-}
-
-//=======================================================================
-//function : WriteReferenceType
-//purpose :
-//=======================================================================
-
-void DDF_IOStream::WriteReferenceType(const Standard_Integer reference,
- const Standard_Integer typeNum)
-{
- *myOStream << reference << " " << typeNum << "\n";
- if (myOStream->bad()) Storage_StreamWriteError::Raise();
-}
-
-//=======================================================================
-//function : EndWriteRefSection
-//purpose :
-//=======================================================================
-
-Storage_Error DDF_IOStream::EndWriteRefSection()
-{
- *myOStream << "END_REF_SECTION\n";
- if (myOStream->bad()) Storage_StreamWriteError::Raise();
- return Storage_VSOk;
-}
-
-
-// ----------------------- REF : READ
-
-
-//=======================================================================
-//function : BeginReadRefSection
-//purpose :
-//=======================================================================
-
-Storage_Error DDF_IOStream::BeginReadRefSection()
-{ return FindTag("BEGIN_REF_SECTION"); }
-
-//=======================================================================
-//function : RefSectionSize
-//purpose :
-//=======================================================================
-
-Standard_Integer DDF_IOStream::RefSectionSize()
-{
- Standard_Integer i;
-
- if (!(*myIStream >> i)) Storage_StreamTypeMismatchError::Raise("RefSectionSize");
- FlushEndOfLine();
-
- return i;
-}
-
-//=======================================================================
-//function : ReadReferenceType
-//purpose :
-//=======================================================================
-
-void DDF_IOStream::ReadReferenceType(Standard_Integer& reference,
- Standard_Integer& typeNum)
-{
- if (!(*myIStream >> reference)) Storage_StreamTypeMismatchError::Raise("ReadReferenceType 1");
- if (!(*myIStream >> typeNum)) Storage_StreamTypeMismatchError::Raise("ReadReferenceType 2");
- FlushEndOfLine();
-}
-
-//=======================================================================
-//function : EndReadRefSection
-//purpose :
-//=======================================================================
-
-Storage_Error DDF_IOStream::EndReadRefSection()
-{
- return FindTag("END_REF_SECTION");
-}
-
-
-// -------------------- DATA : WRITE
-
-
-//=======================================================================
-//function : BeginWriteDataSection
-//purpose :
-//=======================================================================
-
-Storage_Error DDF_IOStream::BeginWriteDataSection()
-{
- *myOStream << "BEGIN_DATA_SECTION";
- if (myOStream->bad()) Storage_StreamWriteError::Raise();
- return Storage_VSOk;
-}
-
-//=======================================================================
-//function : WritePersistentObjectHeader
-//purpose :
-//=======================================================================
-
-void DDF_IOStream::WritePersistentObjectHeader(const Standard_Integer aRef,
- const Standard_Integer aType)
-{
- *myOStream << "\n#" << aRef << "=%" << aType;
- if (myOStream->bad()) Storage_StreamWriteError::Raise();
-}
-
-//=======================================================================
-//function : BeginWritePersistentObjectData
-//purpose :
-//=======================================================================
-
-void DDF_IOStream::BeginWritePersistentObjectData()
-{
- *myOStream << "( ";
- if (myOStream->bad()) Storage_StreamWriteError::Raise();
-}
-
-//=======================================================================
-//function : BeginWriteObjectData
-//purpose :
-//=======================================================================
-
-void DDF_IOStream::BeginWriteObjectData()
-{
- *myOStream << "( ";
- if (myOStream->bad()) Storage_StreamWriteError::Raise();
-}
-
-//=======================================================================
-//function : EndWriteObjectData
-//purpose :
-//=======================================================================
-
-void DDF_IOStream::EndWriteObjectData()
-{
- *myOStream << ") ";
- if (myOStream->bad()) Storage_StreamWriteError::Raise();
-}
-
-//=======================================================================
-//function : EndWritePersistentObjectData
-//purpose :
-//=======================================================================
-
-void DDF_IOStream::EndWritePersistentObjectData()
-{
- *myOStream << ")";
- if (myOStream->bad()) Storage_StreamWriteError::Raise();
-}
-
-//=======================================================================
-//function : EndWriteDataSection
-//purpose :
-//=======================================================================
-
-Storage_Error DDF_IOStream::EndWriteDataSection()
-{
- *myOStream << "\nEND_DATA_SECTION\n";
- if (myOStream->bad()) Storage_StreamWriteError::Raise();
- return Storage_VSOk;
-}
-
-
-// ---------------------- DATA : READ
-
-
-//=======================================================================
-//function : BeginReadDataSection
-//purpose :
-//=======================================================================
-
-Storage_Error DDF_IOStream::BeginReadDataSection()
-{ return FindTag("BEGIN_DATA_SECTION"); }
-
-//=======================================================================
-//function : ReadPersistentObjectHeader
-//purpose :
-//=======================================================================
-
-void DDF_IOStream::ReadPersistentObjectHeader(Standard_Integer& aRef,
- Standard_Integer& aType)
-{
- char c;
-
- myIStream->get(c);
-
- while (c != '#') {
- if (IsEnd() || (c != ' ') || (c == '\n')) {
- Storage_StreamFormatError::Raise();
- }
- myIStream->get(c);
- }
-
- if (!(*myIStream >> aRef)) Storage_StreamTypeMismatchError::Raise("ReadPersistentObjectHeader 1");
- myIStream->get(c);
-
- while (c != '=') {
- if (IsEnd() || (c != ' ') || (c == '\n')) {
- Storage_StreamFormatError::Raise();
- }
- myIStream->get(c);
- }
-
- myIStream->get(c);
-
- while (c != '%') {
- if (IsEnd() || (c != ' ') || (c == '\n')) {
- Storage_StreamFormatError::Raise();
- }
- myIStream->get(c);
- }
-
- if (!(*myIStream >> aType)) Storage_StreamTypeMismatchError::Raise("ReadPersistentObjectHeader 2");
-}
-
-//=======================================================================
-//function : BeginReadPersistentObjectData
-//purpose :
-//=======================================================================
-
-void DDF_IOStream::BeginReadPersistentObjectData()
-{
- char c;
- myIStream->get(c);
- while (c != '(') {
- if (IsEnd() || (c != ' ') || (c == '\n')) {
- Storage_StreamFormatError::Raise();
- }
- myIStream->get(c);
- }
-}
-
-//=======================================================================
-//function : BeginReadObjectData
-//purpose :
-//=======================================================================
-
-void DDF_IOStream::BeginReadObjectData()
-{
- char c;
- myIStream->get(c);
- while (c != '(') {
- if (IsEnd() || (c != ' ') || (c == '\n')) {
- Storage_StreamFormatError::Raise("BeginReadObjectData");
- }
- myIStream->get(c);
- }
-}
-
-//=======================================================================
-//function : EndReadObjectData
-//purpose :
-//=======================================================================
-
-void DDF_IOStream::EndReadObjectData()
-{
- char c;
- myIStream->get(c);
- while (c != ')') {
- if (IsEnd() || (c != ' ') || (c == '\n')) {
- Storage_StreamFormatError::Raise("EndReadObjectData");
- }
- myIStream->get(c);
- }
-}
-
-//=======================================================================
-//function : EndReadPersistentObjectData
-//purpose :
-//=======================================================================
-
-void DDF_IOStream::EndReadPersistentObjectData()
-{
- char c;
-
- myIStream->get(c);
- while (c != ')') {
- if (IsEnd() || (c != ' ') || (c == '\n')) {
- Storage_StreamFormatError::Raise("EndReadPersistentObjectData");
- }
- myIStream->get(c);
- }
-
- myIStream->get(c);
- while (c != '\n') {
- if (IsEnd() || (c != ' ')) {
- Storage_StreamFormatError::Raise();
- }
- myIStream->get(c);
- }
-}
-
-//=======================================================================
-//function : EndReadDataSection
-//purpose :
-//=======================================================================
-
-Storage_Error DDF_IOStream::EndReadDataSection()
-{ return FindTag("END_DATA_SECTION"); }
-
-//=======================================================================
-//function : IsGoodFileType
-//purpose :
-//=======================================================================
-
-Storage_Error DDF_IOStream::IsGoodFileType(istream* anIStream)
-{
- DDF_IOStream f;
- Storage_Error s;
-
- s = f.Open(anIStream);
-
- if (s == Storage_VSOk) {
- TCollection_AsciiString l;
- Standard_Integer len = (Standard_Integer) strlen(DDF_IOStream::MagicNumber());
-
- f.ReadChar(l,len);
-
- f.Close();
-
- if (strncmp(DDF_IOStream::MagicNumber(),l.ToCString(),len) != 0) {
-#ifdef OCCT_DEBUG
- cout<<"IsGoodFileType: format error"<<endl;
-#endif
- s = Storage_VSFormatError;
- }
- }
-
- return s;
-}
-
+++ /dev/null
-// 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
DDF_DataCommands.cxx
DDF_TransactionCommands.cxx
DDF_BrowserCommands.cxx
-DDF_IOStream.cxx
-DDF_IOStream.hxx
FILES
uses Position from Storage,
Error from Storage,
OpenMode from Storage,
+ IODevice from Storage,
AsciiString from TCollection,
SequenceOfAsciiString from TColStd,
SequenceOfExtendedString from TColStd,
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
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;
//purpose :
//=======================================================================
-FSD_BinaryFile::FSD_BinaryFile() :
-myStream(0L)
+FSD_BinaryFile::FSD_BinaryFile()
{
myHeader.testindian = -1;
myHeader.binfo = -1;
// 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;
//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);
}
return result;
+*/
}
//=======================================================================
Standard_Boolean FSD_BinaryFile::IsEnd()
{
- return (feof(myStream) != 0);
+ return !Device().IsNull() ? Device()->IsEnd() : Standard_True;
}
//=======================================================================
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;
buffer.Clear();
while (!IsEnd() && (ccount < rsize)) {
- fread(&c, sizeof(char),1, myStream);
+ Device()->Read(&c, sizeof(char));
buffer += c;
ccount++;
}
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( &t, sizeof(Standard_Integer) ) != sizeof(Standard_Integer) )
+ Storage_StreamWriteError::Raise();
+
return *this;
}
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;
}
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(&t, sizeof(Standard_ExtCharacter)) != sizeof(Standard_ExtCharacter) )
+ Storage_StreamWriteError::Raise();
+
return *this;
}
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(&t,sizeof(Standard_Integer)) != sizeof(Standard_Integer))
+ Storage_StreamWriteError::Raise();
return *this;
}
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(&t,sizeof(Standard_Integer)) != sizeof(Standard_Integer) )
+ Storage_StreamWriteError::Raise();
+
return *this;
}
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(&t,sizeof(Standard_Real)) != sizeof(Standard_Real) )
+ Storage_StreamWriteError::Raise();
+
return *this;
}
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(&t,sizeof(Standard_ShortReal)) != sizeof(Standard_ShortReal) )
+ Storage_StreamWriteError::Raise();
+
return *this;
}
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(&aValue,sizeof(Standard_Integer)) != sizeof(Standard_Integer) )
Storage_StreamTypeMismatchError::Raise();
#if DO_INVERSE
aValue = InverseInt (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(&aValue,sizeof(Standard_Character)) != sizeof(Standard_Character) )
Storage_StreamTypeMismatchError::Raise();
+
return *this;
}
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(&aValue,sizeof(Standard_ExtCharacter)) != sizeof(Standard_ExtCharacter) )
Storage_StreamTypeMismatchError::Raise();
#if DO_INVERSE
aValue = InverseExtChar (aValue);
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(&aValue,sizeof(Standard_Integer)) != sizeof(Standard_Integer) )
Storage_StreamTypeMismatchError::Raise();
#if DO_INVERSE
aValue = InverseInt (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(&aValue,sizeof(Standard_Boolean)) != sizeof(Standard_Boolean) )
Storage_StreamTypeMismatchError::Raise();
#if DO_INVERSE
aValue = InverseInt ((Standard_Integer) 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(&aValue,sizeof(Standard_Real)) != sizeof(Standard_Real))
Storage_StreamTypeMismatchError::Raise();
#if DO_INVERSE
aValue = InverseReal (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(&aValue,sizeof(Standard_ShortReal)) != sizeof(Standard_ShortReal))
Storage_StreamTypeMismatchError::Raise();
#if DO_INVERSE
aValue = InverseShortReal (aValue);
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;
Storage_Error FSD_BinaryFile::EndWriteInfoSection()
{
- myHeader.einfo = ftell(myStream);
+ myHeader.einfo = Device()->Tell();
return Storage_VSOk;
}
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;
}
//=======================================================================
Storage_Error FSD_BinaryFile::BeginWriteCommentSection()
{
- myHeader.bcomment = ftell(myStream);
+ myHeader.bcomment = Device()->Tell();
return Storage_VSOk;
}
Storage_Error FSD_BinaryFile::EndWriteCommentSection()
{
- myHeader.ecomment = ftell(myStream);
+ myHeader.ecomment = Device()->Tell();
return Storage_VSOk;
}
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;
}
//=======================================================================
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;
}
//=======================================================================
Storage_Error FSD_BinaryFile::BeginWriteTypeSection()
{
- myHeader.btype = ftell(myStream);
+ myHeader.btype = Device()->Tell();
return Storage_VSOk;
}
Storage_Error FSD_BinaryFile::EndWriteTypeSection()
{
- myHeader.etype = ftell(myStream);
+ myHeader.etype = Device()->Tell();
return Storage_VSOk;
}
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;
}
//=======================================================================
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;
}
//=======================================================================
Storage_Error FSD_BinaryFile::BeginWriteRootSection()
{
- myHeader.broot = ftell(myStream);
+ myHeader.broot = Device()->Tell();
return Storage_VSOk;
}
Storage_Error FSD_BinaryFile::EndWriteRootSection()
{
- myHeader.eroot = ftell(myStream);
+ myHeader.eroot = Device()->Tell();
return Storage_VSOk;
}
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;
}
//=======================================================================
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;
}
//=======================================================================
Storage_Error FSD_BinaryFile::BeginWriteRefSection()
{
- myHeader.bref = ftell(myStream);
+ myHeader.bref = Device()->Tell();
return Storage_VSOk;
}
Storage_Error FSD_BinaryFile::EndWriteRefSection()
{
- myHeader.eref = ftell(myStream);
+ myHeader.eref = Device()->Tell();
return Storage_VSOk;
}
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;
}
//=======================================================================
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;
}
//=======================================================================
Storage_Error FSD_BinaryFile::BeginWriteDataSection()
{
- myHeader.bdata = ftell(myStream);
+ myHeader.bdata = Device()->Tell();
return Storage_VSOk;
}
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;
}
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;
}
//=======================================================================
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;
}
//=======================================================================
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) != size )
+ Storage_StreamWriteError::Raise();
}
}
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(c,size) != size )
+ Storage_StreamReadError::Raise();
c[size] = '\0';
aString = c;
Standard::Free(c);
#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();
}
}
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(c,size*sizeof(Standard_ExtCharacter)) != size*sizeof(Standard_ExtCharacter) )
Storage_StreamWriteError::Raise();
c[size] = '\0';
#if DO_INVERSE
Storage_Position FSD_BinaryFile::Tell()
{
- return (Storage_Position) ftell(myStream);
+ return Device()->Tell();
}
uses Position from Storage,
Error from Storage,
OpenMode from Storage,
+ IODevice from Storage,
AsciiString from TCollection,
SequenceOfAsciiString from TColStd,
SequenceOfExtendedString from TColStd,
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
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.
// 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;
//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);
result = Storage_VSAlreadyOpen;
}
return result;
+ */
}
//=======================================================================
Standard_Boolean FSD_CmpFile::IsEnd()
{
- return myStream.eof();
+ return !Device().IsNull() ? Device()->IsEnd() : Standard_True;
}
//=======================================================================
Storage_Error result = Storage_VSOk;
if (OpenMode() != Storage_VSNone) {
- myStream.close();
- SetOpenMode(Storage_VSNone);
+ Device()->Close();
}
else {
result = Storage_VSNotOpen;
*/
}
+//=======================================================================
+//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() ) != buffer.Length() )
+ Storage_StreamWriteError::Raise();
+}
+
+
//=======================================================================
//function : ReadLine
//purpose : read from the current position to the end of line.
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( &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
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;
PutExtCharacter(extBuffer[i]);
}
- myStream << "\n";
+ Device()->Write("\n", 1);
}
//=======================================================================
buffer.Clear();
while (!IsEnd() && (ccount < rsize)) {
- myStream.get(c);
+ Device()->Read( &c, sizeof( char ) );
buffer += c;
ccount++;
}
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(&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
buffer.Clear();
while (!IsEnd && !FSD_CmpFile::IsEnd()) {
- myStream.get(c);
- if ((c != ' ') && (c != '\n')) IsEnd = Standard_True;
+ Device()->Read( &c, sizeof(char) );
+ if ((c != ' ') && (c != '\n'))
+ {
+ IsEnd = Standard_True;
+ }
}
IsEnd = Standard_False;
}
*tmpb = c;
tmpb++; i++;
- myStream.get(c);
- if ((c == '\n') || (c == ' ')) IsEnd = Standard_True;
+ Device()->Read( &c, sizeof(char) );
+ if ((c == '\n') || (c == ' '))
+ {
+ IsEnd = Standard_True;
+ }
}
buffer += b;
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() ) != aStr.Length() )
+ Storage_StreamWriteError::Raise();
return *this;
}
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() ) != aStr.Length() )
+ Storage_StreamWriteError::Raise();
- i = aValue;
- myStream << i << " ";
- if (myStream.bad()) Storage_StreamWriteError::Raise();
return *this;
}
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() ) != aStr.Length() )
+ Storage_StreamWriteError::Raise();
+
return *this;
}
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() ) != aStr.Length() )
+ Storage_StreamWriteError::Raise();
+
return *this;
}
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() ) != aStr.Length() )
+ Storage_StreamWriteError::Raise();
+
return *this;
}
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() ) != aStr.Length() )
+ Storage_StreamWriteError::Raise();
+
return *this;
}
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() ) != aStr.Length() )
+ Storage_StreamWriteError::Raise();
+
return *this;
}
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;
}
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;
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;
}
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;
}
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;
}
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;
}
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 = aStr.RealValue();
+ else
Storage_StreamTypeMismatchError::Raise();
- aValue = (Standard_ShortReal)r;
-
return *this;
}
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;
}
{
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";
-
- if (myStream.bad()) Storage_StreamWriteError::Raise();
+ PutInteger( userInfo.Length() );
+ WriteLine( "" );
- 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
Storage_Error FSD_CmpFile::EndWriteInfoSection()
{
- myStream << "END_INFO_SECTION\n";
- if (myStream.bad()) Storage_StreamWriteError::Raise();
+ WriteLine( "END_INFO_SECTION" );
return Storage_VSOk;
}
TCollection_ExtendedString& dataType,
TColStd_SequenceOfAsciiString& userInfo)
{
- if (!(myStream >> nbObj)) Storage_StreamTypeMismatchError::Raise();
+ GetInteger( nbObj );
FlushEndOfLine();
Standard_Integer i,len = 0;
- if (!(myStream >> len)) Storage_StreamTypeMismatchError::Raise();
+ GetInteger( len );
FlushEndOfLine();
Storage_Error FSD_CmpFile::BeginWriteCommentSection()
{
- myStream << "BEGIN_COMMENT_SECTION\n";
- if (myStream.bad()) Storage_StreamWriteError::Raise();
+ WriteLine( "BEGIN_COMMENT_SECTION" );
+
return Storage_VSOk;
}
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();
}
}
Storage_Error FSD_CmpFile::EndWriteCommentSection()
{
- myStream << "END_COMMENT_SECTION\n";
- if (myStream.bad()) Storage_StreamWriteError::Raise();
+ WriteLine ("END_COMMENT_SECTION");
+
return Storage_VSOk;
}
TCollection_ExtendedString line;
Standard_Integer len,i;
- if (!(myStream >> len)) Storage_StreamTypeMismatchError::Raise();
+ GetInteger (len);
FlushEndOfLine();
Storage_Error FSD_CmpFile::BeginWriteTypeSection()
{
- myStream << "BEGIN_TYPE_SECTION\n";
- if (myStream.bad()) Storage_StreamWriteError::Raise();
+ WriteLine ("BEGIN_TYPE_SECTION");
+
return Storage_VSOk;
}
void FSD_CmpFile::SetTypeSectionSize(const Standard_Integer aSize)
{
- myStream << aSize << "\n";
- if (myStream.bad()) Storage_StreamWriteError::Raise();
+ WriteLine (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());
}
//=======================================================================
Storage_Error FSD_CmpFile::EndWriteTypeSection()
{
- myStream << "END_TYPE_SECTION\n";
- if (myStream.bad()) Storage_StreamWriteError::Raise();
+ WriteLine ("END_TYPE_SECTION");
+
return Storage_VSOk;
}
{
Standard_Integer i;
- if (!(myStream >> i)) Storage_StreamTypeMismatchError::Raise();
+ GetInteger (i);
FlushEndOfLine();
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();
}
Storage_Error FSD_CmpFile::BeginWriteRootSection()
{
- myStream << "BEGIN_ROOT_SECTION\n";
- if (myStream.bad()) Storage_StreamWriteError::Raise();
+ WriteLine ("BEGIN_ROOT_SECTION");
+
return Storage_VSOk;
}
void FSD_CmpFile::SetRootSectionSize(const Standard_Integer aSize)
{
- myStream << aSize << "\n";
- if (myStream.bad()) Storage_StreamWriteError::Raise();
+ WriteLine (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());
}
//=======================================================================
Storage_Error FSD_CmpFile::EndWriteRootSection()
{
- myStream << "END_ROOT_SECTION\n";
- if (myStream.bad()) Storage_StreamWriteError::Raise();
+ WriteLine ("END_ROOT_SECTION");
+
return Storage_VSOk;
}
Standard_Integer FSD_CmpFile::RootSectionSize()
{
Standard_Integer i;
-
- if (!(myStream >> i)) Storage_StreamTypeMismatchError::Raise();
-
+ GetInteger (i);
FlushEndOfLine();
return i;
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);
}
Storage_Error FSD_CmpFile::BeginWriteRefSection()
{
- myStream << "BEGIN_REF_SECTION\n";
- if (myStream.bad()) Storage_StreamWriteError::Raise();
+ WriteLine ("BEGIN_REF_SECTION");
return Storage_VSOk;
}
void FSD_CmpFile::SetRefSectionSize(const Standard_Integer aSize)
{
- myStream << aSize << "\n";
- if (myStream.bad()) Storage_StreamWriteError::Raise();
+ WriteLine (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);
}
//=======================================================================
Storage_Error FSD_CmpFile::EndWriteRefSection()
{
- myStream << "END_REF_SECTION\n";
- if (myStream.bad()) Storage_StreamWriteError::Raise();
+ WriteLine ("END_REF_SECTION");
+
return Storage_VSOk;
}
{
Standard_Integer i;
- if (!(myStream >> i)) Storage_StreamTypeMismatchError::Raise();
+ GetInteger (i);
FlushEndOfLine();
return i;
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();
}
Storage_Error FSD_CmpFile::BeginWriteDataSection()
{
- myStream << "BEGIN_DATA_SECTION";
- if (myStream.bad()) Storage_StreamWriteError::Raise();
+ WriteLine ("BEGIN_DATA_SECTION", Standard_False);
return Storage_VSOk;
}
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);
}
//=======================================================================
void FSD_CmpFile::BeginWritePersistentObjectData()
{
- if (myStream.bad()) Storage_StreamWriteError::Raise();
+
}
//=======================================================================
void FSD_CmpFile::BeginWriteObjectData()
{
- if (myStream.bad()) Storage_StreamWriteError::Raise();
+
}
//=======================================================================
void FSD_CmpFile::EndWriteObjectData()
{
- if (myStream.bad()) Storage_StreamWriteError::Raise();
+
}
//=======================================================================
void FSD_CmpFile::EndWritePersistentObjectData()
{
- if (myStream.bad()) Storage_StreamWriteError::Raise();
+
}
//=======================================================================
Storage_Error FSD_CmpFile::EndWriteDataSection()
{
- myStream << "\nEND_DATA_SECTION\n";
- if (myStream.bad()) Storage_StreamWriteError::Raise();
+ WriteLine ("\nEND_DATA_SECTION");
+
return Storage_VSOk;
}
{
char c;
- myStream.get(c);
+ Device()->Read( &c, sizeof( char ) );
while (c != '#') {
if (IsEnd() || (c != ' ') || (c == '\r')|| (c == '\n')) {
Storage_StreamFormatError::Raise();
}
- myStream.get(c);
+ Device()->Read( &c, sizeof( char ) );
}
- if (!(myStream >> aRef)) Storage_StreamTypeMismatchError::Raise();
+ GetInteger (aRef);
- myStream.get(c);
+ Device()->Read( &c, sizeof( char ) );
while (c != '%') {
if (IsEnd() || (c != ' ') || (c == '\r')|| (c == '\n')) {
Storage_StreamFormatError::Raise();
}
- myStream.get(c);
+ Device()->Read( &c, sizeof( char ) );
}
- if (!(myStream >> aType)) Storage_StreamTypeMismatchError::Raise();
-// cout << "REF:" << aRef << " TYPE:"<< aType << endl;
+ GetInteger (aType);
}
//=======================================================================
void FSD_CmpFile::BeginReadPersistentObjectData()
{
-//cout << "BeginReadPersistentObjectData" << endl;
}
//=======================================================================
void FSD_CmpFile::BeginReadObjectData()
{
-// cout << "BeginReadObjectData" << endl;
}
//=======================================================================
void FSD_CmpFile::EndReadObjectData()
{
-// cout << "EndReadObjectData" << endl;
}
//=======================================================================
{
char c;
- myStream.get(c);
+ Device()->Read( &c, sizeof( char ) );
while (c != '\n' && (c != '\r')) {
if (IsEnd() || (c != ' ')) {
Storage_StreamFormatError::Raise();
}
- myStream.get(c);
+ Device()->Read( &c, sizeof( char ) );
}
if (c == '\r') {
- myStream.get(c);
+ Device()->Read( &c, sizeof( char ) );
}
-// cout << "EndReadPersistentObjectData" << endl;
}
//=======================================================================
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;
- }
-}
uses Position from Storage,
Error from Storage,
OpenMode from Storage,
+ IODevice from Storage,
AsciiString from TCollection,
SequenceOfAsciiString from TColStd,
SequenceOfExtendedString from TColStd,
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
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
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.
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;
returns CString from Standard is private;
---C++: return const
- fields
-
- myStream : FStream from FSD;
end;
// 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;
//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);
+
+ if ( Device().IsNull() )
+ return Storage_VSOpenError;
- SetName(aName);
+ return Device()->Open(aMode);
+ /*
+ Storage_Error result = Storage_VSOk;
if (OpenMode() == Storage_VSNone) {
}
return result;
+ */
}
//=======================================================================
Standard_Boolean FSD_File::IsEnd()
{
- return myStream.eof();
+ return !Device().IsNull() ? Device()->IsEnd() : Standard_True;
}
//=======================================================================
Storage_Error result = Storage_VSOk;
if (OpenMode() != Storage_VSNone) {
- myStream.close();
- SetOpenMode(Storage_VSNone);
+ Device()->Close();
}
else {
result = Storage_VSNotOpen;
}*/
}
+//=======================================================================
+//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() ) != buffer.Length() )
+ Storage_StreamWriteError::Raise();
+}
+
//=======================================================================
//function : ReadLine
//purpose : read from the current position to the end of line.
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( &c, 1 );
+ if ( c != '\n')
+ buffer += c;
+ else
+ {
+ buffer += '\0';
IsEnd = Standard_True;
-// }
+ }
}
}
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( &cc, sizeof(char) );
+ Device()->Write( &cd, sizeof(char) );
}
- myStream << (char)0 << "\n";
+ Device()->Write("\0\n", 2);
}
//=======================================================================
buffer.Clear();
while (!fin && !IsEnd()) {
- myStream.get(c);
+ Device()->Read( &c, sizeof(char) );
if (c == tg[count]) count++;
else count = 0;
if (c == '\0') fin = Standard_True;
i = (i << 8);
- myStream.get(c);
+ Device()->Read( &c, sizeof(char) );
if (c == tg[count]) count++;
else count = 0;
if (count < SIZEOFNORMALEXTENDEDSECTION) {
buffer.Clear();
while (!IsEnd() && (ccount < rsize)) {
- myStream.get(c);
+ Device()->Read( &c, sizeof( char ) );
buffer += c;
ccount++;
}
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(&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;
-// }
+ }
}
-
}
//=======================================================================
buffer.Clear();
while (!IsEnd && !FSD_File::IsEnd()) {
- myStream.get(c);
- if ((c != ' ') && (c != '\n')) IsEnd = Standard_True;
+ Device()->Read( &c, sizeof(char) );
+ if ((c != ' ') && (c != '\n'))
+ IsEnd = Standard_True;
}
IsEnd = Standard_False;
}
*tmpb = c;
tmpb++; i++;
- myStream.get(c);
- if ((c == '\n') || (c == ' ')) IsEnd = Standard_True;
+ Device()->Read( &c, sizeof(char) );
+ if ((c == '\n') || (c == ' '))
+ IsEnd = Standard_True;
}
buffer += b;
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() ) != aStr.Length() )
+ Storage_StreamWriteError::Raise();
+
return *this;
}
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() ) != aStr.Length() )
+ Storage_StreamWriteError::Raise();
return *this;
}
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() ) != aStr.Length() )
+ Storage_StreamWriteError::Raise();
return *this;
}
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() ) != aStr.Length() )
+ Storage_StreamWriteError::Raise();
return *this;
}
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() ) != aStr.Length() )
+ Storage_StreamWriteError::Raise();
return *this;
}
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() ) != aStr.Length() )
+ Storage_StreamWriteError::Raise();
return *this;
}
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() ) != aStr.Length() )
+ Storage_StreamWriteError::Raise();
return *this;
}
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;
}
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;
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;
}
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;
}
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;
}
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();
-
- return *this;
-#else
- if (!(myStream >> aValue)) Storage_StreamTypeMismatchError::Raise();
+ TCollection_AsciiString aStr;
+ ReadWord( aStr );
+ if ( aStr.IsRealValue() )
+ aValue = aStr.RealValue();
+ else
+ Storage_StreamTypeMismatchError::Raise();
return *this;
-#endif
}
//=======================================================================
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 = aStr.RealValue();
+ else
+ Storage_StreamTypeMismatchError::Raise();
return *this;
-#endif
}
//=======================================================================
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;
}
{
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";
-
- if (myStream.bad()) Storage_StreamWriteError::Raise();
+ PutInteger( userInfo.Length() );
+ WriteLine( "" );
- 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) );
}
//=======================================================================
Storage_Error FSD_File::EndWriteInfoSection()
{
- myStream << "END_INFO_SECTION\n";
- if (myStream.bad()) Storage_StreamWriteError::Raise();
+ WriteLine( "END_INFO_SECTION" );
+
return Storage_VSOk;
}
TCollection_ExtendedString& dataType,
TColStd_SequenceOfAsciiString& userInfo)
{
- if (!(myStream >> nbObj)) Storage_StreamTypeMismatchError::Raise();
+ GetInteger( nbObj );
FlushEndOfLine();
Standard_Integer i,len = 0;
- if (!(myStream >> len)) Storage_StreamTypeMismatchError::Raise();
+ GetInteger( len );
FlushEndOfLine();
Storage_Error FSD_File::BeginWriteCommentSection()
{
- myStream << "BEGIN_COMMENT_SECTION\n";
- if (myStream.bad()) Storage_StreamWriteError::Raise();
+ WriteLine( "BEGIN_COMMENT_SECTION" );
+
return Storage_VSOk;
}
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();
}
}
Storage_Error FSD_File::EndWriteCommentSection()
{
- myStream << "END_COMMENT_SECTION\n";
- if (myStream.bad()) Storage_StreamWriteError::Raise();
+ WriteLine( "END_COMMENT_SECTION" );
+
return Storage_VSOk;
}
TCollection_ExtendedString line;
Standard_Integer len,i;
- if (!(myStream >> len)) Storage_StreamTypeMismatchError::Raise();
+ GetInteger (len);
FlushEndOfLine();
Storage_Error FSD_File::BeginWriteTypeSection()
{
- myStream << "BEGIN_TYPE_SECTION\n";
- if (myStream.bad()) Storage_StreamWriteError::Raise();
+ WriteLine ("BEGIN_TYPE_SECTION");
return Storage_VSOk;
}
void FSD_File::SetTypeSectionSize(const Standard_Integer aSize)
{
- myStream << aSize << "\n";
- if (myStream.bad()) Storage_StreamWriteError::Raise();
+ WriteLine (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());
}
//=======================================================================
Storage_Error FSD_File::EndWriteTypeSection()
{
- myStream << "END_TYPE_SECTION\n";
- if (myStream.bad()) Storage_StreamWriteError::Raise();
+ WriteLine ("END_TYPE_SECTION");
+
return Storage_VSOk;
}
Standard_Integer FSD_File::TypeSectionSize()
{
Standard_Integer i;
-
- if (!(myStream >> i)) Storage_StreamTypeMismatchError::Raise();
-
+ GetInteger (i);
FlushEndOfLine();
-
return i;
}
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();
}
Storage_Error FSD_File::BeginWriteRootSection()
{
- myStream << "BEGIN_ROOT_SECTION\n";
- if (myStream.bad()) Storage_StreamWriteError::Raise();
+ WriteLine ("BEGIN_ROOT_SECTION");
return Storage_VSOk;
}
void FSD_File::SetRootSectionSize(const Standard_Integer aSize)
{
- myStream << aSize << "\n";
- if (myStream.bad()) Storage_StreamWriteError::Raise();
+ WriteLine (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());
}
//=======================================================================
Storage_Error FSD_File::EndWriteRootSection()
{
- myStream << "END_ROOT_SECTION\n";
- if (myStream.bad()) Storage_StreamWriteError::Raise();
+ WriteLine ("END_ROOT_SECTION");
return Storage_VSOk;
}
Standard_Integer FSD_File::RootSectionSize()
{
Standard_Integer i;
-
- if (!(myStream >> i)) Storage_StreamTypeMismatchError::Raise();
-
+ GetInteger (i);
FlushEndOfLine();
-
return i;
}
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);
}
Storage_Error FSD_File::BeginWriteRefSection()
{
- myStream << "BEGIN_REF_SECTION\n";
- if (myStream.bad()) Storage_StreamWriteError::Raise();
+ WriteLine ("BEGIN_REF_SECTION");
return Storage_VSOk;
}
void FSD_File::SetRefSectionSize(const Standard_Integer aSize)
{
- myStream << aSize << "\n";
- if (myStream.bad()) Storage_StreamWriteError::Raise();
+ WriteLine (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);
}
//=======================================================================
Storage_Error FSD_File::EndWriteRefSection()
{
- myStream << "END_REF_SECTION\n";
- if (myStream.bad()) Storage_StreamWriteError::Raise();
+ WriteLine ("END_REF_SECTION");
return Storage_VSOk;
}
Standard_Integer FSD_File::RefSectionSize()
{
Standard_Integer i;
-
- if (!(myStream >> i)) Storage_StreamTypeMismatchError::Raise();
+ GetInteger (i);
FlushEndOfLine();
-
return i;
}
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();
}
Storage_Error FSD_File::BeginWriteDataSection()
{
- myStream << "BEGIN_DATA_SECTION";
- if (myStream.bad()) Storage_StreamWriteError::Raise();
+ WriteLine ("BEGIN_DATA_SECTION", Standard_False);
return Storage_VSOk;
}
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);
}
//=======================================================================
void FSD_File::BeginWritePersistentObjectData()
{
- myStream << "( ";
- if (myStream.bad()) Storage_StreamWriteError::Raise();
+ WriteLine ("( ", Standard_False);
}
//=======================================================================
void FSD_File::BeginWriteObjectData()
{
- myStream << "( ";
- if (myStream.bad()) Storage_StreamWriteError::Raise();
+ WriteLine ("( ", Standard_False);
}
//=======================================================================
void FSD_File::EndWriteObjectData()
{
- myStream << ") ";
- if (myStream.bad()) Storage_StreamWriteError::Raise();
+ WriteLine (") ", Standard_False);
}
//=======================================================================
void FSD_File::EndWritePersistentObjectData()
{
- myStream << ")";
- if (myStream.bad()) Storage_StreamWriteError::Raise();
+ WriteLine (")", Standard_False);
}
//=======================================================================
Storage_Error FSD_File::EndWriteDataSection()
{
- myStream << "\nEND_DATA_SECTION\n";
- if (myStream.bad()) Storage_StreamWriteError::Raise();
+ WriteLine ("\nEND_DATA_SECTION");
return Storage_VSOk;
}
{
char c;
- myStream.get(c);
+ Device()->Read( &c, sizeof(char) );
while (c != '#') {
if (IsEnd() || (c != ' ') || (c == '\n')) {
Storage_StreamFormatError::Raise();
}
- myStream.get(c);
+ Device()->Read( &c, sizeof(char) );
}
- if (!(myStream >> aRef)) Storage_StreamTypeMismatchError::Raise();
+ GetInteger (aRef);
- myStream.get(c);
+ Device()->Read( &c, sizeof(char) );
while (c != '=') {
if (IsEnd() || (c != ' ') || (c == '\n')) {
Storage_StreamFormatError::Raise();
}
- myStream.get(c);
+ Device()->Read( &c, sizeof(char) );
}
- myStream.get(c);
+ Device()->Read( &c, sizeof(char) );
while (c != '%') {
if (IsEnd() || (c != ' ') || (c == '\n')) {
Storage_StreamFormatError::Raise();
}
- myStream.get(c);
+ Device()->Read( &c, sizeof(char) );
}
- if (!(myStream >> aType)) Storage_StreamTypeMismatchError::Raise();
-// cout << "REF:" << aRef << " TYPE:"<< aType << endl;
+ GetInteger (aType);
}
//=======================================================================
void FSD_File::BeginReadPersistentObjectData()
{
char c;
- myStream.get(c);
+ Device()->Read( &c, sizeof(char) );
while (c != '(') {
if (IsEnd() || (c != ' ') || (c == '\n')) {
Storage_StreamFormatError::Raise();
}
- myStream.get(c);
+ Device()->Read( &c, sizeof(char) );
}
-
-//cout << "BeginReadPersistentObjectData" << endl;
}
//=======================================================================
{
char c;
- myStream.get(c);
+ Device()->Read( &c, sizeof(char) );
while (c != '(') {
if (IsEnd() || (c != ' ') || (c == '\n')) {
Storage_StreamFormatError::Raise();
}
- myStream.get(c);
+ Device()->Read( &c, sizeof(char) );
}
-
-// cout << "BeginReadObjectData" << endl;
}
//=======================================================================
{
char c;
- myStream.get(c);
+ Device()->Read( &c, sizeof(char) );
while (c != ')') {
if (IsEnd() || (c != ' ') || (c == '\n')) {
Storage_StreamFormatError::Raise();
}
- myStream.get(c);
+ Device()->Read( &c, sizeof(char) );
}
-
-// cout << "EndReadObjectData" << endl;
}
//=======================================================================
char c;
- myStream.get(c);
+ Device()->Read( &c, sizeof(char) );
while (c != ')') {
if (IsEnd() || (c != ' ') || (c == '\n')) {
Storage_StreamFormatError::Raise();
}
- myStream.get(c);
+ Device()->Read( &c, sizeof(char) );
}
- myStream.get(c);
+ Device()->Read( &c, sizeof(char) );
while (c != '\n') {
if (IsEnd() || (c != ' ')) {
Storage_StreamFormatError::Raise();
}
- myStream.get(c);
+ Device()->Read( &c, sizeof(char) );
}
-// cout << "EndReadPersistentObjectData" << endl;
}
//=======================================================================
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();
}
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
{
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
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;
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;
}
}
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;
}
//=======================================================================
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;
}
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);
+ }
}
//=======================================================================
#ifndef LDOM_XmlWriter_HeaderFile
#define LDOM_XmlWriter_HeaderFile
+#include <Storage_IODevice.hxx>
+
#include <Standard_TypeDef.hxx>
#include <stdio.h>
{
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
Standard_Integer myCurIndent;
char * myABuffer; // for WriteAttribute()
Standard_Integer myABufferLen; // for WriteAttribute()
+ Handle(Storage_IODevice) myDevice;
};
#endif
CDM,TColStd,TCollection,Storage
-
is
enumeration ReaderStatus 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;
-- 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;
//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;
}
#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);
+ Handle(Storage_IStream) aStream = Handle(Storage_IStream)::DownCast(anInput);
+ if ( !aFile.IsNull() )
+ {
+ TCollection_AsciiString aPath( aFile->Path() );
+ aRes = LDOMParser::parse( aPath.ToCString() );
+ }
+ else if ( !aStream.IsNull() && aStream->Stream() )
+ {
+ aStream->Open(Storage_VSRead);
+ aRes = LDOMParser::parse( *aStream->Stream() );
+ aStream->Close();
+ }
+ return aRes;
+}
+
//=======================================================================
//function : SetStartElementName
//purpose : set the name of the element which would stop parsing when detected
#include <LDOMParser.hxx>
+#include <Storage_IODevice.hxx>
+
// Block of comments describing class PCDM_DOMHeaderParser
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
SequenceOfExtendedString from TColStd,
BaseDriver from Storage,
OpenMode from Storage,
+ IODevice from Storage,
SequenceOfReference from PCDM
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;
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.
--
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;
#define FILE_FORMAT "FILE_FORMAT: "
-static TCollection_ExtendedString TryXmlDriverType
- (const TCollection_AsciiString& theFileName);
+static TCollection_ExtendedString TryXmlDriverType(const Handle(Storage_IODevice)& theDevice);
//=======================================================================
//function : Open
//=======================================================================
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";
//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;
//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();
catch (Standard_Failure) {}
- if(theFileIsOpen)theFileDriver->Close();
+ if(aDeviceIsOpen)theFileDriver->Close();
delete theFileDriver;
//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;
// 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)))
ExtendedString from TCollection,
AsciiString from TCollection,
Data from Storage,
+ IODevice from Storage,
Document from CDM,
MessageDriver from CDM,
SequenceOfExtendedString from TColStd,
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;
#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>
#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"
//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());
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);
//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 ;
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;
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) {}
//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(" ");
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));
}
}
//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);
}
//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,
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();
//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 ;
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);
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());
}
-
}
}
}
Document from CDM,
ExtendedString from TCollection,
Application from CDM,
- ReaderStatus from PCDM
+ ReaderStatus from PCDM,
+ IODevice from Storage
raises DriverError from PCDM
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
-- 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;
#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 {
#include <PCDM_ReferenceIterator.ixx>
#include <Storage_Data.hxx>
+#include <Storage_IODevice.hxx>
#include <UTL.hxx>
#include <CDM_Document.hxx>
#include <CDM_Application.hxx>
myReferences.Clear();
// mod. by szy
- PCDM_RetrievalDriver::References(theMetaData->FileName(), myReferences,
- myMessageDriver);
+ PCDM_RetrievalDriver::References(theMetaData->Device(), myReferences, myMessageDriver);
myIterator=1;
}
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
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
-- 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,
AsciiString from TCollection,
SequenceOfReference from PCDM,
Schema from Storage,
+ IODevice from Storage,
MessageDriver from CDM,
Application from CDM
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
---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);
#include <Storage_HeaderData.hxx>
#include <Storage_Schema.hxx>
#include <Storage_Root.hxx>
+#include <Storage_IODevice.hxx>
#include <TCollection_AsciiString.hxx>
#include <TColStd_SequenceOfAsciiString.hxx>
#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);
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 <<",";
//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)
{
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;
}
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;
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) {
+ return PCDM_ReadWriter::Reader(aDevice)->ReadDocumentVersion(aDevice, theMsgDriver);
+}
-Standard_Integer PCDM_RetrievalDriver::DocumentVersion(const TCollection_ExtendedString& aFileName, const Handle(CDM_MessageDriver)& theMsgDriver) {
+Standard_Integer PCDM_RetrievalDriver::ReferenceCounter(const Handle(Storage_IODevice)& aDevice, const Handle(CDM_MessageDriver)& theMsgDriver) {
- return PCDM_ReadWriter::Reader(aFileName)->ReadDocumentVersion(aFileName, theMsgDriver);
+ return PCDM_ReadWriter::Reader(aDevice)->ReadReferenceCounter(aDevice, theMsgDriver);
}
-Standard_Integer PCDM_RetrievalDriver::ReferenceCounter(const TCollection_ExtendedString& aFileName, const Handle(CDM_MessageDriver)& theMsgDriver) {
- return PCDM_ReadWriter::Reader(aFileName)->ReadReferenceCounter(aFileName, 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
Data from Storage,
ExtendedString from TCollection,
Schema from Storage,
+ IODevice from Storage,
SequenceOfExtendedString from TColStd,
SequenceOfDocument from PCDM,
StoreStatus from PCDM
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.
-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());
aDocument->Extensions(theExtensions);
LoadExtensions(theSchema,theExtensions);
-
Handle(Storage_Data) theData = new Storage_Data;
static Standard_Boolean Failure;
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);
}
FSD_CmpFile theFile;
- PCDM_ReadWriter::Open(theFile,aFileName,Storage_VSWrite);
+ PCDM_ReadWriter::Open(theFile,aDevice,Storage_VSWrite);
theSchema->Write(theFile,theData);
theFile.Close();
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;
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: {
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;
*
* * * * * * */
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;
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
enumeration HandlerStatus is HandlerVoid, HandlerJumped, HandlerProcessed;
imported IStream;
+ imported IStreamPtr;
imported OStream;
+ imported OStreamPtr;
imported SStream;
+ imported FStream;
+
imported UUID;
imported JmpBuf;
imported ThreadId;
--- /dev/null
+// 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
--- /dev/null
+// Copyright (c) 1998-1999 Matra Datavision
+// Copyright (c) 1999-2014 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef Standard_IStreamPtr_HeaderFile
+#define Standard_IStreamPtr_HeaderFile
+
+#include <Standard_TypeDef.hxx>
+#include <Standard_Stream.hxx>
+
+typedef std::istream* Standard_IStreamPtr;
+
+#endif
+
+
--- /dev/null
+// Copyright (c) 1998-1999 Matra Datavision
+// Copyright (c) 1999-2014 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef Standard_OStreamPtr_HeaderFile
+#define Standard_OStreamPtr_HeaderFile
+
+#include <Standard_TypeDef.hxx>
+#include <Standard_Stream.hxx>
+
+typedef std::ostream* Standard_OStreamPtr;
+
+#endif
+
+
-- - Storage_VSInternalError : an internal error has been detected
-- - Storage_VSExtCharParityError : an error
-- has occurred while reading 16 bit characte
-
+
+ enumeration SeekMode
+ is
+ SMBegin,
+ SMCur,
+ SMEnd
+ end;
+
enumeration OpenMode
is
VSNone,
VSRead,
VSWrite,
+ VSAppend,
VSReadWrite
end;
---Purpose:
deferred class BaseDriver;
+ deferred class IODevice;
+ class File;
+ class OStream;
+ class IStream;
+
deferred class CallBack;
class DefaultCallBack;
AsciiString from TCollection,
OpenMode from Storage,
Error from Storage,
+ IODevice from Storage,
ExtendedString from TCollection,
SequenceOfAsciiString from TColStd,
SequenceOfExtendedString from TColStd
Initialize;
- Open(me : in out; aName : AsciiString from TCollection; aMode : OpenMode from Storage) returns Error from Storage is deferred;
+ Open(me : in out; aDevice : IODevice from Storage; aMode : OpenMode from Storage)
+ returns Error from Storage is deferred;
- Name(me) returns AsciiString from TCollection;
+ Device(me) returns IODevice from Storage;
---C++: inline
OpenMode(me) returns OpenMode from Storage;
Tell( me : in out ) returns Position from Storage is deferred;
---Purpose: return position in the file. Return -1 upon error.
-
-- INFO SECTION
-- write
--
-- PROTECTED
- SetName(me : in out; aName : AsciiString from TCollection) is protected;
- ---C++: inline
-
- SetOpenMode(me : in out; aMode : OpenMode from Storage) is protected;
+ SetDevice(me : in out; aDevice : IODevice from Storage) is protected;
---C++: inline
- fields
+-- SetOpenMode(me : in out; aMode : OpenMode from Storage) is protected;
+-- ---C++: inline
- myOpenMode : OpenMode from Storage;
- myName : AsciiString from TCollection;
+fields
+
+-- myOpenMode : OpenMode from Storage;
+ myDevice : IODevice from Storage;
end;
#include <Storage_BaseDriver.ixx>
-Storage_BaseDriver::Storage_BaseDriver() : myOpenMode(Storage_VSNone)
+Storage_BaseDriver::Storage_BaseDriver()
{
}
-void Storage_BaseDriver::Delete()
-{}
+void Storage_BaseDriver::Delete()
+{
+}
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-inline TCollection_AsciiString Storage_BaseDriver::Name() const
-{
- return myName;
-}
+#include <Storage_IODevice.hxx>
-inline Storage_OpenMode Storage_BaseDriver::OpenMode() const
+inline Handle(Storage_IODevice) Storage_BaseDriver::Device() const
{
- return myOpenMode;
+ return myDevice;
}
-inline void Storage_BaseDriver::SetName(const TCollection_AsciiString& aName)
+inline Storage_OpenMode Storage_BaseDriver::OpenMode() const
{
- myName = aName;
+ Storage_OpenMode aMode = Storage_VSNone;
+ if ( !Device().IsNull() )
+ aMode = Device()->OpenMode();
+ return aMode;
}
-inline void Storage_BaseDriver::SetOpenMode(const Storage_OpenMode aMode)
+inline void Storage_BaseDriver::SetDevice( const Handle(Storage_IODevice)& theDevice )
{
- myOpenMode = aMode;
+ myDevice = theDevice;
}
-
--- /dev/null
+-- Created on: 2015-05-20
+-- Created by:
+-- Copyright (c) 2015 OPEN CASCADE SAS
+--
+-- This file is part of Open CASCADE Technology software library.
+--
+-- This library is free software; you can redistribute it and/or modify it under
+-- the terms of the GNU Lesser General Public License version 2.1 as published
+-- by the Free Software Foundation, with special exception defined in the file
+-- OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+-- distribution for complete text of the license and disclaimer of any warranty.
+--
+-- Alternatively, this file may be used under the terms of Open CASCADE
+-- commercial license or contractual agreement.
+
+class File from Storage inherits IODevice from Storage
+ ---Purpose: Store/Retrieve a data to/from a file
+
+uses Position from Storage,
+ AsciiString from TCollection,
+ OpenMode from Storage,
+ SeekMode from Storage,
+ Error from Storage,
+ FStream from Standard,
+ ExtendedString from TCollection
+
+raises StreamTypeMismatchError from Storage,
+ StreamFormatError from Storage,
+ StreamWriteError from Storage,
+ StreamExtCharParityError from Storage
+
+is
+ Create (theFilePath: ExtendedString from TCollection) returns File from Storage;
+
+ Delete (me: mutable) is redefined;
+
+ Path (me) returns ExtendedString from TCollection;
+
+ Name (me) returns ExtendedString from TCollection is redefined;
+
+ Open (me: mutable; theMode: OpenMode from Storage ) returns Error from Storage;
+
+ IsEnd (me) returns Boolean from Standard;
+ ---Purpose: returns True if the end of the device data has been reached.
+
+ Tell (me: mutable) returns Position from Storage is redefined;
+ ---Purpose: returns a position in the device. Return -1 upon error.
+
+ Seek( me: mutable; aPos : Position from Storage; aMode: SeekMode from Storage = Storage_SMBegin )
+ returns Boolean from Standard is redefined;
+
+ Close (me: mutable) returns Boolean from Standard;
+
+ CanRead (me) returns Boolean from Standard;
+
+ CanWrite (me) returns Boolean from Standard;
+
+ Read (me: mutable; theBuffer: Address from Standard; theSize: Size from Standard)
+ returns Size from Standard;
+
+ Write (me: mutable; theBuffer: Address from Standard; theSize: Size from Standard)
+ returns Size from Standard;
+
+ Signature (me) returns AsciiString from TCollection;
+
+ Print (me; theOStream: in out OStream from Standard)
+ returns OStream from Standard is redefined;
+ ---C++: return &
+
+fields
+
+ myStream : FStream from Standard;
+ myFilePath : ExtendedString from TCollection;
+
+end;
--- /dev/null
+// File: Storage_File.cxx
+// Created: 20.05.15
+// Author:
+// Copyright: Open CASCADE 2015
+
+#include <Storage_File.ixx>
+
+#include <TDocStd_PathParser.hxx>
+
+#include <TCollection_AsciiString.hxx>
+
+//=======================================================================
+//function : Storage_File
+//purpose : Constructor
+//=======================================================================
+Storage_File::Storage_File( const TCollection_ExtendedString& theFilePath )
+ : Storage_IODevice(),
+ myFilePath( theFilePath )
+{
+}
+
+//=======================================================================
+//function : Delete
+//purpose :
+//=======================================================================
+void Storage_File::Delete()
+{
+}
+
+//=======================================================================
+//function : Path
+//purpose :
+//=======================================================================
+TCollection_ExtendedString Storage_File::Path() const
+{
+ return myFilePath;
+}
+
+//=======================================================================
+//function : Name
+//purpose :
+//=======================================================================
+TCollection_ExtendedString Storage_File::Name() const
+{
+ Standard_Integer aPos = -1;
+ TCollection_ExtendedString name;
+ TCollection_ExtendedString temp = myFilePath;
+#ifdef WNT
+ aPos = temp.SearchFromEnd( TCollection_ExtendedString( "\\" ) );
+ if ( !( aPos > 0 ) )
+#endif
+ aPos = temp.SearchFromEnd( TCollection_ExtendedString( "/" ) );
+ if ( aPos >0 )
+ name = temp.Split( aPos );
+ else
+ name = temp;
+
+ return name;
+}
+
+//=======================================================================
+//function : Open
+//purpose :
+//=======================================================================
+Storage_Error Storage_File::Open (const Storage_OpenMode theMode)
+{
+ Storage_Error anOpenResult = Storage_VSOk;
+
+ #ifdef _WIN32
+ // file name is treated as UTF-8 string and converted to UTF-16 one
+ const TCollection_ExtendedString aPath( Path() );
+ const wchar_t* aFilePath = (const wchar_t*)aPath.ToExtString();
+ #else
+ const TCollection_AsciiString aPath( Path() );
+ const Standard_CString aFilePath = aPath.ToCString();
+ #endif
+
+ if (OpenMode() == Storage_VSNone)
+ {
+ if (theMode == Storage_VSRead)
+ {
+ myStream.open( aFilePath, ios::in | ios::binary );
+ }
+ else if (theMode == Storage_VSWrite)
+ {
+ myStream.open( aFilePath, ios::out | ios::binary );
+ }
+ else if (theMode == Storage_VSAppend)
+ {
+ myStream.open( aFilePath, ios::in | ios::out | ios::binary | ios::ate );
+ }
+ else if (theMode == Storage_VSReadWrite)
+ {
+ myStream.open( aFilePath, ios::in | ios::out | ios::binary );
+ }
+
+ if (!myStream.rdbuf()->is_open()) {
+ anOpenResult = Storage_VSOpenError;
+ }
+ else
+ {
+ SetOpenMode (theMode);
+ }
+ }
+ else
+ {
+ anOpenResult = Storage_VSAlreadyOpen;
+ }
+
+ return anOpenResult;
+}
+
+//=======================================================================
+//function : IsEnd
+//purpose :
+//=======================================================================
+Standard_Boolean Storage_File::IsEnd() const
+{
+ return myStream.eof();
+}
+
+//=======================================================================
+//function : Tell
+//purpose :
+//=======================================================================
+Storage_Position Storage_File::Tell()
+{
+ return Storage_Position( OpenMode() == Storage_VSRead ? myStream.tellg() : myStream.tellp() );
+}
+
+//=======================================================================
+//function : Seek
+//purpose :
+//=======================================================================
+Standard_Boolean Storage_File::Seek (const Storage_Position& thePos, const Storage_SeekMode aMode)
+{
+ ios::seekdir dir = ios::beg;
+ switch ( aMode )
+ {
+ case Storage_SMEnd:
+ dir = ios::end;
+ break;
+ case Storage_SMCur:
+ dir = ios::cur;
+ break;
+ case Storage_SMBegin:
+ default:
+ dir = ios::beg;
+ break;
+ }
+
+ if ( OpenMode() == Storage_VSRead )
+ myStream.seekg( thePos, dir );
+ else
+ myStream.seekp( thePos, dir );
+
+ return !myStream.fail();
+}
+
+//=======================================================================
+//function : Close
+//purpose :
+//=======================================================================
+Standard_Boolean Storage_File::Close()
+{
+ myStream.close();
+
+ SetOpenMode( Storage_VSNone );
+
+ return Standard_True;
+}
+
+//=======================================================================
+//function : CanRead
+//purpose :
+//=======================================================================
+Standard_Boolean Storage_File::CanRead() const
+{
+ return myStream.good() && ( OpenMode() == Storage_VSRead || OpenMode() == Storage_VSReadWrite );
+}
+
+//=======================================================================
+//function : CanWrite
+//purpose :
+//=======================================================================
+Standard_Boolean Storage_File::CanWrite() const
+{
+ return myStream.good() && ( OpenMode() == Storage_VSWrite || OpenMode() == Storage_VSAppend || OpenMode() == Storage_VSReadWrite );
+}
+
+//=======================================================================
+//function : Read
+//purpose :
+//=======================================================================
+Standard_Size Storage_File::Read( const Standard_Address theBuffer, const Standard_Size theSize )
+{
+ myStream.read((char*)theBuffer, theSize);
+
+ return (Standard_Size)myStream.gcount();
+}
+
+//=======================================================================
+//function : Write
+//purpose :
+//=======================================================================
+Standard_Size Storage_File::Write (const Standard_Address theBuffer, const Standard_Size theSize)
+{
+ Storage_Position aPosBefore = Tell();
+
+ myStream.write ((char*)theBuffer, theSize);
+
+ Storage_Position aPosAfter = Tell();
+
+ return aPosAfter - aPosBefore;
+}
+
+//=======================================================================
+//function : Signature
+//purpose :
+//=======================================================================
+TCollection_AsciiString Storage_File::Signature() const
+{
+ return myFilePath;
+}
+
+//=======================================================================
+//function : Print
+//purpose :
+//=======================================================================
+Standard_OStream& Storage_File::Print (Standard_OStream& theOStream) const
+{
+ return theOStream;
+}
--- /dev/null
+-- Created on: 2015-05-18
+-- Created by: Sergey TELKOV
+-- Copyright (c) 2015 OPEN CASCADE SAS
+--
+-- This file is part of Open CASCADE Technology software library.
+--
+-- This library is free software; you can redistribute it and/or modify it under
+-- the terms of the GNU Lesser General Public License version 2.1 as published
+-- by the Free Software Foundation, with special exception defined in the file
+-- OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+-- distribution for complete text of the license and disclaimer of any warranty.
+--
+-- Alternatively, this file may be used under the terms of Open CASCADE
+-- commercial license or contractual agreement.
+
+deferred class IODevice from Storage inherits TShared from MMgt
+ ---Purpose: Root any input output devices. A device define a way
+ -- to store or retrieve a data, for instance a file.
+
+uses Position from Storage,
+ AsciiString from TCollection,
+ OpenMode from Storage,
+ Error from Storage,
+ SeekMode from Storage,
+ ExtendedString from TCollection,
+ SequenceOfAsciiString from TColStd,
+ SequenceOfExtendedString from TColStd
+
+raises StreamTypeMismatchError from Storage,
+ StreamFormatError from Storage,
+ StreamWriteError from Storage,
+ StreamExtCharParityError from Storage
+
+is
+ Initialize;
+
+ Delete( me : mutable ) is redefined;
+
+ Name( me ) returns ExtendedString from TCollection is deferred;
+
+ Open( me : mutable; aMode: OpenMode from Storage ) returns Error from Storage is deferred;
+
+ OpenMode( me ) returns OpenMode from Storage;
+ ---C++: inline
+
+ IsEnd( me ) returns Boolean from Standard is deferred;
+ ---Purpose: returns True if we are at end of the device data.
+
+ Tell( me : mutable ) returns Position from Storage is deferred;
+ ---Purpose: return position in the device. Return -1 upon error.
+
+ Seek( me: mutable; aPos : Position from Storage; aMode: SeekMode from Storage = Storage_SMBegin )
+ returns Boolean from Standard is deferred;
+ ---Purpose: Set new absolute position within the stream
+
+ Close(me : mutable) returns Boolean from Standard is deferred;
+
+ CanRead(me) returns Boolean from Standard is deferred;
+
+ CanWrite(me) returns Boolean from Standard is deferred;
+
+ Read(me: mutable; aBuffer : Address from Standard;
+ aSize : Size from Standard)
+ returns Size from Standard is deferred;
+
+ Write(me: mutable; aBuffer : Address from Standard;
+ aSize : Size from Standard)
+ returns Size from Standard is deferred;
+
+ Signature(me) returns AsciiString from TCollection is deferred;
+
+ Print(me; anOStream: in out OStream from Standard)
+ returns OStream from Standard is virtual;
+ ---C++: return &
+ ---C++: alias operator <<
+
+ -- SERVICE
+
+ ReadLine(me: mutable; aBuffer : in out CString from Standard;
+ aSize : Integer from Standard;
+ anEndSymbol: Character from Standard);
+
+ ReadLine(me: mutable; anEndSymbol: Character from Standard ) returns AsciiString from TCollection;
+
+
+ WriteLine(me: mutable; aLine : CString from Standard);
+
+ WriteLine(me: mutable; aLine : CString from Standard; anEndSymbol: Character from Standard);
+
+ WriteLine(me: mutable; aLine : AsciiString from TCollection);
+
+ WriteLine(me: mutable; aLine : AsciiString from TCollection; anEndSymbol: Character from Standard);
+
+ -- PROTECTED
+
+ SetOpenMode(me : mutable; aMode : OpenMode from Storage) is protected;
+ ---C++: inline
+
+fields
+
+ myOpenMode : OpenMode from Storage;
+
+end;
--- /dev/null
+// File: Storage_IODevice.cxx
+// Created: 18.05.15 12:41:53
+// Author: stv@NETEX
+// Copyright: Open CASCADE 2015
+
+#include <Storage_IODevice.ixx>
+
+//=======================================================================
+//function : Storage_IODevice
+//purpose : Constructor
+//=======================================================================
+
+Storage_IODevice::Storage_IODevice()
+: myOpenMode(Storage_VSNone)
+{
+}
+
+void Storage_IODevice::Delete()
+{
+}
+
+void Storage_IODevice::SetOpenMode( const Storage_OpenMode aMode )
+{
+ myOpenMode = aMode;
+}
+
+Standard_OStream& Storage_IODevice::Print( Standard_OStream& anOStream ) const
+{
+ return anOStream;
+}
+
+void Storage_IODevice::ReadLine( Standard_CString& aBuffer, const Standard_Integer aSize, const Standard_Character anEndSymbol )
+{
+ Standard_Integer i = 0;
+ Standard_Boolean aFin = Standard_False;
+ Standard_Character* aBuf = (Standard_Character*)aBuffer;
+ while ( CanRead() && !IsEnd() && i < aSize && !aFin )
+ {
+ Standard_Character c;
+ Read( &c, sizeof( Standard_Character ) );
+ aFin = ( c == anEndSymbol );
+ if ( aFin )
+ aBuf[i++] = '\0';
+ else
+ aBuf[i++] = c;
+ }
+}
+
+TCollection_AsciiString Storage_IODevice::ReadLine( const Standard_Character anEndSymbol )
+{
+ TCollection_AsciiString aLine;
+ Standard_Boolean aFin = Standard_False;
+ while ( CanRead() && !IsEnd() && !aFin )
+ {
+ Standard_Character c;
+ Read( &c, sizeof( Standard_Character ) );
+ aFin = ( c == anEndSymbol );
+ if ( !aFin )
+ aLine += c;
+ }
+ return aLine;
+}
+
+void Storage_IODevice::WriteLine( const Standard_CString aLine )
+{
+ WriteLine( aLine, '\n' );
+}
+
+void Storage_IODevice::WriteLine( const TCollection_AsciiString& aLine )
+{
+ WriteLine( aLine, '\n' );
+}
+
+void Storage_IODevice::WriteLine( const Standard_CString aLine, const Standard_Character anEndSymbol )
+{
+ if ( !CanWrite() )
+ return;
+
+ Write( (Standard_Address)aLine, strlen( aLine ) );
+ Write( (Standard_Address)&anEndSymbol, sizeof( Standard_Character ) );
+}
+
+void Storage_IODevice::WriteLine( const TCollection_AsciiString& aLine, const Standard_Character anEndSymbol )
+{
+ if ( !CanWrite() )
+ return;
+
+ Write( (Standard_Address)aLine.ToCString(), aLine.Length() );
+ Write( (Standard_Address)&anEndSymbol, sizeof( Standard_Character ) );
+}
--- /dev/null
+// File: Storage_IODevice.lxx
+// Created: 18.05.15 12:45:50
+// Author: stv@NETEX
+// Copyright: Open CASCADE 2015
+
+inline Storage_OpenMode Storage_IODevice::OpenMode() const
+{
+ return myOpenMode;
+}
--- /dev/null
+-- Created on: 2015-05-20
+-- Created by:
+-- Copyright (c) 2015 OPEN CASCADE SAS
+--
+-- This file is part of Open CASCADE Technology software library.
+--
+-- This library is free software; you can redistribute it and/or modify it under
+-- the terms of the GNU Lesser General Public License version 2.1 as published
+-- by the Free Software Foundation, with special exception defined in the file
+-- OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+-- distribution for complete text of the license and disclaimer of any warranty.
+--
+-- Alternatively, this file may be used under the terms of Open CASCADE
+-- commercial license or contractual agreement.
+
+class IStream from Storage inherits IODevice from Storage
+ ---Purpose:
+
+uses Position from Storage,
+ AsciiString from TCollection,
+ OpenMode from Storage,
+ SeekMode from Storage,
+ Error from Storage,
+ IStream from Standard,
+ IStreamPtr from Standard,
+ ExtendedString from TCollection
+
+raises StreamTypeMismatchError from Storage,
+ StreamFormatError from Storage,
+ StreamWriteError from Storage,
+ StreamExtCharParityError from Storage
+
+is
+ Create (theStream: in out IStream from Standard) returns IStream from Storage;
+
+ Delete (me: mutable) is redefined;
+
+ Stream(me) returns IStreamPtr from Standard;
+
+ Name (me) returns ExtendedString from TCollection is redefined;
+
+ Open (me: mutable; theMode: OpenMode from Storage = Storage_VSWrite) returns Error from Storage;
+
+ IsEnd (me) returns Boolean from Standard;
+ ---Purpose: returns True if the end of the device data has been reached.
+
+ Tell (me: mutable) returns Position from Storage is redefined;
+ ---Purpose: returns a position in the device. Return -1 upon error.
+
+ Seek( me: mutable; aPos : Position from Storage; aMode: SeekMode from Storage = Storage_SMBegin )
+ returns Boolean from Standard is redefined;
+
+ Close (me: mutable) returns Boolean from Standard;
+
+ CanRead (me) returns Boolean from Standard;
+
+ CanWrite (me) returns Boolean from Standard;
+
+ Read (me: mutable; theBuffer: Address from Standard; theSize: Size from Standard)
+ returns Size from Standard;
+
+ Write (me: mutable; theBuffer: Address from Standard; theSize: Size from Standard)
+ returns Size from Standard;
+
+ Signature (me) returns AsciiString from TCollection;
+
+ Print (me; theOStream: in out OStream from Standard)
+ returns OStream from Standard is redefined;
+ ---C++: return &
+
+fields
+ myStream: IStreamPtr from Standard;
+end;
--- /dev/null
+// File: Storage_OStream.cxx
+// Created: 20.05.15
+// Author:
+// Copyright: Open CASCADE 2015
+
+#include <Storage_IStream.ixx>
+
+#include <TCollection_AsciiString.hxx>
+#include <TCollection_ExtendedString.hxx>
+
+//=======================================================================
+//function : Storage_IStream
+//purpose : Constructor
+//=======================================================================
+Storage_IStream::Storage_IStream (Standard_IStream& theStream)
+ : Storage_IODevice(),
+ myStream (&theStream)
+{
+}
+
+//=======================================================================
+//function : Delete
+//purpose :
+//=======================================================================
+void Storage_IStream::Delete()
+{
+}
+
+//=======================================================================
+//function : Path
+//purpose :
+//=======================================================================
+Standard_IStreamPtr Storage_IStream::Stream() const
+{
+ return myStream;
+}
+
+//=======================================================================
+//function : Name
+//purpose :
+//=======================================================================
+TCollection_ExtendedString Storage_IStream::Name() const
+{
+ return "";
+}
+
+//=======================================================================
+//function : Open
+//purpose :
+//=======================================================================
+Storage_Error Storage_IStream::Open (const Storage_OpenMode theMode)
+{
+ if (theMode != Storage_VSRead)
+ {
+ return Storage_VSOpenError;
+ }
+
+ Storage_Error anOpenResult = Storage_VSOk;
+
+ if (OpenMode() == Storage_VSNone)
+ {
+ if (!myStream->good()) // not good for eof
+ {
+ anOpenResult = Storage_VSOpenError;
+ }
+ else
+ {
+ SetOpenMode (theMode);
+
+ // clear flags and set the position where the next character is to be inserted
+ myStream->clear();
+ Seek(0);
+ }
+ }
+ else
+ {
+ anOpenResult = Storage_VSAlreadyOpen;
+ }
+
+ return anOpenResult;
+}
+
+//=======================================================================
+//function : IsEnd
+//purpose :
+//=======================================================================
+Standard_Boolean Storage_IStream::IsEnd() const
+{
+ return myStream->eof();
+}
+
+//=======================================================================
+//function : Tell
+//purpose :
+//=======================================================================
+Storage_Position Storage_IStream::Tell()
+{
+ return Storage_Position (myStream->tellg());
+}
+
+//=======================================================================
+//function : Seek
+//purpose :
+//=======================================================================
+Standard_Boolean Storage_IStream::Seek (const Storage_Position& thePos, const Storage_SeekMode aMode )
+{
+ switch ( aMode )
+ {
+ case Storage_SMEnd:
+ myStream->seekg(thePos, ios::end);
+ break;
+ case Storage_SMCur:
+ myStream->seekg(thePos, ios::cur);
+ break;
+ case Storage_SMBegin:
+ default:
+ myStream->seekg(thePos, ios::beg);
+ break;
+ }
+
+ return !myStream->fail();
+}
+
+//=======================================================================
+//function : Close
+//purpose :
+//=======================================================================
+Standard_Boolean Storage_IStream::Close()
+{
+ SetOpenMode( Storage_VSNone );
+ myStream->clear();
+ Seek(0);
+
+ return Standard_True;
+}
+
+//=======================================================================
+//function : CanRead
+//purpose :
+//=======================================================================
+Standard_Boolean Storage_IStream::CanRead() const
+{
+ return myStream->good();
+}
+
+//=======================================================================
+//function : CanWrite
+//purpose :
+//=======================================================================
+Standard_Boolean Storage_IStream::CanWrite() const
+{
+ return Standard_False;
+}
+
+//=======================================================================
+//function : Read
+//purpose :
+//=======================================================================
+Standard_Size Storage_IStream::Read (const Standard_Address theBuffer, const Standard_Size theSize)
+{
+ myStream->read((char*)theBuffer, theSize);
+ return (Standard_Size)myStream->gcount();
+}
+
+//=======================================================================
+//function : Write
+//purpose :
+//=======================================================================
+Standard_Size Storage_IStream::Write (const Standard_Address /*theBuffer*/, const Standard_Size /*theSize*/)
+{
+ return Standard_Size(0);
+}
+
+//=======================================================================
+//function : Signature
+//purpose :
+//=======================================================================
+TCollection_AsciiString Storage_IStream::Signature() const
+{
+ return TCollection_AsciiString( (Standard_Integer)myStream );
+}
+
+//=======================================================================
+//function : Print
+//purpose :
+//=======================================================================
+Standard_OStream& Storage_IStream::Print (Standard_OStream& theOStream) const
+{
+ return theOStream;
+}
--- /dev/null
+-- Created on: 2015-05-20
+-- Created by:
+-- Copyright (c) 2015 OPEN CASCADE SAS
+--
+-- This file is part of Open CASCADE Technology software library.
+--
+-- This library is free software; you can redistribute it and/or modify it under
+-- the terms of the GNU Lesser General Public License version 2.1 as published
+-- by the Free Software Foundation, with special exception defined in the file
+-- OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+-- distribution for complete text of the license and disclaimer of any warranty.
+--
+-- Alternatively, this file may be used under the terms of Open CASCADE
+-- commercial license or contractual agreement.
+
+class OStream from Storage inherits IODevice from Storage
+ ---Purpose:
+
+uses Position from Storage,
+ AsciiString from TCollection,
+ OpenMode from Storage,
+ SeekMode from Storage,
+ Error from Storage,
+ OStream from Standard,
+ OStreamPtr from Standard,
+ ExtendedString from TCollection
+
+raises StreamTypeMismatchError from Storage,
+ StreamFormatError from Storage,
+ StreamWriteError from Storage,
+ StreamExtCharParityError from Storage
+
+is
+ Create (theStream: in out OStream from Standard) returns OStream from Storage;
+
+ Delete (me: mutable) is redefined;
+
+ Stream (me) returns OStreamPtr from Standard;
+
+ Name (me) returns ExtendedString from TCollection is redefined;
+
+ Open (me: mutable; theMode: OpenMode from Storage = Storage_VSWrite) returns Error from Storage;
+
+ IsEnd (me) returns Boolean from Standard;
+ ---Purpose: returns True if the end of the device data has been reached.
+
+ Tell (me: mutable) returns Position from Storage is redefined;
+ ---Purpose: returns a position in the device. Return -1 upon error.
+
+ Seek( me: mutable; aPos : Position from Storage; aMode: SeekMode from Storage = Storage_SMBegin )
+ returns Boolean from Standard is redefined;
+
+ Close (me: mutable) returns Boolean from Standard;
+
+ CanRead (me) returns Boolean from Standard;
+
+ CanWrite (me) returns Boolean from Standard;
+
+ Read (me: mutable; theBuffer: Address from Standard; theSize: Size from Standard)
+ returns Size from Standard;
+
+ Write (me: mutable; theBuffer: Address from Standard; theSize: Size from Standard)
+ returns Size from Standard;
+
+ Signature (me) returns AsciiString from TCollection;
+
+ Print (me; theOStream: in out OStream from Standard)
+ returns OStream from Standard is redefined;
+ ---C++: return &
+
+fields
+ myStream: OStreamPtr from Standard;
+end;
--- /dev/null
+// File: Storage_OStream.cxx
+// Created: 20.05.15
+// Author:
+// Copyright: Open CASCADE 2015
+
+#include <Storage_OStream.ixx>
+
+#include <TCollection_AsciiString.hxx>
+#include <TCollection_ExtendedString.hxx>
+
+//=======================================================================
+//function : Storage_OStream
+//purpose : Constructor
+//=======================================================================
+Storage_OStream::Storage_OStream (Standard_OStream& theStream)
+ : Storage_IODevice(),
+ myStream (&theStream)
+{
+}
+
+//=======================================================================
+//function : Delete
+//purpose :
+//=======================================================================
+void Storage_OStream::Delete()
+{
+}
+
+//=======================================================================
+//function : Stream
+//purpose :
+//=======================================================================
+Standard_OStreamPtr Storage_OStream::Stream() const
+{
+ return myStream;
+}
+
+//=======================================================================
+//function : Name
+//purpose :
+//=======================================================================
+TCollection_ExtendedString Storage_OStream::Name() const
+{
+ return "";
+}
+
+//=======================================================================
+//function : Open
+//purpose :
+//=======================================================================
+Storage_Error Storage_OStream::Open (const Storage_OpenMode theMode)
+{
+ if (theMode != Storage_VSWrite || theMode != Storage_VSAppend)
+ {
+ return Storage_VSOpenError;
+ }
+
+ Storage_Error anOpenResult = Storage_VSOk;
+
+ if (OpenMode() == Storage_VSNone)
+ {
+ if (!myStream->good()) // not good for eof
+ {
+ anOpenResult = Storage_VSOpenError;
+ }
+ else
+ {
+ SetOpenMode (theMode);
+
+ // clear flags and set the position where the next character is to be inserted
+ myStream->clear();
+ if ( theMode == Storage_VSWrite )
+ myStream->seekp(0, ios::beg);
+ else
+ myStream->seekp(0, ios::end);
+ }
+ }
+ else
+ {
+ anOpenResult = Storage_VSAlreadyOpen;
+ }
+
+ return anOpenResult;
+}
+
+//=======================================================================
+//function : IsEnd
+//purpose :
+//=======================================================================
+Standard_Boolean Storage_OStream::IsEnd() const
+{
+ return myStream->eof();
+}
+
+//=======================================================================
+//function : Tell
+//purpose :
+//=======================================================================
+Storage_Position Storage_OStream::Tell()
+{
+ return Storage_Position (myStream->tellp());
+}
+
+//=======================================================================
+//function : Seek
+//purpose :
+//=======================================================================
+Standard_Boolean Storage_OStream::Seek (const Storage_Position& thePos, const Storage_SeekMode aMode )
+{
+ switch ( aMode )
+ {
+ case Storage_SMEnd:
+ myStream->seekp(thePos, ios::end);
+ break;
+ case Storage_SMCur:
+ myStream->seekp(thePos, ios::cur);
+ break;
+ case Storage_SMBegin:
+ default:
+ myStream->seekp(thePos, ios::beg);
+ break;
+ }
+
+ return !myStream->fail();
+}
+
+//=======================================================================
+//function : Close
+//purpose :
+//=======================================================================
+Standard_Boolean Storage_OStream::Close()
+{
+ SetOpenMode( Storage_VSNone );
+
+ return Standard_True;
+}
+
+//=======================================================================
+//function : CanRead
+//purpose :
+//=======================================================================
+Standard_Boolean Storage_OStream::CanRead() const
+{
+ return Standard_False;
+}
+
+//=======================================================================
+//function : CanWrite
+//purpose :
+//=======================================================================
+Standard_Boolean Storage_OStream::CanWrite() const
+{
+ return myStream->good();
+}
+
+//=======================================================================
+//function : Read
+//purpose :
+//=======================================================================
+Standard_Size Storage_OStream::Read( const Standard_Address /*theBuffer*/, const Standard_Size /*theSize*/ )
+{
+ return Standard_Size(0);
+}
+
+//=======================================================================
+//function : Write
+//purpose :
+//=======================================================================
+Standard_Size Storage_OStream::Write (const Standard_Address theBuffer, const Standard_Size theSize)
+{
+ Storage_Position aPosBefore = Tell();
+
+ myStream->write ((char*)theBuffer, theSize);
+
+ Storage_Position aPosAfter = Tell();
+
+ return aPosAfter - aPosBefore;
+}
+
+//=======================================================================
+//function : Signature
+//purpose :
+//=======================================================================
+TCollection_AsciiString Storage_OStream::Signature() const
+{
+ return TCollection_AsciiString( (Standard_Integer)myStream );
+}
+
+//=======================================================================
+//function : Print
+//purpose :
+//=======================================================================
+Standard_OStream& Storage_OStream::Print (Standard_OStream& theOStream) const
+{
+ return theOStream;
+}
TDF,
TColStd,
TCollection,
- Resource
+ Resource,
+ Storage
is
ExtendedString from TCollection,
SequenceOfExtendedString from TColStd,
ReaderStatus from PCDM,
- StoreStatus from PCDM
-
+ StoreStatus from PCDM,
+ IODevice from Storage
+
raises NoSuchObject from Standard
is
returns Integer from Standard;
- Open (me : mutable; path : ExtendedString from TCollection;
- aDoc : out Document from TDocStd)
+ Open (me : mutable; thePath : ExtendedString from TCollection;
+ theDoc : out Document from TDocStd)
---Purpose: Retrieves the document aDoc stored under the
-- name aName in the directory directory.
-- In order not to override a version of aDoc which
-- is already in memory, this method can be made
-- to depend on the value returned by IsInSession.
returns ReaderStatus from PCDM;
+
+ Open (me : mutable; aDevice : in out IODevice from Storage;
+ aDoc : out Document from TDocStd)
+ ---Purpose: Retrieves the document aDoc from the device
+ -- In order not to override a version of aDoc which
+ -- is already in memory, this method can be made
+ -- to depend on the value returned by IsInSession.
+ returns ReaderStatus from PCDM is protected;
+
+ Open (me : mutable; theIStream : in out IStream from Standard;
+ aDoc : out Document from TDocStd)
+ ---Purpose: Retrieves the document aDoc from the stream
+ -- In order not to override a version of aDoc which
+ -- is already in memory, this method can be made
+ -- to depend on the value returned by IsInSession.
+ returns ReaderStatus from PCDM;
- SaveAs (me : mutable; aDoc : Document from TDocStd;
- path : ExtendedString from TCollection)
- ---Purpose: Save the active document in the file <name> in the
- -- path <path> ; o verwrites the file if it already exists.
+ SaveAs (me : mutable; theDoc : Document from TDocStd;
+ thePath: ExtendedString from TCollection)
+ ---Purpose: Save the active document in the
+ -- path <thePath> ; overwrites the file if it already exists.
returns StoreStatus from PCDM;
+
+ SaveAs (me : mutable; theDoc : Document from TDocStd;
+ theDevice: IODevice from Storage)
+ ---Purpose: Save the active document in the device <theDevice>;
+ -- overwrites the file if it already exists.
+ returns StoreStatus from PCDM is protected;
-
+ SaveAs (me : mutable; theDoc : Document from TDocStd;
+ theOStream: in out OStream from Standard)
+ ---Purpose: Save the active document in the stream <theOStream>;
+ returns StoreStatus from PCDM;
+
Save (me : mutable; aDoc : Document from TDocStd)
---Purpose: Save aDoc active document.
-- Exceptions:
returns StoreStatus from PCDM;
SaveAs (me : mutable; aDoc : Document from TDocStd;
- path : ExtendedString from TCollection;
+ aDev : IODevice from Storage;
theStatusMessage: out ExtendedString from TCollection)
---Purpose: Save the active document in the file <name> in the
-- path <path> . overwrite the file if it
#include <Standard_ErrorHandler.hxx>
#include <Standard_NotImplemented.hxx>
#include <Standard_DomainError.hxx>
+#include <Storage_File.hxx>
+#include <Storage_IStream.hxx>
+#include <Storage_OStream.hxx>
#include <Plugin_Failure.hxx>
#include <TDF_Label.hxx>
#include <CDF_Store.hxx>
return 0;
}
+PCDM_ReaderStatus TDocStd_Application::Open(const TCollection_ExtendedString& thePath,
+ Handle(TDocStd_Document)& theDoc)
+{
+ Handle(Storage_File) aDevice = new Storage_File(thePath);
+ return Open (aDevice, theDoc);
+}
+
//=======================================================================
//function : Open
//purpose :
//=======================================================================
-PCDM_ReaderStatus TDocStd_Application::Open(const TCollection_ExtendedString& path,Handle(TDocStd_Document)& aDoc) {
+PCDM_ReaderStatus TDocStd_Application::Open(Handle(Storage_IODevice)& aDevice,
+ Handle(TDocStd_Document)& aDoc)
+{
+/*
PCDM_ReaderStatus status = PCDM_RS_DriverFailure;
TDocStd_PathParser tool (path);
TCollection_ExtendedString directory = tool.Trek();
TCollection_ExtendedString file = tool.Name();
file+=".";
file+=tool.Extension();
- status = CanRetrieve(directory,file);
- if (status != PCDM_RS_OK) return status;
+*/
+ PCDM_ReaderStatus status = CanRetrieve(aDevice);
+ if (status != PCDM_RS_OK)
+ return status;
try {
OCC_CATCH_SIGNALS
Handle(TDocStd_Document) D =
- Handle(TDocStd_Document)::DownCast(Retrieve(directory,file));
+ Handle(TDocStd_Document)::DownCast(Retrieve(aDevice));
CDF_Application::Open(D);
aDoc = D;
}
// status = GetRetrieveStatus();
Handle(Standard_Failure) F = Standard_Failure::Caught();
if (!F.IsNull() && !MessageDriver().IsNull()) {
-// Standard_SStream aMsg;
-// aMsg << Standard_Failure::Caught() << endl;
-// cout << "TDocStd_Application::Open(): " << aMsg.rdbuf()->str() << endl;
TCollection_ExtendedString aString (F->GetMessageString());
MessageDriver()->Write(aString.ToExtString());
}
return status;
}
+//=======================================================================
+//function : Open
+//purpose :
+//=======================================================================
+
+PCDM_ReaderStatus TDocStd_Application::Open( Standard_IStream& theIStream,
+ Handle(TDocStd_Document)& aDoc )
+{
+ Handle(Storage_IStream) aDevice = new Storage_IStream(theIStream);
+ return Open (aDevice, aDoc);
+}
+
+//=======================================================================
+//function : SaveAs
+//purpose :
+//=======================================================================
+
+PCDM_StoreStatus TDocStd_Application::SaveAs(const Handle(TDocStd_Document)& theDoc,
+ const TCollection_ExtendedString& thePath)
+{
+ Handle(Storage_File) aDevice = new Storage_File(thePath);
+ return SaveAs (theDoc, aDevice);
+}
+
//=======================================================================
//function : SaveAs
//purpose :
//=======================================================================
-PCDM_StoreStatus TDocStd_Application::SaveAs(const Handle(TDocStd_Document)& D,const TCollection_ExtendedString& path) {
+PCDM_StoreStatus TDocStd_Application::SaveAs(const Handle(TDocStd_Document)& D,
+ const Handle(Storage_IODevice)& aDevice)
+ {
+ /*
TDocStd_PathParser tool (path);
TCollection_ExtendedString directory = tool.Trek();
TCollection_ExtendedString file = tool.Name();
file+=".";
file+=tool.Extension();
+ */
D->Open(this);
CDF_Store storer (D);
- if (!storer.SetFolder(directory))
+ if (!storer.SetDevice(aDevice))
{
- TCollection_ExtendedString aMsg ("TDocStd_Application::SaveAs() - folder ");
- aMsg += directory;
- aMsg += " does not exist";
+ TCollection_ExtendedString aMsg ("TDocStd_Application::SaveAs() - device ");
+ aMsg += " not valid";
if(!MessageDriver().IsNull())
MessageDriver()->Write(aMsg.ToExtString());
return storer.StoreStatus(); //CDF_SS_Failure;
}
- storer.SetName (file);
+ // storer.SetName (file);
try {
OCC_CATCH_SIGNALS
storer.Realize();
//purpose :
//=======================================================================
+
+PCDM_StoreStatus TDocStd_Application::SaveAs(const Handle(TDocStd_Document)& theDoc,
+ Standard_OStream& theOStream)
+{
+ Handle(Storage_OStream) aDevice = new Storage_OStream (theOStream);
+ return SaveAs (theDoc, aDevice);
+}
+
+//=======================================================================
+//function : Save
+//purpose :
+//=======================================================================
+
PCDM_StoreStatus TDocStd_Application::Save (const Handle(TDocStd_Document)& D) {
PCDM_StoreStatus status = PCDM_SS_OK;
if (D->IsSaved()) {
//=======================================================================
PCDM_StoreStatus TDocStd_Application::SaveAs(const Handle(TDocStd_Document)& D,
- const TCollection_ExtendedString& path,
+ const Handle(Storage_IODevice)& aDev,
TCollection_ExtendedString& theStatusMessage)
{
- TDocStd_PathParser tool (path);
PCDM_StoreStatus aStatus = PCDM_SS_Failure;
+ /*
+ TDocStd_PathParser tool (path);
TCollection_ExtendedString directory = tool.Trek();
TCollection_ExtendedString file = tool.Name();
file+=".";
file+=tool.Extension();
+ */
D->Open(this);
CDF_Store storer (D);
- if (storer.SetFolder(directory)) {
- storer.SetName (file);
+ if (storer.SetDevice(aDev)) {
+ // storer.SetName (file);
try {
OCC_CATCH_SIGNALS
storer.Realize();
aStatus = storer.StoreStatus();
} else {
theStatusMessage =
- TCollection_ExtendedString("TDocStd_Application::SaveAs"
- ": No such directory ") + directory;
+ TCollection_ExtendedString("TDocStd_Application::SaveAs: No valid device ");
aStatus = PCDM_SS_Failure;
}
return aStatus;
#include <CDM_MetaData.hxx>
+#include <Storage_File.hxx>
+
// List should have a RemoveLast...
#define TDocStd_List_RemoveLast(theList) \
TDF_ListIteratorOfDeltaList it(theList); \
TCollection_ExtendedString TDocStd_Document::GetPath () const
{
- return CDM_Document::MetaData()->Path();
+ TCollection_ExtendedString aPath;
+ Handle(Storage_File) aFile = Handle(Storage_File)::DownCast(CDM_Document::MetaData()->Device());
+ if ( !aFile.IsNull() )
+ aPath = aFile->Path();
+ return aPath;
}
-
//=======================================================================
//function : SetData
//purpose :
xgetenv(aCString: CString from Standard)
returns ExtendedString from TCollection;
- OpenFile(aFile: in out BaseDriver from Storage; aName: ExtendedString from TCollection; aMode : OpenMode from Storage)
- returns Error from Storage;
+-- OpenFile(aFile: in out BaseDriver from Storage; aName: ExtendedString from TCollection; aMode : OpenMode from Storage)
+-- returns Error from Storage;
AddToUserInfo(aData: Data from Storage; anInfo: ExtendedString from TCollection);
theExtension.Remove(1, 1);
return TCollection_ExtendedString(theExtension);
}
-
+/*
Storage_Error UTL::OpenFile(Storage_BaseDriver& aDriver,
const TCollection_ExtendedString& aFileName,
const Storage_OpenMode aMode)
{
return aDriver.Open(TCollection_AsciiString(aFileName),aMode);
}
-
+*/
void UTL::AddToUserInfo(const Handle(Storage_Data)& aData,
const TCollection_ExtendedString& anInfo)
{
uses
Standard,
+ Storage,
TDF,
TDocStd,
TCollection,
Document from PCDM,
Document from CDM,
Document from TDocStd,
+ IODevice from Storage,
Application from CDM,
ADriver from XmlMDF,
ADriverTable from XmlMDF,
returns Document from CDM is redefined virtual;
-- 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;
--
fields
myDrivers : ADriverTable from XmlMDF is protected;
myRelocTable: RRelocationTable from XmlObjMgt is protected;
- myFileName : ExtendedString from TCollection is protected;
+ myDevice : IODevice from Storage is protected;
end DocumentRetrievalDriver;
#include <UTL.hxx>
#include <OSD_Path.hxx>
+#include <Storage_File.hxx>
+#include <Storage_IStream.hxx>
+
#ifdef WNT
# include <tchar.h>
#endif // WNT
//purpose :
//=======================================================================
void XmlLDrivers_DocumentRetrievalDriver::Read
- (const TCollection_ExtendedString& theFileName,
+ (const Handle(Storage_IODevice)& theDevice,
const Handle(CDM_Document)& theNewDocument,
const Handle(CDM_Application)& theApplication)
{
myReaderStatus = PCDM_RS_DriverFailure;
- myFileName = theFileName;
Handle(CDM_MessageDriver) aMessageDriver = theApplication -> MessageDriver();
::take_time (~0, " +++++ Start RETRIEVE procedures ++++++", aMessageDriver);
+ myDevice = theDevice;
+
// 1. Read DOM_Document from file
LDOMParser aParser;
- TCollection_AsciiString aName (theFileName,'?');
- if (aParser.parse(aName.ToCString()))
+
+ Standard_Boolean aRes = Standard_True;
+ Handle(Storage_File) aFile = Handle(Storage_File)::DownCast(theDevice);
+ Handle(Storage_IStream) aStream = Handle(Storage_IStream)::DownCast(theDevice);
+ if ( !aFile.IsNull() )
+ {
+ TCollection_AsciiString aPath( aFile->Path() );
+ aRes = aParser.parse( aPath.ToCString() );
+ }
+ else if ( !aStream.IsNull() && aStream->Stream() )
+ {
+ aRes = aParser.parse( *aStream->Stream() );
+ }
+
+ if (aRes)
{
TCollection_AsciiString aData;
cout << aParser.GetError(aData) << ": " << aData << endl;
const Handle(CDM_MessageDriver) aMsgDriver =
theApplication -> MessageDriver();
// 1. Read info // to be done
- TCollection_AsciiString anAbsoluteDirectory = GetDirFromFile(myFileName);
+ TCollection_AsciiString anAbsoluteDirectory;
+ Handle(Storage_File) aStorageFile = Handle(Storage_File)::DownCast(myDevice);
+ if (!aStorageFile.IsNull())
+ {
+ anAbsoluteDirectory = GetDirFromFile(aStorageFile->Path());
+ }
+
Standard_Integer aCurDocVersion = 0;
TCollection_ExtendedString anInfo;
const XmlObjMgt_Element anInfoElem =
}
// Add new ref!
/////////////
- TCollection_ExtendedString theFolder,theName;
- //TCollection_ExtendedString theFile=myReferences(myIterator).FileName();
- TCollection_ExtendedString f(aPath);
-#ifndef WNT
-
- Standard_Integer i= f.SearchFromEnd("/");
- TCollection_ExtendedString n = f.Split(i);
- f.Trunc(f.Length()-1);
- theFolder = f;
- theName = n;
-#else
- OSD_Path p = UTL::Path(f);
- Standard_ExtCharacter chr;
- TCollection_ExtendedString dir, dirRet, name;
+// TCollection_ExtendedString theFolder,theName;
+// //TCollection_ExtendedString theFile=myReferences(myIterator).FileName();
+// TCollection_ExtendedString f(aPath);
+//#ifndef WNT
+//
+// Standard_Integer i= f.SearchFromEnd("/");
+// TCollection_ExtendedString n = f.Split(i);
+// f.Trunc(f.Length()-1);
+// theFolder = f;
+// theName = n;
+//#else
+// OSD_Path p = UTL::Path(f);
+// Standard_ExtCharacter chr;
+// TCollection_ExtendedString dir, dirRet, name;
+//
+// dir = UTL::Disk(p);
+// dir += UTL::Trek(p);
+//
+// for ( int i = 1; i <= dir.Length (); ++i ) {
+//
+// chr = dir.Value ( i );
+//
+// switch ( chr ) {
+//
+// case _TEXT( '|' ):
+// dirRet += _TEXT( "/" );
+// break;
+//
+// case _TEXT( '^' ):
+//
+// dirRet += _TEXT( ".." );
+// break;
+//
+// default:
+// dirRet += chr;
+//
+// }
+// }
+// theFolder = dirRet;
+// theName = UTL::Name(p); theName+= UTL::Extension(p);
+//#endif // WNT
- dir = UTL::Disk(p);
- dir += UTL::Trek(p);
-
- for ( int i = 1; i <= dir.Length (); ++i ) {
-
- chr = dir.Value ( i );
-
- switch ( chr ) {
-
- case _TEXT( '|' ):
- dirRet += _TEXT( "/" );
- break;
-
- case _TEXT( '^' ):
-
- dirRet += _TEXT( ".." );
- break;
-
- default:
- dirRet += chr;
-
- }
- }
- theFolder = dirRet;
- theName = UTL::Name(p); theName+= UTL::Extension(p);
-#endif // WNT
-
- Handle(CDM_MetaData) aMetaData = CDM_MetaData::LookUp(theFolder,theName,aPath,aPath,UTL::IsReadOnly(aFileName));
-////////////
- theNewDocument->CreateReference(aMetaData,aRefId,
- theApplication,aDocumentVersion,Standard_False);
+ Handle(CDM_MetaData) aMetaData = CDM_MetaData::LookUp(myDevice, UTL::IsReadOnly(aFileName));
-
+ theNewDocument->CreateReference (aMetaData, aRefId, theApplication, aDocumentVersion, Standard_False);
}
-
-
}
if(anInfo == START_REF)
isRef = Standard_True;
Element from XmlObjMgt,
SRelocationTable from XmlObjMgt,
ADriverTable from XmlMDF,
- MessageDriver from CDM
+ MessageDriver from CDM,
+ IODevice from Storage
is
Create (theCopyright: ExtendedString from TCollection)
-- pure virtual method definition
Write (me: mutable;theDocument: Document from CDM;
- theFileName: ExtendedString from TCollection)
+ theDevice: IODevice from Storage)
is redefined virtual;
-- Write <aDocument> to the xml file <theFileName>
WriteToDomDocument(me:mutable; theDocument: Document from CDM;
thePDoc : out Element from XmlObjMgt;
- theFileName: ExtendedString from TCollection)
+ theDevice: IODevice from Storage)
returns Boolean from Standard
is virtual protected;
//=======================================================================
void XmlLDrivers_DocumentStorageDriver::Write
(const Handle(CDM_Document)& theDocument,
- const TCollection_ExtendedString& theFileName)
+ const Handle(Storage_IODevice)& theDevice)
{
Handle(CDM_MessageDriver) aMessageDriver =
theDocument -> Application() -> MessageDriver();
// Fill the document with data
XmlObjMgt_Element anElement = aDOMDoc.getDocumentElement();
- if (WriteToDomDocument (theDocument, anElement, theFileName) == Standard_False) {
+ if (WriteToDomDocument (theDocument, anElement, theDevice) == Standard_False) {
// Write DOM_Document into XML file,
- FILE * aFile = OSD_OpenFile(theFileName, "wt");
+ theDevice->Open( Storage_VSWrite );
- if (aFile) {
- LDOM_XmlWriter aWriter (aFile);
+ if (theDevice->CanWrite()) {
+ LDOM_XmlWriter aWriter (theDevice);
aWriter.SetIndentation(1);
aWriter << aDOMDoc;
- fclose(aFile);
+ theDevice->Close();
::take_time (0, " +++++ Fin formatting to XML : ", aMessageDriver);
-
- }else{
+ }
+ else
+ {
SetIsError (Standard_True);
SetStoreStatus(PCDM_SS_WriteFailure);
TCollection_ExtendedString aMsg =
- TCollection_ExtendedString("Error: the file ") + theFileName +
+ TCollection_ExtendedString("Error: the device ") + theDevice->Name() +
" cannot be opened for writing";
aMessageDriver -> Write (aMsg.ToExtString());
Standard_Failure::Raise("File cannot be opened for writing");
Standard_Boolean XmlLDrivers_DocumentStorageDriver::WriteToDomDocument
(const Handle(CDM_Document)& theDocument,
XmlObjMgt_Element& theElement,
- const TCollection_ExtendedString& theFileName)
+ const Handle(Storage_IODevice)& theDevice)
{
SetIsError(Standard_False);
Handle(CDM_MessageDriver) aMessageDriver =
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);
projects / occt-copy.git / commitdiff