#include <BinMDF_ADriverTable.hxx>
#include <BinMDocStd.hxx>
#include <BinMFunction.hxx>
-#include <BinMNaming.hxx>
-#include <BinMPrsStd.hxx>
#include <CDM_MessageDriver.hxx>
#include <Plugin_Macro.hxx>
#include <Standard_Failure.hxx>
BinMNaming ::AddDrivers (aTable, aMsgDrv);
BinMDocStd ::AddDrivers (aTable, aMsgDrv);
BinMFunction ::AddDrivers (aTable, aMsgDrv);
- BinMPrsStd ::AddDrivers (aTable, aMsgDrv);
return aTable;
}
#include <TCollection_ExtendedString.hxx>
#include <TNaming_NamedShape.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( (Standard_Address)aBuf, theSection.Length() );
+ if ( aSize == theSection.Length() )
+ {
+ Standard_SStream aStrStream( std::string( aBuf, aSize ), Standard_SStream::in | Standard_SStream::binary );
+ aNamedShapeDriver->ReadShapeSection( aStrStream );
}
- 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*/)
{}
//=======================================================================
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-
+#include <BinDrivers_DocumentStorageDriver.ixx>
+#include <Standard_ErrorHandler.hxx>
+#include <Standard_SStream.hxx>
+#include <TCollection_AsciiString.hxx>
#include <BinDrivers.hxx>
#include <BinDrivers_DocumentStorageDriver.hxx>
#include <BinLDrivers_DocumentSection.hxx>
#include <TCollection_AsciiString.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);
}
BinMDocStd ::AddDrivers (aTable, aMsgDrv);
// BinMNaming ::AddDrivers (aTable, aMsgDrv);
-// BinMPrsStd ::AddDrivers (aTable, aMsgDrv);
return aTable;
}
#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. ");
- }
- }
+
}
//=======================================================================
#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( (Standard_Address)&aBuf[0], aBufSize + sizeof(Standard_Integer) );
// Store the address of Offset word in the file
- myValue[0] = (Standard_Size) theStream.tellp();
+ myValue[0] = (Standard_Size) theDevice->Tell();
myValue[1] = 0;
// Write the placeholders of Offset and Length of the section that should
aBufSz[0] = 0;
aBufSz[1] = 0;
aBufSz[2] = 0;
- theStream.write (&aBuf[0], 3*sizeof(Standard_Integer));
+ theDevice->Write( (Standard_Address)&aBuf[0], 3*sizeof(Standard_Integer));
}
}
//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((Standard_Address)&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( (Standard_Address)&aNameBufferSize, sizeof(Standard_Integer) );
#if DO_INVERSE
aNameBufferSize = InverseSize(aNameBufferSize);
#endif
if (aNameBufferSize > 0) {
- theStream.read ((char *)&aBuf[0], (Standard_Size)aNameBufferSize);
+ theDevice->Read ((char *)&aBuf[0], (Standard_Size)aNameBufferSize);
theSection.myName = (Standard_CString)&aBuf[0];
Standard_Integer aValue[3];
- theStream.read ((char *)&aValue[0], 3*sizeof(Standard_Integer));
+ theDevice->Read ((char *)&aValue[0], 3*sizeof(Standard_Integer));
#if DO_INVERSE
aValue[0] = InverseSize (aValue[0]);
aValue[1] = InverseSize (aValue[1]);
//=======================================================================
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( (Standard_Address)&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);
+ }
}
#include <BinMDataXtd_ShapeDriver.hxx>
#include <BinMDF_ADriverTable.hxx>
#include <CDM_MessageDriver.hxx>
+#include <BinMDataXtd_PresentationDriver.hxx>
+#include <BinMDataXtd_PositionDriver.hxx>
static Standard_Integer myDocumentVersion = -1;
//=======================================================================
theDriverTable->AddDriver (new BinMDataXtd_AxisDriver (theMsgDriver) );
theDriverTable->AddDriver (new BinMDataXtd_PlaneDriver (theMsgDriver) );
theDriverTable->AddDriver (new BinMDataXtd_PlacementDriver (theMsgDriver) );
+ theDriverTable->AddDriver (new BinMDataXtd_PresentationDriver(theMsgDriver) );
+ theDriverTable->AddDriver (new BinMDataXtd_PositionDriver (theMsgDriver) );
}
--- /dev/null
+// Created on: 2004-05-17
+// Created by: Sergey ZARITCHNY
+// Copyright (c) 2004-2014 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+// modified 13.04.2009 Sergey ZARITCHNY
+
+#include <BinMDataXtd_PositionDriver.ixx>
+#include <gp_Pnt.hxx>
+#include <Standard_Type.hxx>
+#include <TDataXtd_Position.hxx>
+#include <TDF_Attribute.hxx>
+
+//=======================================================================
+//function : BinMDataStd_PositionDriver
+//purpose : Constructor
+//=======================================================================
+BinMDataXtd_PositionDriver::BinMDataXtd_PositionDriver
+ (const Handle(CDM_MessageDriver)& theMsgDriver)
+: BinMDF_ADriver (theMsgDriver, STANDARD_TYPE(TDataXtd_Position)->Name())
+{
+}
+
+//=======================================================================
+//function : NewEmpty
+//purpose :
+//=======================================================================
+
+Handle(TDF_Attribute) BinMDataXtd_PositionDriver::NewEmpty() const
+{
+ return new TDataXtd_Position();
+}
+
+//=======================================================================
+//function : Paste
+//purpose : persistent -> transient (retrieve)
+//=======================================================================
+
+Standard_Boolean BinMDataXtd_PositionDriver::Paste
+ (const BinObjMgt_Persistent& theSource,
+ const Handle(TDF_Attribute)& theTarget,
+ BinObjMgt_RRelocationTable& ) const
+{
+ Handle(TDataXtd_Position) anAtt = Handle(TDataXtd_Position)::DownCast(theTarget);
+ Standard_Real aValue;
+ Standard_Boolean ok = theSource >> aValue;
+ if (!ok) return ok;
+ gp_Pnt aPosition(0., 0., 0.);
+ aPosition.SetX(aValue);
+
+ ok = theSource >> aValue;
+ if (!ok) return ok;
+ aPosition.SetY(aValue);
+
+ ok = theSource >> aValue;
+ if (!ok) return ok;
+ aPosition.SetZ(aValue);
+
+ anAtt->SetPosition(aPosition);
+
+ return ok;
+}
+
+//=======================================================================
+//function : Paste
+//purpose : transient -> persistent (store)
+//=======================================================================
+
+void BinMDataXtd_PositionDriver::Paste (const Handle(TDF_Attribute)& theSource,
+ BinObjMgt_Persistent& theTarget,
+ BinObjMgt_SRelocationTable& ) const
+{
+ Handle(TDataXtd_Position) anAtt = Handle(TDataXtd_Position)::DownCast(theSource);
+
+ theTarget << anAtt->GetPosition().X();
+ theTarget << anAtt->GetPosition().Y();
+ theTarget << anAtt->GetPosition().Z();
+}
--- /dev/null
+// Created on: 2004-05-17
+// Created by: Sergey ZARITCHNY
+// Copyright (c) 2004-2014 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <BinMDataXtd_PresentationDriver.ixx>
+#include <TDataXtd_Presentation.hxx>
+#include <CDM_MessageDriver.hxx>
+
+//=======================================================================
+//function : BinMDataStd_AISPresentationDriver
+//purpose : Constructor
+//=======================================================================
+BinMDataXtd_PresentationDriver::BinMDataXtd_PresentationDriver
+ (const Handle(CDM_MessageDriver)& theMsgDriver)
+: BinMDF_ADriver(theMsgDriver, STANDARD_TYPE(TDataXtd_Presentation)->Name())
+{
+}
+
+//=======================================================================
+//function : NewEmpty
+//purpose :
+//=======================================================================
+
+Handle(TDF_Attribute) BinMDataXtd_PresentationDriver::NewEmpty() const
+{
+ return new TDataXtd_Presentation();
+}
+
+//=======================================================================
+//function : Paste
+//purpose : persistent -> transient (retrieve)
+//=======================================================================
+
+Standard_Boolean BinMDataXtd_PresentationDriver::Paste
+ (const BinObjMgt_Persistent& theSource,
+ const Handle(TDF_Attribute)& theTarget,
+ BinObjMgt_RRelocationTable& /*theRT*/) const
+{
+ Standard_Boolean ok = Standard_False;
+ Handle(TDataXtd_Presentation) anAttribute = Handle(TDataXtd_Presentation)::DownCast(theTarget);
+
+ // Display status
+ Standard_Integer aValue;
+ ok = theSource >> aValue;
+ if (!ok) return ok;
+ anAttribute->SetDisplayed(static_cast<Standard_Boolean>(aValue));
+
+ // GUID
+ Standard_GUID aGUID;
+ ok = theSource >> aGUID;
+ if (!ok) return ok;
+ anAttribute->SetDriverGUID(aGUID);
+
+ // Color
+ ok = theSource >> aValue;
+ if (!ok) return ok;
+ if ( aValue != -1 )
+ anAttribute->SetColor(aValue);
+ else
+ anAttribute->UnsetColor();
+
+ // Material
+ ok = theSource >> aValue;
+ if ( !ok ) return ok;
+ if (aValue != -1)
+ anAttribute->SetMaterial(aValue);
+ else
+ anAttribute->UnsetMaterial();
+
+ // Transparency
+ Standard_Real aRValue;
+ ok = theSource >> aRValue;
+ if ( !ok ) return ok;
+ if ( aRValue != -1. )
+ anAttribute->SetTransparency(aRValue);
+ else
+ anAttribute->UnsetTransparency();
+
+ // Width
+ ok = theSource >> aRValue;
+ if ( !ok ) return ok;
+ if ( aRValue != -1. )
+ anAttribute->SetWidth(aRValue);
+ else
+ anAttribute->UnsetWidth();
+
+ // Mode
+ ok = theSource >> aValue;
+ if ( !ok ) return ok;
+ if ( aValue != -1 )
+ anAttribute->SetMode(aValue);
+ else
+ anAttribute->UnsetMode();
+
+ return ok;
+}
+
+//=======================================================================
+//function : Paste
+//purpose : transient -> persistent (store)
+//=======================================================================
+
+void BinMDataXtd_PresentationDriver::Paste(const Handle(TDF_Attribute)& theSource,
+ BinObjMgt_Persistent& theTarget,
+ BinObjMgt_SRelocationTable& /*theSRT*/) const
+{
+ Handle(TDataXtd_Presentation) anAttribute = Handle(TDataXtd_Presentation)::DownCast(theSource);
+
+ // Display status
+ theTarget.PutBoolean(anAttribute->IsDisplayed());
+
+ // GUID
+ theTarget.PutGUID(anAttribute->GetDriverGUID());
+
+ // Color
+ if (anAttribute->IsHasOwnColor())
+ theTarget.PutInteger(anAttribute->Color());
+ else
+ theTarget.PutInteger(-1);
+
+ // Material
+ if (anAttribute->IsHasOwnMaterial())
+ theTarget.PutInteger(anAttribute->Material());
+ else
+ theTarget.PutInteger(-1);
+
+ // Transparency
+ if (anAttribute->IsHasOwnTransparency())
+ theTarget.PutReal(anAttribute->Transparency());
+ else
+ theTarget.PutReal(-1.);
+
+ // Width
+ if (anAttribute->IsHasOwnWidth())
+ theTarget.PutReal(anAttribute->Width());
+ else
+ theTarget.PutReal(-1.);
+
+ // Mode
+ if (anAttribute->IsHasOwnMode())
+ theTarget.PutInteger(anAttribute->Mode());
+ else
+ theTarget.PutInteger(-1);
+}
#include <TNaming_NamedShape.hxx>
#include <TopAbs_Orientation.hxx>
#include <TopoDS_Shape.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
}
-
+++ /dev/null
-// Created on: 2004-05-17
-// Created by: Sergey ZARITCHNY
-// Copyright (c) 2004-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-// modified 13.04.2009 Sergey ZARITCHNY
-
-#include <BinMPrsStd_PositionDriver.hxx>
-#include <BinObjMgt_Persistent.hxx>
-#include <CDM_MessageDriver.hxx>
-#include <gp_Pnt.hxx>
-#include <Standard_Type.hxx>
-#include <TDataXtd_Position.hxx>
-#include <TDF_Attribute.hxx>
-
-//=======================================================================
-//function : BinMDataStd_PositionDriver
-//purpose : Constructor
-//=======================================================================
-BinMPrsStd_PositionDriver::BinMPrsStd_PositionDriver
- (const Handle(CDM_MessageDriver)& theMsgDriver)
- : BinMDF_ADriver (theMsgDriver, STANDARD_TYPE(TDataXtd_Position)->Name())
-{
-}
-
-//=======================================================================
-//function : NewEmpty
-//purpose :
-//=======================================================================
-
-Handle(TDF_Attribute) BinMPrsStd_PositionDriver::NewEmpty() const
-{
- return new TDataXtd_Position();
-}
-
-//=======================================================================
-//function : Paste
-//purpose : persistent -> transient (retrieve)
-//=======================================================================
-
-Standard_Boolean BinMPrsStd_PositionDriver::Paste
- (const BinObjMgt_Persistent& theSource,
- const Handle(TDF_Attribute)& theTarget,
- BinObjMgt_RRelocationTable& ) const
-{
- Handle(TDataXtd_Position) anAtt = Handle(TDataXtd_Position)::DownCast(theTarget);
- Standard_Real aValue;
- Standard_Boolean ok = theSource >> aValue;
- if (!ok) return ok;
- gp_Pnt aPosition(0., 0., 0.);
- aPosition.SetX(aValue);
-
- ok = theSource >> aValue;
- if (!ok) return ok;
- aPosition.SetY(aValue);
-
- ok = theSource >> aValue;
- if (!ok) return ok;
- aPosition.SetZ(aValue);
-
- anAtt->SetPosition(aPosition);
-
- return ok;
-}
-
-//=======================================================================
-//function : Paste
-//purpose : transient -> persistent (store)
-//=======================================================================
-
-void BinMPrsStd_PositionDriver::Paste (const Handle(TDF_Attribute)& theSource,
- BinObjMgt_Persistent& theTarget,
- BinObjMgt_SRelocationTable& ) const
-{
- Handle(TDataXtd_Position) anAtt = Handle(TDataXtd_Position)::DownCast(theSource);
-
- theTarget << anAtt->GetPosition().X();
- theTarget << anAtt->GetPosition().Y();
- theTarget << anAtt->GetPosition().Z();
-}
#include <TDF_Data.hxx>
#include <TDF_Label.hxx>
#include <TDF_Tool.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( (Standard_Address)myData(i), nbToWrite );
+ nbWritten += nbToWrite;
+ }
+ myIndex = 1;
+ myOffset = BP_HEADSIZE;
+ mySize = BP_HEADSIZE;
+ myIsError = Standard_False;
+}
+
//=======================================================================
//function : Read
//purpose : Retrieves <me> from the stream.
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
//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;
-
}
-
-
//=======================================================================
//function : Activate
//purpose :
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);
}
//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());
}
//==============================================================================
//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 :
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);
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;
}
//=======================================================================
#include <Standard_Type.hxx>
#include <TCollection_ExtendedString.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 ( aSig.IsEmpty() || !getLookUpTable().IsBound(aSig) ) {
+ theMetaData = new CDM_MetaData(aDevice, ReadOnly);
+ if ( !aSig.IsEmpty() )
+ 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 ( aSig.IsEmpty() || !getLookUpTable().IsBound(aSig) ) {
+ theMetaData = new CDM_MetaData(aDevice, aVersion, ReadOnly);
+ if ( !aSig.IsEmpty() )
+ 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;
-}
-
DDF_Data.cxx
DDF_Data.hxx
DDF_DataCommands.cxx
-DDF_IOStream.cxx
-DDF_IOStream.hxx
DDF_ListIteratorOfTransactionStack.hxx
DDF_Transaction.cxx
DDF_Transaction.hxx
//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((Standard_Address)&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( (Standard_Address)&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((Standard_Address)&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((Standard_Address)&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((Standard_Address)&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((Standard_Address)&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((Standard_Address)&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( (Standard_Address)&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( (Standard_Address)&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( (Standard_Address)&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((Standard_Address)&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((Standard_Address)&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((Standard_Address)&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((Standard_Address)&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) != (Standard_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((Standard_Address)c,size) != (Standard_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((Standard_Address)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();
}
// 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() ) != (Standard_Size)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( (Standard_Address)&c, 1 );
+ if ( c != '\n' && c != '\r')
+ {
+ buffer += c;
}
-
-// if (myStream.get(c) && c != '\r' && c != '\n') {
-// buffer += Buffer;
-// buffer += c;
-// }
-// else {
- buffer += Buffer;
+ else
+ {
+ buffer += '\0';
IsEnd = Standard_True;
-// }
}
}
+}
//=======================================================================
//function : WriteExtendedLine
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((Standard_Address)"\n", 1);
}
//=======================================================================
buffer.Clear();
while (!IsEnd() && (ccount < rsize)) {
- myStream.get(c);
+ Device()->Read( (Standard_Address)&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((Standard_Address)&c, sizeof(c));
+ if (isFirstTime)
+ {
+ if (c == '\n' || c == ' ')
+ {
+ continue;
}
- bpos = Buffer;
-
- // LeftAdjust
- //
- if (isFirstTime) {
+ else
+ {
isFirstTime = Standard_False;
- while (*bpos == '\n' || *bpos == ' ') bpos++;
}
-// char c;
-// if (myStream.get(c) && c != '\n') {
-// buffer += bpos;
-// buffer += c;
-// }
-// else {
- buffer += bpos;
+ }
+
+ if (c != '\n')
+ {
+ buffer += c;
+ }
+ else
+ {
+ buffer += '\0';
IsEnd = Standard_True;
-// }
}
}
+}
//=======================================================================
//function : ReadWord
buffer.Clear();
while (!IsEnd && !FSD_CmpFile::IsEnd()) {
- myStream.get(c);
- if ((c != ' ') && (c != '\n')) IsEnd = Standard_True;
+ Device()->Read( (Standard_Address)&c, sizeof(char) );
+ if ((c != ' ') && (c != '\n'))
+ {
+ IsEnd = Standard_True;
+ }
}
IsEnd = Standard_False;
}
*tmpb = c;
tmpb++; i++;
- myStream.get(c);
- if ((c == '\n') || (c == ' ')) IsEnd = Standard_True;
+ Device()->Read( (Standard_Address)&c, sizeof(char) );
+ if ((c == '\n') || (c == ' '))
+ {
+ IsEnd = Standard_True;
+ }
}
buffer += b;
Storage_BaseDriver& FSD_CmpFile::PutReference(const Standard_Integer aValue)
{
- myStream << aValue << " ";
- if (myStream.bad()) Storage_StreamWriteError::Raise();
+ TCollection_AsciiString aStr = TCollection_AsciiString( aValue ) + " ";
+ if ( Device()->Write( (Standard_Address)aStr.ToCString(), aStr.Length() ) != (Standard_Size)aStr.Length() )
+ Storage_StreamWriteError::Raise();
return *this;
}
Storage_BaseDriver& FSD_CmpFile::PutCharacter(const Standard_Character aValue)
{
- unsigned short i;
+ Standard_Integer i = aValue;
+ TCollection_AsciiString aStr = TCollection_AsciiString( i ) + " ";
+ if ( Device()->Write( (Standard_Address)aStr.ToCString(), aStr.Length() ) != (Standard_Size)aStr.Length() )
+ Storage_StreamWriteError::Raise();
- i = aValue;
- myStream << i << " ";
- if (myStream.bad()) Storage_StreamWriteError::Raise();
return *this;
}
Storage_BaseDriver& FSD_CmpFile::PutExtCharacter(const Standard_ExtCharacter aValue)
{
- myStream << aValue << " ";
- if (myStream.bad()) Storage_StreamWriteError::Raise();
+ Standard_Integer i = aValue;
+ TCollection_AsciiString aStr = TCollection_AsciiString( i ) + " ";
+ if ( Device()->Write( (Standard_Address)aStr.ToCString(), aStr.Length() ) != (Standard_Size)aStr.Length() )
+ Storage_StreamWriteError::Raise();
+
return *this;
}
Storage_BaseDriver& FSD_CmpFile::PutInteger(const Standard_Integer aValue)
{
- myStream << aValue << " ";
- if (myStream.bad()) Storage_StreamWriteError::Raise();
+ TCollection_AsciiString aStr = TCollection_AsciiString( aValue ) + " ";
+ if ( Device()->Write( (Standard_Address)aStr.ToCString(), aStr.Length() ) != (Standard_Size)aStr.Length() )
+ Storage_StreamWriteError::Raise();
+
return *this;
}
Storage_BaseDriver& FSD_CmpFile::PutBoolean(const Standard_Boolean aValue)
{
- myStream << ((Standard_Integer)aValue) << " ";
- if (myStream.bad()) Storage_StreamWriteError::Raise();
+ TCollection_AsciiString aStr = TCollection_AsciiString( (Standard_Integer)aValue ) + " ";
+ if ( Device()->Write( (Standard_Address)aStr.ToCString(), aStr.Length() ) != (Standard_Size)aStr.Length() )
+ Storage_StreamWriteError::Raise();
+
return *this;
}
Storage_BaseDriver& FSD_CmpFile::PutReal(const Standard_Real aValue)
{
- myStream << ((Standard_Real)aValue) << " ";
- if (myStream.bad()) Storage_StreamWriteError::Raise();
+ TCollection_AsciiString aStr = TCollection_AsciiString( aValue ) + " ";
+ if ( Device()->Write( (Standard_Address)aStr.ToCString(), aStr.Length() ) != (Standard_Size)aStr.Length() )
+ Storage_StreamWriteError::Raise();
+
return *this;
}
Storage_BaseDriver& FSD_CmpFile::PutShortReal(const Standard_ShortReal aValue)
{
- myStream << aValue << " ";
- if (myStream.bad()) Storage_StreamWriteError::Raise();
+ TCollection_AsciiString aStr = TCollection_AsciiString( aValue ) + " ";
+ if ( Device()->Write( (Standard_Address)aStr.ToCString(), aStr.Length() ) != (Standard_Size)aStr.Length() )
+ Storage_StreamWriteError::Raise();
+
return *this;
}
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 = (Standard_ShortReal)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( (Standard_Address)&c, sizeof( char ) );
while (c != '#') {
if (IsEnd() || (c != ' ') || (c == '\r')|| (c == '\n')) {
Storage_StreamFormatError::Raise();
}
- myStream.get(c);
+ Device()->Read( (Standard_Address)&c, sizeof( char ) );
}
- if (!(myStream >> aRef)) Storage_StreamTypeMismatchError::Raise();
+ GetInteger (aRef);
- myStream.get(c);
+ Device()->Read( (Standard_Address)&c, sizeof( char ) );
while (c != '%') {
if (IsEnd() || (c != ' ') || (c == '\r')|| (c == '\n')) {
Storage_StreamFormatError::Raise();
}
- myStream.get(c);
+ Device()->Read( (Standard_Address)&c, sizeof( char ) );
}
- if (!(myStream >> aType)) Storage_StreamTypeMismatchError::Raise();
-// cout << "REF:" << aRef << " TYPE:"<< aType << endl;
+ GetInteger (aType);
}
//=======================================================================
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( (Standard_Address)&c, sizeof( char ) );
while (c != '\n' && (c != '\r')) {
if (IsEnd() || (c != ' ')) {
Storage_StreamFormatError::Raise();
}
- myStream.get(c);
+ Device()->Read( (Standard_Address)&c, sizeof( char ) );
}
if (c == '\r') {
- myStream.get(c);
+ Device()->Read( (Standard_Address)&c, sizeof( char ) );
}
-// cout << "EndReadPersistentObjectData" << endl;
}
//=======================================================================
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;
- }
-}
// 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() ) != (Standard_Size)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( (Standard_Address)&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( (Standard_Address)&cc, sizeof(char) );
+ Device()->Write( (Standard_Address)&cd, sizeof(char) );
}
- myStream << (char)0 << "\n";
+ Device()->Write((Standard_Address)"\0\n", 2);
}
//=======================================================================
buffer.Clear();
while (!fin && !IsEnd()) {
- myStream.get(c);
+ Device()->Read( (Standard_Address)&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( (Standard_Address)&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( (Standard_Address)&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((Standard_Address)&c, sizeof(c));
+ if ( isFirstTime )
+ {
+ if ( c == '\n' || c == ' ' )
+ continue;
+ else
+ isFirstTime = Standard_False;
}
-// char c;
-// if (myStream.get(c) && c != '\n') {
-// buffer += bpos;
-// buffer += c;
-// }
-// else {
- buffer += bpos;
+
+ if ( c != '\n')
+ buffer += c;
+ else
+ {
+ buffer += '\0';
IsEnd = Standard_True;
-// }
+ }
}
-
}
//=======================================================================
buffer.Clear();
while (!IsEnd && !FSD_File::IsEnd()) {
- myStream.get(c);
- if ((c != ' ') && (c != '\n')) IsEnd = Standard_True;
+ Device()->Read( (Standard_Address)&c, sizeof(char) );
+ if ((c != ' ') && (c != '\n'))
+ IsEnd = Standard_True;
}
IsEnd = Standard_False;
}
*tmpb = c;
tmpb++; i++;
- myStream.get(c);
- if ((c == '\n') || (c == ' ')) IsEnd = Standard_True;
+ Device()->Read( (Standard_Address)&c, sizeof(char) );
+ if ((c == '\n') || (c == ' '))
+ IsEnd = Standard_True;
}
buffer += b;
Storage_BaseDriver& FSD_File::PutReference(const Standard_Integer aValue)
{
- myStream << aValue << " ";
- if (myStream.bad()) Storage_StreamWriteError::Raise();
+ TCollection_AsciiString aStr = TCollection_AsciiString( aValue ) + " ";
+ if ( Device()->Write( (Standard_Address)aStr.ToCString(), aStr.Length() ) != (Standard_Size)aStr.Length() )
+ Storage_StreamWriteError::Raise();
+
return *this;
}
Storage_BaseDriver& FSD_File::PutCharacter(const Standard_Character aValue)
{
- unsigned short i;
-
- i = aValue;
- myStream << i << " ";
- if (myStream.bad()) Storage_StreamWriteError::Raise();
+ Standard_Integer i = aValue;
+ TCollection_AsciiString aStr = TCollection_AsciiString( i ) + " ";
+ if ( Device()->Write( (Standard_Address)aStr.ToCString(), aStr.Length() ) != (Standard_Size)aStr.Length() )
+ Storage_StreamWriteError::Raise();
return *this;
}
Storage_BaseDriver& FSD_File::PutExtCharacter(const Standard_ExtCharacter aValue)
{
- myStream << aValue << " ";
- if (myStream.bad()) Storage_StreamWriteError::Raise();
+ Standard_Integer i = aValue;
+ TCollection_AsciiString aStr = TCollection_AsciiString( i ) + " ";
+ if ( Device()->Write( (Standard_Address)aStr.ToCString(), aStr.Length() ) != (Standard_Size)aStr.Length() )
+ Storage_StreamWriteError::Raise();
return *this;
}
Storage_BaseDriver& FSD_File::PutInteger(const Standard_Integer aValue)
{
- myStream << aValue << " ";
- if (myStream.bad()) Storage_StreamWriteError::Raise();
+ TCollection_AsciiString aStr = TCollection_AsciiString( aValue ) + " ";
+ if ( Device()->Write( (Standard_Address)aStr.ToCString(), aStr.Length() ) != (Standard_Size)aStr.Length() )
+ Storage_StreamWriteError::Raise();
return *this;
}
Storage_BaseDriver& FSD_File::PutBoolean(const Standard_Boolean aValue)
{
- myStream << ((Standard_Integer)aValue) << " ";
- if (myStream.bad()) Storage_StreamWriteError::Raise();
+ TCollection_AsciiString aStr = TCollection_AsciiString( (Standard_Integer)aValue ) + " ";
+ if ( Device()->Write( (Standard_Address)aStr.ToCString(), aStr.Length() ) != (Standard_Size)aStr.Length() )
+ Storage_StreamWriteError::Raise();
return *this;
}
Storage_BaseDriver& FSD_File::PutReal(const Standard_Real aValue)
{
- myStream << ((Standard_Real)aValue) << " ";
- if (myStream.bad()) Storage_StreamWriteError::Raise();
+ TCollection_AsciiString aStr = TCollection_AsciiString( aValue ) + " ";
+ if ( Device()->Write( (Standard_Address)aStr.ToCString(), aStr.Length() ) != (Standard_Size)aStr.Length() )
+ Storage_StreamWriteError::Raise();
return *this;
}
Storage_BaseDriver& FSD_File::PutShortReal(const Standard_ShortReal aValue)
{
- myStream << aValue << " ";
- if (myStream.bad()) Storage_StreamWriteError::Raise();
+ TCollection_AsciiString aStr = TCollection_AsciiString( aValue ) + " ";
+ if ( Device()->Write( (Standard_Address)aStr.ToCString(), aStr.Length() ) != (Standard_Size)aStr.Length() )
+ Storage_StreamWriteError::Raise();
return *this;
}
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 = (Standard_ShortReal)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( (Standard_Address)&c, sizeof(char) );
while (c != '#') {
if (IsEnd() || (c != ' ') || (c == '\n')) {
Storage_StreamFormatError::Raise();
}
- myStream.get(c);
+ Device()->Read( (Standard_Address)&c, sizeof(char) );
}
- if (!(myStream >> aRef)) Storage_StreamTypeMismatchError::Raise();
+ GetInteger (aRef);
- myStream.get(c);
+ Device()->Read( (Standard_Address)&c, sizeof(char) );
while (c != '=') {
if (IsEnd() || (c != ' ') || (c == '\n')) {
Storage_StreamFormatError::Raise();
}
- myStream.get(c);
+ Device()->Read( (Standard_Address)&c, sizeof(char) );
}
- myStream.get(c);
+ Device()->Read( (Standard_Address)&c, sizeof(char) );
while (c != '%') {
if (IsEnd() || (c != ' ') || (c == '\n')) {
Storage_StreamFormatError::Raise();
}
- myStream.get(c);
+ Device()->Read( (Standard_Address)&c, sizeof(char) );
}
- if (!(myStream >> aType)) Storage_StreamTypeMismatchError::Raise();
-// cout << "REF:" << aRef << " TYPE:"<< aType << endl;
+ GetInteger (aType);
}
//=======================================================================
void FSD_File::BeginReadPersistentObjectData()
{
char c;
- myStream.get(c);
+ Device()->Read( (Standard_Address)&c, sizeof(char) );
while (c != '(') {
if (IsEnd() || (c != ' ') || (c == '\n')) {
Storage_StreamFormatError::Raise();
}
- myStream.get(c);
+ Device()->Read( (Standard_Address)&c, sizeof(char) );
}
-
-//cout << "BeginReadPersistentObjectData" << endl;
}
//=======================================================================
{
char c;
- myStream.get(c);
+ Device()->Read( (Standard_Address)&c, sizeof(char) );
while (c != '(') {
if (IsEnd() || (c != ' ') || (c == '\n')) {
Storage_StreamFormatError::Raise();
}
- myStream.get(c);
+ Device()->Read( (Standard_Address)&c, sizeof(char) );
}
-
-// cout << "BeginReadObjectData" << endl;
}
//=======================================================================
{
char c;
- myStream.get(c);
+ Device()->Read( (Standard_Address)&c, sizeof(char) );
while (c != ')') {
if (IsEnd() || (c != ' ') || (c == '\n')) {
Storage_StreamFormatError::Raise();
}
- myStream.get(c);
+ Device()->Read( (Standard_Address)&c, sizeof(char) );
}
-
-// cout << "EndReadObjectData" << endl;
}
//=======================================================================
char c;
- myStream.get(c);
+ Device()->Read( (Standard_Address)&c, sizeof(char) );
while (c != ')') {
if (IsEnd() || (c != ' ') || (c == '\n')) {
Storage_StreamFormatError::Raise();
}
- myStream.get(c);
+ Device()->Read( (Standard_Address)&c, sizeof(char) );
}
- myStream.get(c);
+ Device()->Read( (Standard_Address)&c, sizeof(char) );
while (c != '\n') {
if (IsEnd() || (c != ' ')) {
Storage_StreamFormatError::Raise();
}
- myStream.get(c);
+ Device()->Read( (Standard_Address)&c, sizeof(char) );
}
-// cout << "EndReadPersistentObjectData" << endl;
}
//=======================================================================
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
--- /dev/null
+// Created on: 1997-07-08
+// Created by: Sergey RUIN
+// Copyright (c) 1997-1999 Matra Datavision
+// Copyright (c) 1999-2014 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <MDataXtd_PresentationStorageDriver.ixx>
+
+#include <PDataXtd_Presentation.hxx>
+#include <PDataXtd_Presentation_1.hxx>
+#include <TDataXtd_Presentation.hxx>
+#include <TCollection_ExtendedString.hxx>
+#include <PCollection_HExtendedString.hxx>
+#include <CDM_MessageDriver.hxx>
+
+//=======================================================================
+//function : MDataXtd_PresentationStorageDriver
+//purpose :
+//=======================================================================
+
+MDataXtd_PresentationStorageDriver::MDataXtd_PresentationStorageDriver(const Handle(CDM_MessageDriver)& theMsgDriver)
+: MDF_ASDriver(theMsgDriver)
+{
+}
+
+Standard_Integer MDataXtd_PresentationStorageDriver::VersionNumber() const
+{
+ return 0;
+}
+
+Handle(Standard_Type) MDataXtd_PresentationStorageDriver::SourceType() const
+{
+ return STANDARD_TYPE(TDataXtd_Presentation);
+}
+
+Handle(PDF_Attribute) MDataXtd_PresentationStorageDriver::NewEmpty() const
+{
+ return new PDataXtd_Presentation_1;
+}
+
+void MDataXtd_PresentationStorageDriver::Paste(const Handle(TDF_Attribute)& Source,
+ const Handle(PDF_Attribute)& Target,
+ const Handle(MDF_SRelocationTable)& /*RelocTable*/) const
+{
+ Handle(TDataXtd_Presentation) S = Handle(TDataXtd_Presentation)::DownCast(Source);
+
+ Handle(PDataXtd_Presentation_1) T = Handle(PDataXtd_Presentation_1)::DownCast(Target);
+
+ T->SetDisplayed( S->IsDisplayed() );
+
+ TCollection_ExtendedString extstr("00000000-0000-0000-0000-000000000000"); //covert GUID into ExtendedString
+ Standard_PExtCharacter pStr = const_cast<Standard_PExtCharacter>(extstr.ToExtString());
+ S->GetDriverGUID().ToExtString(pStr);
+
+ Handle(PCollection_HExtendedString) guid = new PCollection_HExtendedString ( extstr );
+ T->SetDriverGUID ( guid );
+
+ if( S->IsHasOwnColor() ) T->SetColor( S->Color() );
+ else T->SetColor(-1);
+
+ if( S->IsHasOwnMaterial() ) T->SetMaterial( S->Material() );
+ else T->SetMaterial(-1);
+
+ if( S->IsHasOwnTransparency() ) T->SetTransparency( S->Transparency() );
+ else T->SetTransparency(-1.);
+
+ if( S->IsHasOwnWidth() ) T->SetWidth( S->Width() );
+ else T->SetWidth(-1.);
+
+ T->SetMode(S->Mode());
+
+#ifdef OCCT_DEBUG
+ cout << "AISPresentationStorageDriver " << "storaged DriverGUID ==> " << guid->Convert() << endl;
+#endif
+}
return CAF
}
proc ApplicationFramework:depends { } {
- return [list Visualization]
+ return [list ModelingAlgorithms]
}
;#
;# Liste des toolkits WOK sous forme de full path
;#
proc Draw:toolkits { } {
- set aResult [list TKDraw TKTopTest TKViewerTest TKXSDRAW TKDCAF TKXDEDRAW TKTObjDRAW TKQADraw]
+ set aResult [list TKDraw TKTopTest TKViewerTest TKVCAF TKXSDRAW TKDCAF TKXDEDRAW TKTObjDRAW TKQADraw]
if { [info exists ::env(HAVE_VTK)] && $::env(HAVE_VTK) == "true" } {
lappend aResult "TKIVtkDraw"
//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);
+ if ( !aFile.IsNull() )
+ {
+ TCollection_AsciiString aPath( aFile->Path() );
+ aRes = LDOMParser::parse( aPath.ToCString() );
+ }
+ else if ( !anInput.IsNull() && anInput->CanRead() )
+ {
+ Standard_Size aSize = 8000;
+ char* aBuf = (char*)malloc( aSize );
+ anInput->Open(Storage_VSRead);
+ std::string aStr;
+ while ( !anInput->IsEnd() )
+ {
+ Standard_Size aNum = anInput->Read( aBuf, aSize );
+ aStr.append( aBuf, aNum );
+ }
+ anInput->Close();
+ free( aBuf );
+
+ Standard_SStream aStream( std::ios::in );
+ aStream.str( aStr );
+
+ aRes = LDOMParser::parse( aStream );
+ }
+ return aRes;
+}
+
//=======================================================================
//function : SetStartElementName
//purpose : set the name of the element which would stop parsing when detected
#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
#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)))
#include <CDM_MessageDriver.hxx>
#include <CDM_MetaData.hxx>
#include <CDM_ReferenceIterator.hxx>
+#include <CDM_MetaData.hxx>
+#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 <OSD_Path.hxx>
#include <PCDM.hxx>
#include <PCDM_BaseDriverPointer.hxx>
#include <PCDM_ReadWriter_1.hxx>
#include <PCDM_Reference.hxx>
#include <PCDM_TypeOfFileDriver.hxx>
-#include <Standard_ErrorHandler.hxx>
-#include <Standard_Type.hxx>
-#include <Storage_Data.hxx>
-#include <Storage_HeaderData.hxx>
-#include <Storage_Schema.hxx>
-#include <TCollection_AsciiString.hxx>
-#include <TCollection_ExtendedString.hxx>
-#include <TColStd_SequenceOfAsciiString.hxx>
-#include <TColStd_SequenceOfExtendedString.hxx>
-#include <UTL.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());
}
-
}
}
}
#include <PCDM_Reference.hxx>
#include <TCollection_ExtendedString.hxx>
-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_RetrievalDriver.hxx>
#include <Standard_Type.hxx>
#include <Storage_Data.hxx>
+#include <Storage_IODevice.hxx>
#include <UTL.hxx>
#ifdef WNT
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
#include <Storage_HSeqOfRoot.hxx>
#include <Storage_Root.hxx>
#include <Storage_Schema.hxx>
+#include <Storage_IODevice.hxx>
#include <TCollection_AsciiString.hxx>
#include <TCollection_ExtendedString.hxx>
#include <TColStd_SequenceOfAsciiString.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
-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();
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: {
Standard_HandlerStatus.hxx
Standard_ImmutableObject.hxx
Standard_Integer.hxx
-Standard_IStream.hxx
Standard_JmpBuf.hxx
Standard_LicenseError.hxx
Standard_LicenseNotFound.hxx
Standard_ShortReal.cxx
Standard_ShortReal.hxx
Standard_Size.hxx
+Standard_IStream.hxx
+Standard_IStreamPtr.hxx
+Standard_OStream.hxx
+Standard_OStreamPtr.hxx
+Standard_FStream.hxx
Standard_SStream.cxx
Standard_SStream.hxx
Standard_Stream.hxx
--- /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
+
+
#include <TCollection_AsciiString.hxx>
#include <TCollection_ExtendedString.hxx>
-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
+// 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
+// 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( (Standard_Address)&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( (Standard_Address)&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
+// File: Storage_OStream.cxx
+// Created: 20.05.15
+// Author:
+// Copyright: Open CASCADE 2015
+
+#include <Storage_IStream.ixx>
+
+#include <Standard_SStream.hxx>
+
+#include <TCollection_AsciiString.hxx>
+#include <TCollection_ExtendedString.hxx>
+
+//=======================================================================
+//function : Storage_IStream
+//purpose : Constructor
+//=======================================================================
+Storage_IStream::Storage_IStream (Standard_IStream& theStream)
+ : Storage_IODevice(),
+ myStream( &theStream ),
+ myBuffer( std::ios::in | std::ios::binary )
+{
+}
+
+//=======================================================================
+//function : Delete
+//purpose :
+//=======================================================================
+void Storage_IStream::Delete()
+{
+}
+
+//=======================================================================
+//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 ( !myBuffer.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
+ myBuffer.clear();
+ Seek( 0 );
+ }
+ }
+ else
+ {
+ anOpenResult = Storage_VSAlreadyOpen;
+ }
+
+ return anOpenResult;
+}
+
+//=======================================================================
+//function : IsEnd
+//purpose :
+//=======================================================================
+Standard_Boolean Storage_IStream::IsEnd() const
+{
+ return myBuffer.eof() && myStream->eof();
+}
+
+//=======================================================================
+//function : Tell
+//purpose :
+//=======================================================================
+Storage_Position Storage_IStream::Tell()
+{
+ return Storage_Position( myBuffer.tellg() );
+}
+
+//=======================================================================
+//function : Seek
+//purpose :
+//=======================================================================
+Standard_Boolean Storage_IStream::Seek (const Storage_Position& thePos, const Storage_SeekMode aMode )
+{
+ if ( aMode == Storage_SMEnd )
+ {
+ fillBuffer();
+ myBuffer.seekg( thePos, ios::end );
+ }
+ else
+ {
+ Standard_Size aCur = myBuffer.tellg();
+ Standard_Size aPos = aMode == Storage_SMBegin ? thePos : aCur + thePos;
+ if ( aPos > aCur )
+ {
+ myBuffer.seekg( 0, ios::end );
+ Standard_Size aLast = myBuffer.tellg();
+ if ( aLast < aPos )
+ {
+ Standard_Size aCount = aPos - aLast;
+ char* aBuf = (char*)malloc( aCount );
+ myStream->read( aBuf, aCount );
+ Standard_Size aNum = (Standard_Size)myStream->gcount();
+ std::string aStr = myBuffer.str();
+ aStr.append( (char*)aBuf, aNum );
+ myBuffer.str( aStr );
+ free( aBuf );
+ aPos = aLast + aNum;
+ }
+ }
+ if ( aPos != aCur )
+ myBuffer.seekg( aPos );
+ }
+
+ return !myBuffer.fail();
+}
+
+//=======================================================================
+//function : Close
+//purpose :
+//=======================================================================
+Standard_Boolean Storage_IStream::Close()
+{
+ SetOpenMode( Storage_VSNone );
+ myBuffer.clear();
+
+ return Standard_True;
+}
+
+//=======================================================================
+//function : CanRead
+//purpose :
+//=======================================================================
+Standard_Boolean Storage_IStream::CanRead() const
+{
+ return myBuffer.good() || 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 )
+{
+ myBuffer.read((char*)theBuffer, theSize);
+ Standard_Size aCount = (Standard_Size)myBuffer.gcount();
+ if ( aCount < theSize )
+ {
+ myStream->read((char*)theBuffer + aCount, theSize - aCount );
+ Standard_Size aNum = (Standard_Size)myStream->gcount();
+
+ if ( aNum > 0 )
+ {
+ std::string aStr = myBuffer.str();
+ aStr.append( (char*)theBuffer + aCount, aNum );
+ myBuffer.str( aStr );
+ aCount += aNum;
+
+ myBuffer.clear();
+ myBuffer.seekg( 0, std::ios::end );
+ }
+ }
+
+ return aCount;
+}
+
+//=======================================================================
+//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();
+}
+
+//=======================================================================
+//function : Print
+//purpose :
+//=======================================================================
+Standard_OStream& Storage_IStream::Print (Standard_OStream& theOStream) const
+{
+ return theOStream;
+}
+
+//=======================================================================
+//function : fillBuffer
+//purpose :
+//=======================================================================
+void Storage_IStream::fillBuffer()
+{
+ Standard_Size aCur = myBuffer.tellg();
+
+ Standard_Size aSize = 8000;
+ char* aBuf = (char*)malloc( aSize );
+ while ( !myStream->eof() )
+ {
+ myStream->read( aBuf, aSize );
+ Standard_Size aNum = (Standard_Size)myStream->gcount();
+ std::string aStr = myBuffer.str();
+ aStr.append( (char*)aBuf, aNum );
+ myBuffer.str( aStr );
+ }
+ free( aBuf );
+
+ myBuffer.seekg( aCur );
+}
--- /dev/null
+// File: Storage_OStream.cxx
+// Created: 20.05.15
+// Author:
+// Copyright: Open CASCADE 2015
+
+#include <Storage_OStream.ixx>
+
+#include <Standard_SStream.hxx>
+
+#include <TCollection_AsciiString.hxx>
+#include <TCollection_ExtendedString.hxx>
+
+//=======================================================================
+//function : Storage_OStream
+//purpose : Constructor
+//=======================================================================
+Storage_OStream::Storage_OStream( Standard_OStream& theStream )
+ : Storage_IODevice(),
+ myStream( &theStream ),
+ myBuffer( std::ios::out | std::ios::binary )
+{
+}
+
+//=======================================================================
+//function : Delete
+//purpose :
+//=======================================================================
+void Storage_OStream::Delete()
+{
+}
+
+//=======================================================================
+//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
+ myBuffer.clear();
+ if ( theMode == Storage_VSWrite )
+ myBuffer.seekp(0, ios::beg);
+ else
+ myBuffer.seekp(0, ios::end);
+ }
+ }
+ else
+ {
+ anOpenResult = Storage_VSAlreadyOpen;
+ }
+
+ return anOpenResult;
+}
+
+//=======================================================================
+//function : IsEnd
+//purpose :
+//=======================================================================
+Standard_Boolean Storage_OStream::IsEnd() const
+{
+ return myBuffer.eof();
+}
+
+//=======================================================================
+//function : Tell
+//purpose :
+//=======================================================================
+Storage_Position Storage_OStream::Tell()
+{
+ return Storage_Position( myBuffer.tellp() );
+}
+
+//=======================================================================
+//function : Seek
+//purpose :
+//=======================================================================
+Standard_Boolean Storage_OStream::Seek (const Storage_Position& thePos, const Storage_SeekMode aMode )
+{
+ switch ( aMode )
+ {
+ case Storage_SMEnd:
+ myBuffer.seekp(thePos, ios::end);
+ break;
+ case Storage_SMCur:
+ myBuffer.seekp(thePos, ios::cur);
+ break;
+ case Storage_SMBegin:
+ default:
+ myBuffer.seekp(thePos, ios::beg);
+ break;
+ }
+
+ return !myBuffer.fail();
+}
+
+//=======================================================================
+//function : Close
+//purpose :
+//=======================================================================
+Standard_Boolean Storage_OStream::Close()
+{
+ SetOpenMode( Storage_VSNone );
+
+ std::string aStr = myBuffer.str();
+
+ myStream->write( aStr.c_str(), aStr.size() );
+
+ 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 myBuffer.good() && 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)
+{
+ myBuffer.write((char*)theBuffer, theSize);
+ return theSize;
+}
+
+//=======================================================================
+//function : Signature
+//purpose :
+//=======================================================================
+TCollection_AsciiString Storage_OStream::Signature() const
+{
+ return TCollection_AsciiString();
+}
+
+//=======================================================================
+//function : Print
+//purpose :
+//=======================================================================
+Standard_OStream& Storage_OStream::Print (Standard_OStream& theOStream) const
+{
+ return theOStream;
+}
--- /dev/null
+// Created on: 2015-04-20
+// Created by: Alexander Zaikin
+// 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.
+
+#include <TDataXtd_Presentation.ixx>
+
+#include <TDF_DefaultDeltaOnRemoval.hxx>
+#include <TDF_DefaultDeltaOnModification.hxx>
+#include <TDF_DeltaOnAddition.hxx>
+#include <TDF_Tool.hxx>
+#include <TCollection_ExtendedString.hxx>
+
+//=======================================================================
+//function : TDataXtd_Presentation
+//purpose : Default constructor.
+//=======================================================================
+TDataXtd_Presentation::TDataXtd_Presentation()
+: myDriverGUID ("00000000-0000-0000-0000-000000000000"),
+ myColor (516), // Quantity_NOC_WHITE
+ myMaterial (0), // Graphic3d_NOM_BRASS
+ myMode (0),
+ mySelectionMode (0),
+ myTransparency (0.0),
+ myWidth (0.0),
+ myIsDisplayed (Standard_False),
+ myIsHasOwnColor (Standard_False),
+ myIsHasOwnMaterial (Standard_False),
+ myIsHasOwnTransparency (Standard_False),
+ myIsHasOwnWidth (Standard_False),
+ myIsHasOwnMode (Standard_False),
+ myIsHasOwnSelectionMode(Standard_False)
+{}
+
+
+//=======================================================================
+//function : Set
+//purpose :
+//=======================================================================
+Handle(TDataXtd_Presentation) TDataXtd_Presentation::Set(const TDF_Label& theLabel,
+ const Standard_GUID& theDriverId)
+{
+ Handle(TDataXtd_Presentation) aPresentation;
+
+ if ( !theLabel.FindAttribute(TDataXtd_Presentation::GetID(), aPresentation) )
+ {
+ aPresentation = new TDataXtd_Presentation();
+ theLabel.AddAttribute(aPresentation);
+ }
+
+ aPresentation->SetDriverGUID(theDriverId);
+ return aPresentation;
+}
+
+
+//=======================================================================
+//function : Set
+//purpose :
+//=======================================================================
+Handle(TDataXtd_Presentation) TDataXtd_Presentation::Set(const Handle(TDF_Attribute)& theMaster)
+{
+ Handle(TDataXtd_Presentation) aPresentation;
+
+ const TDF_Label aLabel = theMaster->Label();
+ if (!aLabel.FindAttribute(TDataXtd_Presentation::GetID(), aPresentation))
+ {
+ aPresentation = new TDataXtd_Presentation();
+ aLabel.AddAttribute(aPresentation);
+ }
+
+ aPresentation->SetDriverGUID( theMaster->ID() );
+ return aPresentation;
+}
+
+
+//=======================================================================
+//function : Unset
+//purpose :
+//=======================================================================
+void TDataXtd_Presentation::Unset(const TDF_Label& theLabel)
+{
+ Handle(TDataXtd_Presentation) aPresentation;
+ if (theLabel.FindAttribute(TDataXtd_Presentation::GetID(), aPresentation))
+ theLabel.ForgetAttribute(aPresentation);
+}
+
+
+//=======================================================================
+//function : GetID
+//purpose :
+//=======================================================================
+const Standard_GUID& TDataXtd_Presentation::GetID()
+{
+ static Standard_GUID TDataXtd_PresentationID("04fb4d00-5690-11d1-8940-080009dc3333");
+ return TDataXtd_PresentationID;
+}
+
+
+//=======================================================================
+//function : ID
+//purpose :
+//=======================================================================
+const Standard_GUID& TDataXtd_Presentation::ID() const
+{
+ return GetID();
+}
+
+
+//=======================================================================
+//function :GetDriverGUID
+//purpose :
+//=======================================================================
+Standard_GUID TDataXtd_Presentation::GetDriverGUID() const
+{
+ return myDriverGUID;
+}
+
+
+//=======================================================================
+//function :SetDriverGUID
+//purpose :
+//=======================================================================
+void TDataXtd_Presentation::SetDriverGUID(const Standard_GUID& theGUID)
+{
+ if ( myDriverGUID != theGUID )
+ {
+ Backup();
+ myDriverGUID = theGUID;
+ }
+}
+
+
+//=======================================================================
+//function : IsDisplayed
+//purpose :
+//=======================================================================
+Standard_Boolean TDataXtd_Presentation::IsDisplayed() const
+{
+ return myIsDisplayed;
+}
+
+
+//=======================================================================
+//function : IsHasOwnMaterial
+//purpose :
+//=======================================================================
+Standard_Boolean TDataXtd_Presentation::IsHasOwnMaterial() const
+{
+ return myIsHasOwnMaterial;
+}
+
+
+//=======================================================================
+//function : IsHasOwnTransparency
+//purpose :
+//=======================================================================
+Standard_Boolean TDataXtd_Presentation::IsHasOwnTransparency() const
+{
+ return myIsHasOwnTransparency;
+}
+
+
+//=======================================================================
+//function : IsHasOwnColor
+//purpose :
+//=======================================================================
+Standard_Boolean TDataXtd_Presentation::IsHasOwnColor() const
+{
+ return myIsHasOwnColor;
+}
+
+
+//=======================================================================
+//function : IsHasOwnWidth
+//purpose :
+//=======================================================================
+Standard_Boolean TDataXtd_Presentation::IsHasOwnWidth() const
+{
+ return myIsHasOwnWidth;
+}
+
+
+//=======================================================================
+//function : IsHasOwnMode
+//purpose :
+//=======================================================================
+Standard_Boolean TDataXtd_Presentation::IsHasOwnMode() const
+{
+ return myIsHasOwnMode;
+}
+
+
+//=======================================================================
+//function : IsHasOwnSelectionMode
+//purpose :
+//=======================================================================
+Standard_Boolean TDataXtd_Presentation::IsHasOwnSelectionMode() const
+{
+ return myIsHasOwnSelectionMode;
+}
+
+
+//=======================================================================
+//function : SetDisplayed
+//purpose :
+//=======================================================================
+void TDataXtd_Presentation::SetDisplayed(const Standard_Boolean theIsDisplayed)
+{
+ Backup();
+ myIsDisplayed = theIsDisplayed;
+}
+
+
+//=======================================================================
+//function : SetMaterial
+//purpose :
+//=======================================================================
+void TDataXtd_Presentation::SetMaterial(const Standard_Integer theName)
+{
+ Backup();
+ myMaterial = theName;
+ myIsHasOwnMaterial = Standard_True;
+}
+
+
+//=======================================================================
+//function : SetTransparency
+//purpose :
+//=======================================================================
+void TDataXtd_Presentation::SetTransparency(const Standard_Real theValue)
+{
+ Backup();
+ myTransparency = theValue;
+ myIsHasOwnTransparency = Standard_True;
+}
+
+
+//=======================================================================
+//function : SetColor
+//purpose :
+//=======================================================================
+void TDataXtd_Presentation::SetColor(const Standard_Integer theColor)
+{
+ Backup();
+ myColor = theColor;
+ myIsHasOwnColor = Standard_True;
+}
+
+
+//=======================================================================
+//function : SetWidth
+//purpose :
+//=======================================================================
+void TDataXtd_Presentation::SetWidth(const Standard_Real theWidth)
+{
+ Backup();
+ myWidth = theWidth;
+ myIsHasOwnWidth = Standard_True;
+}
+
+
+//=======================================================================
+//function : SetMode
+//purpose :
+//=======================================================================
+void TDataXtd_Presentation::SetMode(const Standard_Integer theMode)
+{
+ Backup();
+ myMode = theMode;
+ myIsHasOwnMode = Standard_True;
+}
+
+
+//=======================================================================
+//function : SetSelectionMode
+//purpose :
+//=======================================================================
+void TDataXtd_Presentation::SetSelectionMode(const Standard_Integer theSelectionMode)
+{
+ Backup();
+ myIsHasOwnSelectionMode = Standard_True;
+ mySelectionMode = theSelectionMode;
+}
+
+
+//=======================================================================
+//function : Material
+//purpose :
+//=======================================================================
+Standard_Integer TDataXtd_Presentation::Material() const
+{
+ return myMaterial;
+}
+
+
+//=======================================================================
+//function : Transparency
+//purpose :
+//=======================================================================
+Standard_Real TDataXtd_Presentation::Transparency() const
+{
+ return myTransparency;
+}
+
+
+//=======================================================================
+//function : Color
+//purpose :
+//=======================================================================
+Standard_Integer TDataXtd_Presentation::Color() const
+{
+ return myColor;
+}
+
+
+//=======================================================================
+//function : Width
+//purpose :
+//=======================================================================
+Standard_Real TDataXtd_Presentation::Width() const
+{
+ return myWidth;
+}
+
+
+//=======================================================================
+//function : Mode
+//purpose :
+//=======================================================================
+Standard_Integer TDataXtd_Presentation::Mode() const
+{
+ return myMode;
+}
+
+
+//=======================================================================
+//function : SelectionMode
+//purpose :
+//=======================================================================
+Standard_Integer TDataXtd_Presentation::SelectionMode() const
+{
+ return mySelectionMode;
+}
+
+
+//=======================================================================
+//function : UnsetMaterial
+//purpose :
+//=======================================================================
+void TDataXtd_Presentation::UnsetMaterial()
+{
+ Backup();
+ myIsHasOwnMaterial = Standard_False;
+}
+
+
+//=======================================================================
+//function : UnsetTransparency
+//purpose :
+//=======================================================================
+void TDataXtd_Presentation::UnsetTransparency()
+{
+ myIsHasOwnTransparency = Standard_False;
+}
+
+
+//=======================================================================
+//function : UnsetColor
+//purpose :
+//=======================================================================
+void TDataXtd_Presentation::UnsetColor()
+{
+ Backup();
+ myIsHasOwnColor = Standard_False;
+}
+
+
+//=======================================================================
+//function : UnsetWidth
+//purpose :
+//=======================================================================
+void TDataXtd_Presentation::UnsetWidth()
+{
+ Backup();
+ myIsHasOwnWidth = Standard_False;
+}
+
+
+//=======================================================================
+//function : UnsetMode
+//purpose :
+//=======================================================================
+void TDataXtd_Presentation::UnsetMode()
+{
+ Backup();
+ myIsHasOwnMode = Standard_False;
+}
+
+
+//=======================================================================
+//function : UnsetSelectionMode
+//purpose :
+//=======================================================================
+void TDataXtd_Presentation::UnsetSelectionMode()
+{
+ Backup();
+ myIsHasOwnSelectionMode = Standard_False;
+}
+
+
+//=======================================================================
+//function : BackupCopy
+//purpose :
+//=======================================================================
+Handle(TDF_Attribute) TDataXtd_Presentation::BackupCopy() const
+{
+ Handle(TDataXtd_Presentation) aCopy = new TDataXtd_Presentation;
+
+ aCopy->myIsDisplayed = myIsDisplayed;
+ aCopy->myDriverGUID = myDriverGUID;
+ aCopy->mySelectionMode = mySelectionMode;
+ aCopy->myTransparency = myTransparency;
+ aCopy->myColor = myColor;
+ aCopy->myMode = myMode;
+ aCopy->myWidth = myWidth;
+ aCopy->myMaterial = myMaterial;
+
+ aCopy->myIsHasOwnColor = myIsHasOwnColor;
+ aCopy->myIsHasOwnMaterial = myIsHasOwnMaterial;
+ aCopy->myIsHasOwnWidth = myIsHasOwnWidth;
+ aCopy->myIsHasOwnMode = myIsHasOwnMode;
+ aCopy->myIsHasOwnTransparency = myIsHasOwnTransparency;
+ aCopy->myIsHasOwnSelectionMode = myIsHasOwnSelectionMode;
+
+ return aCopy;
+}
+
+
+//=======================================================================
+//function : NewEmpty
+//purpose :
+//=======================================================================
+Handle(TDF_Attribute) TDataXtd_Presentation::NewEmpty() const
+{
+ return new TDataXtd_Presentation();
+}
+
+
+//=======================================================================
+//function : Restore
+//purpose :
+//=======================================================================
+void TDataXtd_Presentation::Restore(const Handle(TDF_Attribute)& theAttribute)
+{
+ Handle(TDataXtd_Presentation) aPresentation =
+ Handle(TDataXtd_Presentation)::DownCast(theAttribute);
+
+ myIsHasOwnMaterial = aPresentation->IsHasOwnMaterial();
+ myMaterial = aPresentation->Material();
+
+ myIsHasOwnColor = aPresentation->IsHasOwnColor();
+ myColor = aPresentation->Color();
+
+ myIsHasOwnWidth = aPresentation->IsHasOwnWidth();
+ myWidth = aPresentation->Width();
+
+ myIsHasOwnMode = aPresentation->IsHasOwnMode();
+ myMode = aPresentation->Mode();
+
+ myIsHasOwnSelectionMode = aPresentation->IsHasOwnSelectionMode();
+ mySelectionMode = aPresentation->SelectionMode();
+
+ myIsHasOwnTransparency = aPresentation->IsHasOwnTransparency();
+ myTransparency = aPresentation->Transparency();
+
+ myIsDisplayed = aPresentation->IsDisplayed();
+ myDriverGUID = aPresentation->GetDriverGUID();
+}
+
+
+//=======================================================================
+//function : Paste
+//purpose :
+//=======================================================================
+void TDataXtd_Presentation::Paste(const Handle(TDF_Attribute)& theInto,
+ const Handle(TDF_RelocationTable)&) const
+{
+ Handle(TDataXtd_Presentation) anInto =
+ Handle(TDataXtd_Presentation)::DownCast(theInto);
+
+ anInto->Backup();
+
+ if (myIsHasOwnMaterial)
+ {
+ anInto->myMaterial = myMaterial;
+ anInto->myIsHasOwnMaterial = Standard_True;
+ }
+ else
+ {
+ anInto->myIsHasOwnMaterial = Standard_False;
+ }
+
+ if (myIsHasOwnColor)
+ {
+ anInto->myColor = myColor;
+ anInto->myIsHasOwnColor = Standard_True;
+ }
+ else
+ {
+ anInto->myIsHasOwnColor = Standard_False;
+ }
+
+ if(myIsHasOwnWidth)
+ {
+ anInto->myWidth = myWidth;
+ anInto->myIsHasOwnWidth = Standard_True;
+ }
+ else
+ {
+ anInto->myIsHasOwnWidth = Standard_False;
+ }
+
+ if (myIsHasOwnMode)
+ {
+ anInto->myMode = myMode;
+ anInto->myIsHasOwnMode = Standard_True;
+ }
+ else
+ {
+ anInto->myIsHasOwnMode = Standard_False;
+ }
+
+ if (myIsHasOwnSelectionMode)
+ {
+ anInto->mySelectionMode = mySelectionMode;
+ anInto->myIsHasOwnSelectionMode = Standard_True;
+ }
+ else
+ {
+ anInto->myIsHasOwnSelectionMode = Standard_False;
+ }
+
+ if (myIsHasOwnTransparency)
+ {
+ anInto->myTransparency = myTransparency;
+ anInto->myIsHasOwnTransparency = Standard_True;
+ }
+ else
+ {
+ anInto->myIsHasOwnTransparency = Standard_False;
+ }
+
+ anInto->myIsDisplayed = myIsDisplayed;
+ anInto->myDriverGUID = myDriverGUID;
+}
#include <Standard_ErrorHandler.hxx>
#include <Standard_NoSuchObject.hxx>
#include <Standard_NotImplemented.hxx>
-#include <Standard_Type.hxx>
-#include <TCollection_ExtendedString.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 <TDocStd_Application.hxx>
#include <TDocStd_Document.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)& D,const TCollection_ExtendedString& path) {
- TDocStd_PathParser tool (path);
- TCollection_ExtendedString directory = tool.Trek();
- TCollection_ExtendedString file = tool.Name();
- file+=".";
- file+=tool.Extension();
+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)& theDoc,
+ const TCollection_ExtendedString& thePath,
+ TCollection_ExtendedString& theStatusMessage)
+{
+ Handle(Storage_File) aDevice = new Storage_File( thePath );
+ return SaveAs( theDoc, aDevice, theStatusMessage );
+}
+
+//=======================================================================
+//function : SaveAs
+//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 : SaveAs
+//purpose :
+//=======================================================================
+
+PCDM_StoreStatus TDocStd_Application::SaveAs(const Handle(TDocStd_Document)& theDoc,
+ Standard_OStream& theOStream,
+ TCollection_ExtendedString& theStatusMessage)
+{
+ Handle(Storage_OStream) aDevice = new Storage_OStream( theOStream );
+ return SaveAs( theDoc, aDevice, theStatusMessage );
+}
+
+//=======================================================================
+//function : SaveAs
+//purpose :
+//=======================================================================
+
+PCDM_StoreStatus TDocStd_Application::SaveAs(const Handle(TDocStd_Document)& D,
+ const Handle(Storage_IODevice)& aDevice)
+{
+ TCollection_ExtendedString aStatusMessage;
+ return SaveAs( D, aDevice, aStatusMessage );
+}
+
+//=======================================================================
+//function : SaveAs
+//purpose :
+//=======================================================================
+
+PCDM_StoreStatus TDocStd_Application::SaveAs(const Handle(TDocStd_Document)& D,
+ const Handle(Storage_IODevice)& aDev,
+ TCollection_ExtendedString& theStatusMessage)
+{
+ PCDM_StoreStatus aStatus = PCDM_SS_Failure;
D->Open(this);
- CDF_Store storer (D);
- if (!storer.SetFolder(directory))
- {
- TCollection_ExtendedString aMsg ("TDocStd_Application::SaveAs() - folder ");
- aMsg += directory;
- aMsg += " does not exist";
- if(!MessageDriver().IsNull())
- MessageDriver()->Write(aMsg.ToExtString());
- return storer.StoreStatus(); //CDF_SS_Failure;
- }
- storer.SetName (file);
- try {
- OCC_CATCH_SIGNALS
- storer.Realize();
- }
- catch (Standard_Failure) {
- Handle(Standard_Failure) F = Standard_Failure::Caught();
- if (!F.IsNull() && !MessageDriver().IsNull()) {
- TCollection_ExtendedString aString (F->GetMessageString());
- MessageDriver()->Write(aString.ToExtString());
+ CDF_Store storer (D);
+ if (storer.SetDevice(aDev)) {
+ try {
+ OCC_CATCH_SIGNALS
+ storer.Realize();
+ }
+ catch (Standard_Failure) {
+ Handle(Standard_Failure) F = Standard_Failure::Caught();
+ if (!F.IsNull() && !MessageDriver().IsNull()) {
+ TCollection_ExtendedString aString (F->GetMessageString());
+ MessageDriver()->Write(aString.ToExtString());
+ }
}
+ if(storer.StoreStatus() == PCDM_SS_OK)
+ D->SetSaved();
+ theStatusMessage = storer.AssociatedStatusText();
+ aStatus = storer.StoreStatus();
+ } else {
+ theStatusMessage =
+ TCollection_ExtendedString("TDocStd_Application::SaveAs: No valid device ");
+ aStatus = PCDM_SS_Failure;
}
- if(storer.StoreStatus() == PCDM_SS_OK)
- D->SetSaved();
-#ifdef OCCT_DEBUG
- cout<<"TDocStd_Application::SaveAs(): The status = "<<storer.StoreStatus()<<endl;
-#endif
- return storer.StoreStatus();
+ return aStatus;
}
//=======================================================================
// }
-//=======================================================================
-//function : SaveAs
-//purpose :
-//=======================================================================
-
-PCDM_StoreStatus TDocStd_Application::SaveAs(const Handle(TDocStd_Document)& D,
- const TCollection_ExtendedString& path,
- TCollection_ExtendedString& theStatusMessage)
-{
- TDocStd_PathParser tool (path);
- PCDM_StoreStatus aStatus = PCDM_SS_Failure;
- 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);
- try {
- OCC_CATCH_SIGNALS
- storer.Realize();
- }
- catch (Standard_Failure) {
- Handle(Standard_Failure) F = Standard_Failure::Caught();
- if (!F.IsNull() && !MessageDriver().IsNull()) {
- TCollection_ExtendedString aString (F->GetMessageString());
- MessageDriver()->Write(aString.ToExtString());
- }
- }
- if(storer.StoreStatus() == PCDM_SS_OK)
- D->SetSaved();
- theStatusMessage = storer.AssociatedStatusText();
- aStatus = storer.StoreStatus();
- } else {
- theStatusMessage =
- TCollection_ExtendedString("TDocStd_Application::SaveAs"
- ": No such directory ") + directory;
- aStatus = PCDM_SS_Failure;
- }
- return aStatus;
-}
-
//=======================================================================
//function : Save
//purpose :
#include <TDocStd_XLink.hxx>
#include <TDocStd_XLinkIterator.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 :
TKCAF
TKCDF
TKLCAF
-TKV3d
TKBinL
BinDrivers
BinMDataXtd
-BinMPrsStd
BinMNaming
TKBRep
TKTopAlgo
TKMath
-TKService
TKG2d
TKG3d
TKCDF
TKLCAF
-TKV3d
TKBO
TDataXtd
TNaming
-TPrsStd
AppStd
TKBool
TKBO
TKCAF
+TKVCAF
TKViewerTest
TKOffset
TKFeat
TKCAF
+TKVCAF
TKIGES
TKXSBase
TKMesh
--- /dev/null
+TKernel
+TKGeomBase
+TKBRep
+TKTopAlgo
+TKMath
+TKService
+TKG2d
+TKG3d
+TKCDF
+TKLCAF
+TKBO
+TKCAF
+TKV3d
--- /dev/null
+EXTERNLIB
+PACKAGES
TKG3d
TKMesh
TKHLR
-TKService
TKGeomAlgo
-TKV3d
TKBRep
TKernel
TKMath
-TKService
TKG2d
TKTopAlgo
-TKV3d
TKCDF
TKLCAF
TKG3d
TKCAF
+
TKXSBase
TKG2d
TKCAF
+TKVCAF
TKDraw
TKTopAlgo
TKLCAF
TKCDF
TKernel
-TKV3d
TKMath
TKBRep
TKG2d
XmlDrivers
XmlMDataXtd
XmlMNaming
-XmlMPrsStd
00000000-0000-0000-0000-000000000000 Reserved
ffffffff-ffff-ffff-ffff-ffffffffffff Reserved
-04fb4d00-5690-11d1-8940-080009dc3333 TPrsStd_AISPresentation
+3680ac6c-47ae-4366-bb94-26abb6e07341 TPrsStd_AISPresentation
04fb4d01-5690-11d1-8940-080009dc3333 TPrsStd_ColorAttribute
04fb4d02-5690-11d1-8940-080009dc3333 TPrsStd_TransparencyAttribute
04fb4d04-5690-11d1-8940-080009dc3333 TPrsStd_GraphicAttribute
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-// Lastly modified by :
-// +---------------------------------------------------------------------------+
-// ! ivan ! SetMode ! 5-04-2001! 3.0-00-1!
-// +---------------------------------------------------------------------------+
#include <AIS_InteractiveContext.hxx>
#include <AIS_InteractiveObject.hxx>
#include <TPrsStd_AISPresentation.hxx>
#include <TColStd_ListOfInteger.hxx>
#include <TColStd_ListIteratorOfListOfInteger.hxx>
+#include <TDataXtd_Presentation.hxx>
#include <TPrsStd_AISViewer.hxx>
#include <TPrsStd_Driver.hxx>
#include <TPrsStd_DriverTable.hxx>
+
+//=======================================================================
+//function : TPrsStd_AISPresentation
+//purpose : Constructor
+//=======================================================================
+TPrsStd_AISPresentation::TPrsStd_AISPresentation ()
+: myDriverGUID("00000000-0000-0000-0000-000000000000")
+{
+}
+
+
//=======================================================================
//function : Set
//purpose :
//=======================================================================
-Handle(TPrsStd_AISPresentation) TPrsStd_AISPresentation::Set(const TDF_Label& L,const Standard_GUID& driver)
-{
-
- Handle(TPrsStd_AISPresentation) P;
+Handle(TPrsStd_AISPresentation) TPrsStd_AISPresentation::Set
+ ( const TDF_Label& theLabel, const Standard_GUID& theDriver )
+{
+ Handle(TPrsStd_AISPresentation) aPresentation;
- if (!L.FindAttribute(TPrsStd_AISPresentation::GetID(),P)) {
- P = new TPrsStd_AISPresentation ();
- L.AddAttribute(P);
+ if ( !theLabel.FindAttribute(TPrsStd_AISPresentation::GetID(), aPresentation) )
+ {
+ aPresentation = new TPrsStd_AISPresentation();
+ theLabel.AddAttribute(aPresentation);
}
- P->SetDriverGUID(driver);
- return P;
+
+ aPresentation->SetDriverGUID(theDriver);
+ return aPresentation;
}
//function : Unset
//purpose :
//=======================================================================
-void TPrsStd_AISPresentation::Unset (const TDF_Label& L)
-{
- Handle(TPrsStd_AISPresentation) P;
+void TPrsStd_AISPresentation::Unset (const TDF_Label& theLabel)
+{
+ Handle(TPrsStd_AISPresentation) aPresentation;
- if (L.FindAttribute(TPrsStd_AISPresentation::GetID(),P)) {
- L.ForgetAttribute(P);
- }
+ if ( theLabel.FindAttribute(TPrsStd_AISPresentation::GetID(), aPresentation) )
+ theLabel.ForgetAttribute(aPresentation);
}
//function : Set
//purpose :
//=======================================================================
-Handle(TPrsStd_AISPresentation) TPrsStd_AISPresentation::Set (const Handle(TDF_Attribute)& master)
-{
- Handle(TPrsStd_AISPresentation) P;
-
- if (!master->Label().FindAttribute(TPrsStd_AISPresentation::GetID(),P)) {
- P = new TPrsStd_AISPresentation ();
- master->Label().AddAttribute(P);
- }
-
- P->SetDriverGUID( master->ID() );
+Handle(TPrsStd_AISPresentation) TPrsStd_AISPresentation::Set(const Handle(TDF_Attribute)& theMaster)
+{
+ Handle(TPrsStd_AISPresentation) aPresentation;
+ if ( !theMaster->Label().FindAttribute(TPrsStd_AISPresentation::GetID(), aPresentation) )
+ {
+ aPresentation = new TPrsStd_AISPresentation ();
+ theMaster->Label().AddAttribute(aPresentation);
+ }
- return P;
+ aPresentation->SetDriverGUID( theMaster->ID() );
+ return aPresentation;
}
-
-
//=======================================================================
//function : GetID
//purpose :
//=======================================================================
-const Standard_GUID& TPrsStd_AISPresentation::GetID()
+const Standard_GUID& TPrsStd_AISPresentation::GetID()
{
- static Standard_GUID TPrsStd_AISPresentationID("04fb4d00-5690-11d1-8940-080009dc3333");
+ static Standard_GUID TPrsStd_AISPresentationID("3680ac6c-47ae-4366-bb94-26abb6e07341");
return TPrsStd_AISPresentationID;
}
-//=======================================================================
-//function : TPrsStd_AISPresentation
-//purpose :
-//=======================================================================
-TPrsStd_AISPresentation::TPrsStd_AISPresentation () :
-myDriverGUID("00000000-0000-0000-0000-000000000000"),
-myTransparency(0.),
-myColor(Quantity_NOC_WHITE),
-myMaterial(Graphic3d_NOM_BRASS),
-myWidth(0.),
-myMode(0),
-mySelectionMode(0),
-isDisplayed(Standard_False),
-hasOwnColor(Standard_False),
-hasOwnMaterial(Standard_False),
-hasOwnTransparency(Standard_False),
-hasOwnWidth(Standard_False),
-hasOwnMode(Standard_False),
-hasOwnSelectionMode(Standard_False)
-{}
-
-
//=======================================================================
//function : Display
//purpose :
//=======================================================================
-void TPrsStd_AISPresentation::Display (const Standard_Boolean update)
+void TPrsStd_AISPresentation::Display(const Standard_Boolean theIsUpdate)
{
-
- if( update || myAIS.IsNull() ) {
+ if ( theIsUpdate || myAIS.IsNull() )
AISUpdate();
- }
- AISDisplay();
+
+ AISDisplay();
}
//function : Erase
//purpose :
//=======================================================================
-void TPrsStd_AISPresentation::Erase (const Standard_Boolean remove)
-{
- if( isDisplayed ) AISErase(remove);
+void TPrsStd_AISPresentation::Erase(const Standard_Boolean theIsRemove)
+{
+ Handle(TDataXtd_Presentation) aPresentation;
+ if ( FindAttribute(TDataXtd_Presentation::GetID(), aPresentation) )
+ {
+ if ( aPresentation.IsNull() == Standard_False && aPresentation->IsDisplayed() )
+ AISErase(theIsRemove);
+ }
}
+
//=======================================================================
//function : Update
//purpose :
//=======================================================================
-void TPrsStd_AISPresentation::Update ()
-{
+void TPrsStd_AISPresentation::Update()
+{
AISUpdate();
}
//function : IsDisplayed
//purpose :
//=======================================================================
-Standard_Boolean TPrsStd_AISPresentation::IsDisplayed () const
+Standard_Boolean TPrsStd_AISPresentation::IsDisplayed() const
{
- return isDisplayed;
+ Handle(TDataXtd_Presentation) aPresentation;
+ if ( FindAttribute(TDataXtd_Presentation::GetID(), aPresentation) )
+ return aPresentation->IsDisplayed();
+
+ return Standard_False;
+}
+
+
+//=======================================================================
+//function : SetDisplayed
+//purpose :
+//=======================================================================
+void TPrsStd_AISPresentation::SetDisplayed(const Standard_Boolean theIsDisplayed)
+{
+ Handle(TDataXtd_Presentation) aPresentation = getData();
+ return aPresentation->SetDisplayed(theIsDisplayed);
}
//function :SetDriverGUID
//purpose :
//=======================================================================
-void TPrsStd_AISPresentation::SetDriverGUID(const Standard_GUID& guid)
+void TPrsStd_AISPresentation::SetDriverGUID(const Standard_GUID& theGUID)
{
- // OCC2932 correction
- if(myDriverGUID == guid) return;
+ if ( myDriverGUID == theGUID )
+ return;
- Backup();
- myDriverGUID = guid;
+ Backup();
+ myDriverGUID = theGUID;
}
//=======================================================================
Graphic3d_NameOfMaterial TPrsStd_AISPresentation::Material() const
{
- return myMaterial;
+ Handle(TDataXtd_Presentation) aPresentation;
+ if ( FindAttribute(TDataXtd_Presentation::GetID(), aPresentation) )
+ return static_cast<Graphic3d_NameOfMaterial>( aPresentation->Material() );
+
+ return Graphic3d_NOM_BRASS;
}
+
//=======================================================================
//function :HasMaterial
//purpose :
//=======================================================================
Standard_Boolean TPrsStd_AISPresentation::HasOwnMaterial() const
{
- return hasOwnMaterial;
+ Handle(TDataXtd_Presentation) aPresentation;
+ if ( FindAttribute(TDataXtd_Presentation::GetID(), aPresentation) )
+ return aPresentation->IsHasOwnMaterial();
+
+ return Standard_False;
}
+
//=======================================================================
-//function :UnsetMaterial
+//function : UnsetMaterial
//purpose :
//=======================================================================
void TPrsStd_AISPresentation::UnsetMaterial()
{
- // OCC2932 correction
- if(hasOwnMaterial == Standard_False && !myAIS.IsNull()) {
- if(!myAIS->HasMaterial())
- return;
- }
-
- Backup();
- hasOwnMaterial = Standard_False;
- if( myAIS.IsNull() ) AISUpdate();
- if( !myAIS.IsNull() && myAIS->HasMaterial() ) {
- Handle(AIS_InteractiveContext) ctx;
- Handle(TPrsStd_AISViewer) viewer;
- if( TPrsStd_AISViewer::Find(Label(), viewer) ) ctx = viewer->GetInteractiveContext();
- if( !ctx.IsNull() )
- ctx->UnsetMaterial(myAIS, Standard_False);
- else
+ Handle(TDataXtd_Presentation) aPresentation;
+ if ( !FindAttribute(TDataXtd_Presentation::GetID(), aPresentation) )
+ return;
+
+ if ( !aPresentation->IsHasOwnMaterial() )
+ if( !myAIS.IsNull() && !myAIS->HasMaterial() )
+ return;
+
+ aPresentation->UnsetMaterial();
+
+ if ( myAIS.IsNull() )
+ AISUpdate();
+
+ if ( !myAIS.IsNull() && myAIS->HasMaterial() )
+ {
+ Handle(AIS_InteractiveContext) aContext = getAISContext();
+
+ if ( !aContext.IsNull() )
+ aContext->UnsetMaterial(myAIS, Standard_False);
+ else
myAIS->UnsetMaterial();
}
}
+
//=======================================================================
-//function :SetMaterial
+//function : SetMaterial
//purpose :
//=======================================================================
-void TPrsStd_AISPresentation::SetMaterial(const Graphic3d_NameOfMaterial aName)
+void TPrsStd_AISPresentation::SetMaterial(const Graphic3d_NameOfMaterial theName)
{
- // OCC2932 correction
- if(myMaterial == aName && hasOwnMaterial == Standard_True && !myAIS.IsNull()) {
- if(myAIS->HasMaterial() && myAIS->Material() == aName)
- return;
- }
+ const Standard_Integer aName = static_cast<Standard_Integer>(theName);
- Backup();
- myMaterial = aName;
- hasOwnMaterial = Standard_True;
- if( myAIS.IsNull() ) AISUpdate();
- if( !myAIS.IsNull() ) {
- if( myAIS->HasMaterial() && myAIS->Material() == aName ) return; // AIS has already had that material
- Handle(AIS_InteractiveContext) ctx;
- Handle(TPrsStd_AISViewer) viewer;
- if( TPrsStd_AISViewer::Find(Label(), viewer) ) ctx = viewer->GetInteractiveContext();
- if( !ctx.IsNull() )
- ctx->SetMaterial(myAIS, aName, Standard_False);
- else
- myAIS->SetMaterial(aName);
+ Handle(TDataXtd_Presentation) aPresentation = getData();
+
+ if ( aPresentation->IsHasOwnMode() && aPresentation->Material() == aName )
+ if ( !myAIS.IsNull() && myAIS->HasMaterial() && myAIS->Material() == theName )
+ return;
+
+ aPresentation->SetMaterial(aName);
+
+ if ( myAIS.IsNull() )
+ AISUpdate();
+
+ if ( !myAIS.IsNull() )
+ {
+ if ( myAIS->HasMaterial() && myAIS->Material() == theName )
+ return; // AIS has already had that material
+
+ Handle(AIS_InteractiveContext) aContext = getAISContext();
+
+ if ( !aContext.IsNull() )
+ aContext->SetMaterial(myAIS, theName, Standard_False);
+ else
+ myAIS->SetMaterial(theName);
}
}
//=======================================================================
-//function :SetTransparency
+//function :Transparency
//purpose :
//=======================================================================
-void TPrsStd_AISPresentation::SetTransparency(const Standard_Real aValue)
+Standard_Real TPrsStd_AISPresentation::Transparency() const
{
- // OCC2932 correction
- if(hasOwnTransparency == Standard_True && myTransparency == aValue && !myAIS.IsNull())
- if(myAIS->Transparency() == aValue)
- return;
+ Handle(TDataXtd_Presentation) aPresentation;
+ if ( FindAttribute(TDataXtd_Presentation::GetID(), aPresentation) )
+ return aPresentation->Transparency();
- Backup();
- myTransparency = aValue;
- hasOwnTransparency = Standard_True;
- if( myAIS.IsNull() ) AISUpdate();
- if( !myAIS.IsNull() ) {
- if( myAIS->Transparency() == aValue ) return; // AIS has already had that transparency
- Handle(AIS_InteractiveContext) ctx;
- Handle(TPrsStd_AISViewer) viewer;
- if( TPrsStd_AISViewer::Find(Label(), viewer) ) ctx = viewer->GetInteractiveContext();
- if( !ctx.IsNull() )
- ctx->SetTransparency(myAIS, aValue, Standard_False);
- else
- myAIS->SetTransparency(aValue);
- }
+ return 0.0;
}
//=======================================================================
-//function :Transparency
+//function :SetTransparency
//purpose :
//=======================================================================
-Standard_Real TPrsStd_AISPresentation::Transparency() const
+void TPrsStd_AISPresentation::SetTransparency(const Standard_Real theValue)
{
- return myTransparency;
+ Handle(TDataXtd_Presentation) aPresentation = getData();
+
+ if( aPresentation->IsHasOwnTransparency() && aPresentation->Transparency() == theValue )
+ if ( !myAIS.IsNull() && myAIS->Transparency() == theValue )
+ return;
+
+ aPresentation->SetTransparency(theValue);
+
+ if ( myAIS.IsNull() )
+ AISUpdate();
+
+ if ( !myAIS.IsNull() )
+ {
+ if ( myAIS->Transparency() == theValue )
+ return; // AIS has already had that transparency
+
+ Handle(AIS_InteractiveContext) aContext = getAISContext();
+
+ if ( !aContext.IsNull() )
+ aContext->SetTransparency(myAIS, theValue, Standard_False);
+ else
+ myAIS->SetTransparency(theValue);
+ }
}
+
//=======================================================================
//function :UnsetTransparency
//purpose :
//=======================================================================
void TPrsStd_AISPresentation::UnsetTransparency()
{
- // OCC2932 correction
- if(!hasOwnTransparency)
- return;
+ Handle(TDataXtd_Presentation) aPresentation;
+ if ( FindAttribute(TDataXtd_Presentation::GetID(), aPresentation) )
+ {
+ if ( !aPresentation->IsHasOwnTransparency() )
+ return;
- Backup();
- hasOwnTransparency = Standard_False;
- if( myAIS.IsNull() ) AISUpdate();
- if( !myAIS.IsNull() ) {
- Handle(AIS_InteractiveContext) ctx;
- Handle(TPrsStd_AISViewer) viewer;
- if( TPrsStd_AISViewer::Find(Label(), viewer) ) ctx = viewer->GetInteractiveContext();
- if( !ctx.IsNull() )
- ctx->UnsetTransparency(myAIS, Standard_False);
- else
+ aPresentation->UnsetTransparency();
+ }
+
+ if ( myAIS.IsNull() )
+ AISUpdate();
+
+ if ( !myAIS.IsNull() )
+ {
+ Handle(AIS_InteractiveContext) aContext = getAISContext();
+
+ if( !aContext.IsNull() )
+ aContext->UnsetTransparency(myAIS, Standard_False);
+ else
myAIS->UnsetTransparency();
}
}
+
//=======================================================================
-//function :HasTransparency
+//function : HasTransparency
//purpose :
//=======================================================================
Standard_Boolean TPrsStd_AISPresentation::HasOwnTransparency() const
{
- return hasOwnTransparency;
+ Handle(TDataXtd_Presentation) aPresentation;
+ if ( FindAttribute(TDataXtd_Presentation::GetID(), aPresentation) )
+ return aPresentation->IsHasOwnTransparency();
+
+ return Standard_False;
}
+
//=======================================================================
-//function :Color
+//function : Color
//purpose :
//=======================================================================
Quantity_NameOfColor TPrsStd_AISPresentation::Color() const
{
- return myColor;
+ Handle(TDataXtd_Presentation) aPresentation;
+ if ( FindAttribute(TDataXtd_Presentation::GetID(), aPresentation) )
+ return static_cast<Quantity_NameOfColor>(aPresentation->Color());
+
+ return Quantity_NOC_WHITE;
}
//=======================================================================
-//function :HasColor
+//function : HasOwnColor
//purpose :
//=======================================================================
Standard_Boolean TPrsStd_AISPresentation::HasOwnColor() const
{
- return hasOwnColor;
+ Handle(TDataXtd_Presentation) aPresentation;
+ if ( FindAttribute(TDataXtd_Presentation::GetID(), aPresentation) )
+ return aPresentation->IsHasOwnColor();
+
+ return Standard_False;
}
+
//=======================================================================
-//function :UnsetColor
+//function : UnsetColor
//purpose :
//=======================================================================
void TPrsStd_AISPresentation::UnsetColor()
{
- // OCC2932 correction
- if(!hasOwnColor && !myAIS.IsNull())
- if(!myAIS->HasColor())
- return;
-
- Backup();
- hasOwnColor = Standard_False;
- if( myAIS.IsNull() ) AISUpdate();
- if( !myAIS.IsNull() && myAIS->HasColor() ) {
- Handle(AIS_InteractiveContext) ctx;
- Handle(TPrsStd_AISViewer) viewer;
- if( TPrsStd_AISViewer::Find(Label(), viewer) ) ctx = viewer->GetInteractiveContext();
- if( !ctx.IsNull() )
- ctx->UnsetColor(myAIS, Standard_False);
- else
+ Handle(TDataXtd_Presentation) aPresentation;
+ if ( FindAttribute(TDataXtd_Presentation::GetID(), aPresentation) )
+ {
+ if ( aPresentation->IsHasOwnColor() )
+ if ( !myAIS.IsNull() && !myAIS->HasColor() )
+ return;
+
+ aPresentation->UnsetColor();
+ }
+
+ if ( myAIS.IsNull() )
+ AISUpdate();
+
+ if ( !myAIS.IsNull() && myAIS->HasColor() )
+ {
+ Handle(AIS_InteractiveContext) aContext = getAISContext();
+
+ if ( !aContext.IsNull() )
+ aContext->UnsetColor(myAIS, Standard_False);
+ else
myAIS->UnsetColor();
}
}
+
//=======================================================================
-//function :SetColor
+//function : SetColor
//purpose :
//=======================================================================
-void TPrsStd_AISPresentation::SetColor(const Quantity_NameOfColor aColor)
+void TPrsStd_AISPresentation::SetColor(const Quantity_NameOfColor theColor)
{
- // OCC2932 correction
- if(hasOwnColor && myColor == aColor && ! myAIS.IsNull())
- if(myAIS->HasColor() && myAIS->Color() == aColor )
+ Handle(TDataXtd_Presentation) aPresentation = getData();
+
+ const Standard_Integer aColor = static_cast<Standard_Integer>(theColor);
+ if ( aPresentation->IsHasOwnColor() && aPresentation->Color() == aColor )
+ if ( !myAIS.IsNull() && myAIS->HasColor() && myAIS->Color() == theColor )
return;
-
- Backup();
- myColor = aColor;
- hasOwnColor = Standard_True;
- if( myAIS.IsNull() ) AISUpdate();
- if( !myAIS.IsNull() ) {
- if( myAIS->HasColor() && myAIS->Color() == aColor ) return; // AIS has already had that color
- Handle(AIS_InteractiveContext) ctx;
- Handle(TPrsStd_AISViewer) viewer;
- if( TPrsStd_AISViewer::Find(Label(), viewer) ) ctx = viewer->GetInteractiveContext();
- if( !ctx.IsNull() )
- ctx->SetColor(myAIS, aColor, Standard_False);
+
+ aPresentation->SetColor(aColor);
+
+ if ( myAIS.IsNull() )
+ AISUpdate();
+
+ if ( !myAIS.IsNull() )
+ {
+ if ( myAIS->HasColor() && myAIS->Color() == theColor )
+ return; // AIS has already had that color
+
+ Handle(AIS_InteractiveContext) aContext = getAISContext();
+
+ if( !aContext.IsNull() )
+ aContext->SetColor(myAIS, theColor, Standard_False);
else
- myAIS->SetColor(aColor);
+ myAIS->SetColor(theColor);
}
}
//=======================================================================
Standard_Real TPrsStd_AISPresentation::Width() const
{
- return myWidth;
+ Handle(TDataXtd_Presentation) aPresentation;
+ if ( FindAttribute(TDataXtd_Presentation::GetID(), aPresentation) )
+ return aPresentation->Width();
+
+ return 0.0;
}
+
//=======================================================================
-//function :HasWidth
+//function : HasWidth
//purpose :
//=======================================================================
Standard_Boolean TPrsStd_AISPresentation::HasOwnWidth() const
{
- return hasOwnWidth;
+ Handle(TDataXtd_Presentation) aPresentation;
+ if ( FindAttribute(TDataXtd_Presentation::GetID(), aPresentation) )
+ return aPresentation->IsHasOwnWidth();
+
+ return Standard_False;
}
+
//=======================================================================
-//function :SetWidth
+//function : SetWidth
//purpose :
//=======================================================================
-void TPrsStd_AISPresentation::SetWidth(const Standard_Real aWidth)
+void TPrsStd_AISPresentation::SetWidth(const Standard_Real theWidth)
{
- // OCC2932 correction
- if(hasOwnWidth && myWidth == aWidth && myAIS.IsNull())
- if(myAIS->HasWidth() && myAIS->Width() == aWidth )
+ Handle(TDataXtd_Presentation) aPresentation = getData();
+
+ if ( aPresentation->IsHasOwnWidth() && aPresentation->Width() == theWidth )
+ if ( !myAIS.IsNull() && myAIS->HasWidth() && myAIS->Width() == theWidth )
return;
- Backup();
- myWidth = aWidth;
- hasOwnWidth = Standard_True;
- if( myAIS.IsNull() ) AISUpdate();
- if( !myAIS.IsNull() ) {
- if( myAIS->HasWidth() && myAIS->Width() == aWidth ) return; // AIS has already had that width
- Handle(AIS_InteractiveContext) ctx;
- Handle(TPrsStd_AISViewer) viewer;
- if( TPrsStd_AISViewer::Find(Label(), viewer) ) ctx = viewer->GetInteractiveContext();
- if( !ctx.IsNull() )
- ctx->SetWidth(myAIS, aWidth, Standard_False);
+ aPresentation->SetWidth(theWidth);
+
+ if( !myAIS.IsNull() )
+ {
+ if ( myAIS->HasWidth() && myAIS->Width() == theWidth )
+ return; // AIS has already had that width
+
+ Handle(AIS_InteractiveContext) aContext = getAISContext();
+
+ if( !aContext.IsNull() )
+ aContext->SetWidth(myAIS, theWidth, Standard_False);
else
- myAIS->SetWidth(aWidth);
+ myAIS->SetWidth(theWidth);
}
}
+
//=======================================================================
-//function :UnsetWidth
+//function : UnsetWidth
//purpose :
//=======================================================================
void TPrsStd_AISPresentation::UnsetWidth()
{
- // OCC2932 correction
- if(!hasOwnWidth && !myAIS.IsNull())
- if(!myAIS->HasWidth())
+ Handle(TDataXtd_Presentation) aPresentation;
+ if ( !FindAttribute(TDataXtd_Presentation::GetID(), aPresentation) )
+ {
+ // create new
+ return;
+ }
+
+ if ( !aPresentation->IsHasOwnWidth() )
+ if ( !myAIS.IsNull() && !myAIS->HasWidth() )
return;
- Backup();
- hasOwnWidth = Standard_False;
- if( myAIS.IsNull() ) AISUpdate();
- if( !myAIS.IsNull() && myAIS->HasWidth() ) {
- Handle(AIS_InteractiveContext) ctx;
- Handle(TPrsStd_AISViewer) viewer;
- if( TPrsStd_AISViewer::Find(Label(), viewer) ) ctx = viewer->GetInteractiveContext();
- if( !ctx.IsNull() )
- ctx->UnsetWidth(myAIS, Standard_False);
- else
+ aPresentation->UnsetWidth();
+
+ if( myAIS.IsNull() )
+ AISUpdate();
+
+ if ( !myAIS.IsNull() && myAIS->HasWidth() )
+ {
+ Handle(AIS_InteractiveContext) aContext = getAISContext();
+
+ if ( !aContext.IsNull() )
+ aContext->UnsetWidth(myAIS, Standard_False);
+ else
myAIS->UnsetWidth();
}
}
-
//=======================================================================
//function : Mode
//purpose :
//=======================================================================
-
Standard_Integer TPrsStd_AISPresentation::Mode() const
{
- return myMode;
+ Handle(TDataXtd_Presentation) aPresentation;
+ if ( FindAttribute(TDataXtd_Presentation::GetID(), aPresentation) )
+ return aPresentation->Mode();
+
+ return 0;
}
+
//=======================================================================
-//function :HasOwnMode
+//function : HasOwnMode
//purpose :
//=======================================================================
Standard_Boolean TPrsStd_AISPresentation::HasOwnMode() const
{
- return hasOwnMode;
+ Handle(TDataXtd_Presentation) aPresentation;
+ if ( FindAttribute(TDataXtd_Presentation::GetID(), aPresentation) )
+ return aPresentation->IsHasOwnMode();
+
+ return Standard_False;
}
+
//=======================================================================
-//function :SetMode
+//function : SetMode
//purpose :
//=======================================================================
-void TPrsStd_AISPresentation::SetMode(const Standard_Integer theMode)
+void TPrsStd_AISPresentation::SetMode(const Standard_Integer theMode)
{
- // OCC2932 correction
- if(hasOwnMode && myMode == theMode && !myAIS.IsNull())
- if(myAIS->DisplayMode() == theMode )
+ Handle(TDataXtd_Presentation) aPresentation = getData();
+
+ if ( aPresentation->IsHasOwnMode() && aPresentation->Mode() == theMode )
+ if ( !myAIS.IsNull() && myAIS->DisplayMode() == theMode )
return;
- Backup();
- myMode = theMode;
- hasOwnMode = Standard_True;
- if( myAIS.IsNull() ) AISUpdate();
- if( !myAIS.IsNull() ) {
- if( myAIS->DisplayMode() == theMode ) return; // AIS has already had that mode
- Handle(AIS_InteractiveContext) ctx;
- Handle(TPrsStd_AISViewer) viewer;
- if( TPrsStd_AISViewer::Find(Label(), viewer) )
- ctx = viewer->GetInteractiveContext();
- if( !ctx.IsNull() )
- ctx->SetDisplayMode(myAIS, theMode, Standard_False);
+ aPresentation->SetMode(theMode);
+
+ if ( myAIS.IsNull() )
+ AISUpdate();
+
+ if ( !myAIS.IsNull() )
+ {
+ if ( myAIS->DisplayMode() == theMode )
+ return; // AIS has already had that mode
+
+ Handle(AIS_InteractiveContext) aContext = getAISContext();
+
+ if( !aContext.IsNull() )
+ aContext->SetDisplayMode(myAIS, theMode, Standard_False);
else
myAIS->SetDisplayMode(theMode);
}
}
+
//=======================================================================
-//function :UnsetMode
+//function : UnsetMode
//purpose :
//=======================================================================
void TPrsStd_AISPresentation::UnsetMode()
{
- // OCC2932 correction
- if(HasOwnMode() == Standard_False && myAIS.IsNull() == Standard_False)
- if(!myAIS->HasDisplayMode())
+ Handle(TDataXtd_Presentation) aPresentation;
+ if ( !FindAttribute(TDataXtd_Presentation::GetID(), aPresentation) )
+ return;
+
+ if ( !aPresentation->IsHasOwnMode() )
+ if ( !myAIS.IsNull() && !myAIS->HasDisplayMode() )
return;
- Backup();
- hasOwnMode = Standard_False;
- if( myAIS.IsNull() ) AISUpdate();
- if( !myAIS.IsNull() && myAIS->HasDisplayMode() ) {
- Handle(AIS_InteractiveContext) ctx;
- Handle(TPrsStd_AISViewer) viewer;
- if( TPrsStd_AISViewer::Find(Label(), viewer) )
- ctx = viewer->GetInteractiveContext();
- if( !ctx.IsNull() )
- ctx->UnsetDisplayMode(myAIS, Standard_False);
- else
- myAIS->UnsetDisplayMode();
+ aPresentation->UnsetMode();
+
+ if ( myAIS.IsNull() )
+ AISUpdate();
+
+ if( !myAIS.IsNull() && myAIS->HasDisplayMode() )
+ {
+ Handle(AIS_InteractiveContext) aContext = getAISContext();
+
+ if ( !aContext.IsNull() )
+ aContext->UnsetDisplayMode(myAIS, Standard_False);
+ else
+ myAIS->UnsetDisplayMode();
}
}
+
//=======================================================================
//function : SelectionMode
//purpose :
//=======================================================================
-
Standard_Integer TPrsStd_AISPresentation::SelectionMode() const
{
- return mySelectionMode;
+ Handle(TDataXtd_Presentation) aPresentation;
+ if ( FindAttribute(TDataXtd_Presentation::GetID(), aPresentation) )
+ return aPresentation->SelectionMode();
+
+ return 0;
}
+
//=======================================================================
-//function :HasOwnSelectionMode
+//function : HasOwnSelectionMode
//purpose :
//=======================================================================
Standard_Boolean TPrsStd_AISPresentation::HasOwnSelectionMode() const
{
- return hasOwnSelectionMode;
+ Handle(TDataXtd_Presentation) aPresentation;
+ if ( FindAttribute(TDataXtd_Presentation::GetID(), aPresentation) )
+ return aPresentation->IsHasOwnSelectionMode();
+
+ return Standard_False;
}
+
//=======================================================================
-//function :SetSelectionMode
+//function : SetSelectionMode
//purpose :
//=======================================================================
-void TPrsStd_AISPresentation::SetSelectionMode(const Standard_Integer theSelectionMode)
+void TPrsStd_AISPresentation::SetSelectionMode(const Standard_Integer theSelectionMode)
{
// OCC2932 correction
if(hasOwnSelectionMode && mySelectionMode == theSelectionMode && !myAIS.IsNull())
return;
+ }
Backup();
mySelectionMode = theSelectionMode;
if( myAIS.IsNull() ) AISUpdate();
}
+
//=======================================================================
-//function :UnsetSelectionMode
+//function : UnsetSelectionMode
//purpose :
//=======================================================================
void TPrsStd_AISPresentation::UnsetSelectionMode()
{
if(!hasOwnSelectionMode && !myAIS.IsNull())
- return;
+ return;
Backup();
hasOwnSelectionMode = Standard_False;
mySelectionMode = myAIS->GlobalSelectionMode();
}
+
//=======================================================================
//function : ID
//purpose :
//=======================================================================
-const Standard_GUID& TPrsStd_AISPresentation::ID() const { return GetID(); }
+const Standard_GUID& TPrsStd_AISPresentation::ID() const
+{
+ return GetID();
+}
//=======================================================================
//=======================================================================
Handle(TDF_Attribute) TPrsStd_AISPresentation::BackupCopy() const
{
- Handle(TPrsStd_AISPresentation) copy = new TPrsStd_AISPresentation;
- copy->myTransparency = myTransparency;
- copy->myColor = myColor;
- copy->myMode= myMode;
- copy->myWidth= myWidth;
- copy->myMaterial = myMaterial;
- copy->hasOwnColor = hasOwnColor;
- copy->hasOwnMaterial = hasOwnMaterial;
- copy->hasOwnWidth = hasOwnWidth;
- copy->hasOwnMode=hasOwnMode;
- copy->hasOwnTransparency = hasOwnTransparency;
- copy->myAIS.Nullify();
- copy->isDisplayed = isDisplayed;
- copy->myDriverGUID = myDriverGUID;
- copy->mySelectionMode= mySelectionMode;
- copy->hasOwnSelectionMode = hasOwnSelectionMode;
- return copy;
+ return new TPrsStd_AISPresentation;
}
//=======================================================================
Handle(TDF_Attribute) TPrsStd_AISPresentation::NewEmpty() const
{
- return new TPrsStd_AISPresentation ();
+ return new TPrsStd_AISPresentation();
}
+
//=======================================================================
-//function : Restore
+//function : Paste
//purpose :
//=======================================================================
-void TPrsStd_AISPresentation::Restore (const Handle(TDF_Attribute)& With)
-{
- Handle(TPrsStd_AISPresentation) with = Handle(TPrsStd_AISPresentation)::DownCast(With);
+void TPrsStd_AISPresentation::Restore(const Handle(TDF_Attribute)& theWith)
+{
+ Handle(TPrsStd_AISPresentation) aWith =
+ Handle(TPrsStd_AISPresentation)::DownCast(theWith);
myAIS.Nullify();
-
- if(!with->HasOwnMaterial()) hasOwnMaterial = Standard_False;
- else {
- hasOwnMaterial = Standard_True;
- }
- myMaterial = with->Material();
-
- if(!with->HasOwnColor()) hasOwnColor = Standard_False;
- else {
- hasOwnColor = Standard_True;
- }
- myColor = with->Color();
-
- if(!with->HasOwnWidth()) hasOwnWidth = Standard_False;
- else {
- hasOwnWidth = Standard_True;
- }
- myWidth = with->Width();
-
- if(!with->HasOwnMode()) hasOwnMode = Standard_False;
- else {
- hasOwnMode = Standard_True;
- }
- myMode = with->Mode();
-
- if(!with->HasOwnSelectionMode()) hasOwnSelectionMode = Standard_False;
- else {
- hasOwnSelectionMode = Standard_True;
- }
- mySelectionMode = with->SelectionMode();
-
- if(!with->HasOwnTransparency()) hasOwnTransparency = Standard_False;
- else {
- hasOwnTransparency = Standard_True;
- }
- myTransparency = with->Transparency();
-
- isDisplayed = with->IsDisplayed();
- myDriverGUID = with->GetDriverGUID();
+ myDriverGUID = aWith->GetDriverGUID();
}
+
//=======================================================================
//function : Paste
//purpose :
//=======================================================================
-void TPrsStd_AISPresentation::Paste (const Handle(TDF_Attribute)& Into,
- const Handle(TDF_RelocationTable)& ) const
-{
- Handle(TPrsStd_AISPresentation) into = Handle(TPrsStd_AISPresentation)::DownCast(Into);
-
- into->Backup();
-
- if(!hasOwnMaterial) into->hasOwnMaterial = Standard_False;
- else {
- into->myMaterial = myMaterial;
- into->hasOwnMaterial = Standard_True;
- }
-
- if(!hasOwnColor) into->hasOwnColor = Standard_False;
- else {
- into->myColor = myColor;
- into->hasOwnColor = Standard_True;
- }
-
- if(!hasOwnWidth) into->hasOwnWidth = Standard_False;
- else {
- into->myWidth = myWidth;
- into->hasOwnWidth = Standard_True;
- }
- if(!hasOwnMode) into->hasOwnMode = Standard_False;
- else {
- into->myMode = myMode;
- into->hasOwnMode = Standard_True;
- }
-
- if(!hasOwnSelectionMode) into->hasOwnSelectionMode = Standard_False;
- else {
- into->mySelectionMode = mySelectionMode;
- into->hasOwnSelectionMode = Standard_True;
- }
-
- if(!hasOwnTransparency) into->hasOwnTransparency = Standard_False;
- else {
- into->myTransparency = myTransparency;
- into->hasOwnTransparency = Standard_True;
- }
-
- if (into->isDisplayed)
- into->AISErase(Standard_True);
-
- into->isDisplayed = isDisplayed;
- into->myDriverGUID = myDriverGUID;
+void TPrsStd_AISPresentation::Paste (const Handle(TDF_Attribute)& theInto,
+ const Handle(TDF_RelocationTable)& ) const
+{
+ Handle(TPrsStd_AISPresentation) anInto =
+ Handle(TPrsStd_AISPresentation)::DownCast(theInto);
- into->myAIS.Nullify();
+ anInto->Backup();
+ anInto->myAIS.Nullify();
}
+
//=======================================================================
//function : AfterAddition
//purpose : erase if displayed
//=======================================================================
void TPrsStd_AISPresentation::AfterAddition()
-{
+{
AfterResume();
}
+
//=======================================================================
//function : BeforeRemoval
//purpose : erase if displayed
//=======================================================================
void TPrsStd_AISPresentation::BeforeRemoval()
-{
- BeforeForget();
+{
+ BeforeForget();
}
+
//=======================================================================
//function : BeforeForget
//purpose : erase if displayed
//=======================================================================
void TPrsStd_AISPresentation::BeforeForget()
{
- if( !myAIS.IsNull() ) {
- AISErase(Standard_True); //Remove AISObject from context
+ if ( !myAIS.IsNull() )
+ { // Remove AISObject from context.
+ AISErase(Standard_True);
myAIS.Nullify();
}
}
//function : AfterResume
//purpose : display if displayed
//=======================================================================
-void TPrsStd_AISPresentation::AfterResume()
+void TPrsStd_AISPresentation::AfterResume()
{
AISUpdate();
- if( IsDisplayed() ) AISDisplay();
- else AISErase();
+
+ if ( IsDisplayed() )
+ AISDisplay();
+ else
+ AISErase();
}
+
//=======================================================================
//function : BeforeUndo
//purpose : le NamedShape associe doit etre present
//=======================================================================
-
Standard_Boolean TPrsStd_AISPresentation::BeforeUndo (const Handle(TDF_AttributeDelta)& AD,
- const Standard_Boolean )
+ const Standard_Boolean )
{
Handle(TPrsStd_AISPresentation) P;
- AD->Label().FindAttribute(TPrsStd_AISPresentation::GetID(), P);
+ AD->Label().FindAttribute(TPrsStd_AISPresentation::GetID(), P);
- if (AD->IsKind(STANDARD_TYPE(TDF_DeltaOnAddition))) {
- if( !P.IsNull() ) P->BeforeForget();
+ if (AD->IsKind(STANDARD_TYPE(TDF_DeltaOnAddition)))
+ {
+ if ( !P.IsNull() )
+ P->BeforeForget();
}
else if (AD->IsKind(STANDARD_TYPE(TDF_DefaultDeltaOnRemoval))) {
- }
- else if (AD->IsKind(STANDARD_TYPE(TDF_DefaultDeltaOnModification))) {
- if( !P.IsNull() ) P->BeforeForget();
- }
+ }
+ else if (AD->IsKind(STANDARD_TYPE(TDF_DefaultDeltaOnModification)))
+ {
+ if ( !P.IsNull() )
+ P->BeforeForget();
+ }
return Standard_True;
}
//function : AfterUndo
//purpose : le NamedShape associe doit etre present
//=======================================================================
-
Standard_Boolean TPrsStd_AISPresentation::AfterUndo (const Handle(TDF_AttributeDelta)& AD,
- const Standard_Boolean )
+ const Standard_Boolean )
{
Handle(TPrsStd_AISPresentation) P;
AD->Label().FindAttribute(TPrsStd_AISPresentation::GetID(), P);
- if (AD->IsKind(STANDARD_TYPE(TDF_DeltaOnAddition))) {
+ if (AD->IsKind(STANDARD_TYPE(TDF_DeltaOnAddition)))
+ {}
+ else if (AD->IsKind(STANDARD_TYPE(TDF_DefaultDeltaOnRemoval)))
+ {
+ if ( !P.IsNull() )
+ P->AfterAddition();
}
- else if (AD->IsKind(STANDARD_TYPE(TDF_DefaultDeltaOnRemoval))) {
- if( !P.IsNull() ) P->AfterAddition();
- }
- else if (AD->IsKind(STANDARD_TYPE(TDF_DefaultDeltaOnModification))) {
- if( !P.IsNull() ) P->AfterResume();
+ else if (AD->IsKind(STANDARD_TYPE(TDF_DefaultDeltaOnModification)))
+ {
+ if ( !P.IsNull() )
+ P->AfterResume();
}
return Standard_True;
}
-
//=======================================================================
//function : AISUpdate
//purpose :
//=======================================================================
-
-void TPrsStd_AISPresentation::AISUpdate ()
-{
+void TPrsStd_AISPresentation::AISUpdate()
+{
Backup();
- Handle(AIS_InteractiveContext) ctx;
- if(!Label().IsNull()) {
- Handle(TPrsStd_AISViewer) viewer;
- if( TPrsStd_AISViewer::Find(Label(), viewer) ) ctx = viewer->GetInteractiveContext();
-
- Handle(TPrsStd_Driver) driver;
- if (TPrsStd_DriverTable::Get()->FindDriver(GetDriverGUID(), driver)) {
- if (myAIS.IsNull()) { // build a new AIS
- Handle(AIS_InteractiveObject) newais;
- if (driver->Update (Label(), newais)) {
- myAIS = newais;
- newais->SetOwner(this);
- }
+ Handle(AIS_InteractiveContext) aContext;
+ if ( !Label().IsNull() )
+ {
+ aContext = getAISContext();
+
+ Handle(TPrsStd_Driver) aDriver;
+ if ( TPrsStd_DriverTable::Get()->FindDriver(GetDriverGUID(), aDriver) )
+ {
+ // Build a new AIS.
+ if ( myAIS.IsNull() )
+ {
+ Handle(AIS_InteractiveObject) aNewObj;
+ if ( aDriver->Update(Label(), aNewObj) )
+ {
+ myAIS = aNewObj;
+ aNewObj->SetOwner(this);
+ }
}
- else {
- Handle(AIS_InteractiveObject) theais = myAIS;
- if (driver->Update (Label(), theais)) {
- if (! (theais == myAIS)) {
- if(!ctx.IsNull()) ctx->Remove(myAIS);
- myAIS = theais; //Driver has built new AIS
- theais->SetOwner(this);
- }
- }
+ else
+ {
+ Handle(AIS_InteractiveObject) anObj = myAIS;
+ if ( aDriver->Update(Label(), anObj) )
+ if ( !(anObj == myAIS) )
+ {
+ if ( !aContext.IsNull() )
+ aContext->Remove(myAIS);
+
+ // Driver has built new AIS.
+ myAIS = anObj;
+ anObj->SetOwner(this);
+ }
}
}
}
else return;
-//Apply the visualization settings
- if( !myAIS.IsNull() ) {
+ // Apply the visualization settings.
+ if ( !myAIS.IsNull() )
+ {
+ if ( HasOwnColor() )
+ {
+ Quantity_NameOfColor aColor = Color();
+ if ( !(myAIS->HasColor()) || (myAIS->HasColor() && myAIS->Color() != aColor) )
+ if ( !aContext.IsNull() )
+ aContext->SetColor(myAIS, aColor, Standard_False);
+ else
+ myAIS->SetColor(aColor);
+ }
- if( hasOwnColor ) {
- if( !(myAIS->HasColor()) || (myAIS->HasColor() && myAIS->Color() != myColor) ) {
- if(!ctx.IsNull()) ctx->SetColor(myAIS, myColor, Standard_False);
- else myAIS->SetColor(myColor);
- }
- }
+ if ( HasOwnMaterial() )
+ {
+ Graphic3d_NameOfMaterial aMaterial = Material();
+ if ( !(myAIS->HasMaterial()) || (myAIS->HasMaterial() && myAIS->Material() != aMaterial) )
+ if ( !aContext.IsNull() )
+ aContext->SetMaterial(myAIS, aMaterial, Standard_False );
+ else
+ myAIS->SetMaterial(aMaterial);
+ }
- if( hasOwnMaterial ) {
- if( !(myAIS->HasMaterial()) || (myAIS->HasMaterial() && myAIS->Material() != myMaterial) ) {
- if(!ctx.IsNull()) ctx->SetMaterial(myAIS, myMaterial, Standard_False );
- else myAIS->SetMaterial(myMaterial);
- }
- }
-
- if( hasOwnTransparency ) {
- if( myAIS->Transparency() != myTransparency ) {
- if(!ctx.IsNull()) ctx->SetTransparency(myAIS, myTransparency, Standard_False);
- else myAIS->SetTransparency(myTransparency);
- }
+ if ( HasOwnTransparency() )
+ {
+ const Standard_Real aTransparency = Transparency();
+ if ( myAIS->Transparency() != aTransparency )
+ if( !aContext.IsNull() )
+ aContext->SetTransparency(myAIS, aTransparency, Standard_False);
+ else
+ myAIS->SetTransparency(aTransparency);
}
- if( hasOwnWidth ) {
- if( !(myAIS->HasWidth()) || (myAIS->HasWidth() && myAIS->Width() != myWidth) ) {
- if(!ctx.IsNull()) ctx->SetWidth(myAIS, myWidth, Standard_False);
- else myAIS->SetWidth(myWidth);
- }
+ if ( HasOwnWidth() )
+ {
+ const Standard_Real aWidth = Width();
+ if ( !(myAIS->HasWidth()) || (myAIS->HasWidth() && myAIS->Width() != aWidth) )
+ if ( !aContext.IsNull() )
+ aContext->SetWidth(myAIS, aWidth, Standard_False);
+ else
+ myAIS->SetWidth(aWidth);
}
- if( hasOwnMode) {
- if( myAIS->DisplayMode() != myMode ) {
- myAIS->SetDisplayMode(myMode);
- }
-
-
+ if ( HasOwnMode() )
+ {
+ const Standard_Integer aMode = Mode();
+ if ( myAIS->DisplayMode() != aMode )
+ myAIS->SetDisplayMode(aMode);
+ }
+
+ if ( HasOwnSelectionMode() )
+ {
+ const Standard_Integer aMode = SelectionMode();
+ if (myAIS->SelectionMode() != aMode )
+ myAIS->SetSelectionMode(aMode);
}
+ }
+
+ if ( !aContext.IsNull() && IsDisplayed() )
+ aContext->Redisplay(myAIS, Standard_False);
if (hasOwnSelectionMode) {
const Handle(AIS_InteractiveContext) aContext =
//function : AISDisplay
//purpose :
//=======================================================================
+void TPrsStd_AISPresentation::AISDisplay()
+{
+ if ( !Label().IsNull() )
+ {
+ Handle(AIS_InteractiveContext) aContext = getAISContext();
-void TPrsStd_AISPresentation::AISDisplay ()
-{
-
- if (!Label().IsNull()) {
- Handle(TPrsStd_AISViewer) viewer;
- if( !TPrsStd_AISViewer::Find(Label(), viewer) ) return;
- Handle(AIS_InteractiveContext) ctx = viewer->GetInteractiveContext();
- if( ctx.IsNull() ) return;
+ if ( aContext.IsNull() )
+ return;
- if (!myAIS.IsNull()) {
+ if ( !myAIS.IsNull() )
+ {
+ if ( !(myAIS->GetContext()).IsNull() && (myAIS->GetContext()) != aContext )
+ myAIS->GetContext()->Remove(myAIS);
- if( !(myAIS->GetContext()).IsNull() && (myAIS->GetContext()) != ctx ) myAIS->GetContext()->Remove(myAIS);
-
- if( isDisplayed && ctx->IsDisplayed(myAIS) ) return;
+ if ( IsDisplayed() && aContext->IsDisplayed(myAIS) )
+ return;
- ctx->Display(myAIS, Standard_False);
-
- if( ctx->IsDisplayed(myAIS) ) SetDisplayed(Standard_True);
+ aContext->Display(myAIS, Standard_False);
+
+ if ( aContext->IsDisplayed(myAIS) )
+ SetDisplayed(Standard_True);
}
}
}
//function : AISErase
//purpose :
//=======================================================================
+void TPrsStd_AISPresentation::AISErase(const Standard_Boolean theIsRemove)
+{
+ SetDisplayed(Standard_False);
+ Handle(AIS_InteractiveContext) aContext, anOwnContext;
-void TPrsStd_AISPresentation::AISErase (const Standard_Boolean remove)
-{
- SetDisplayed(Standard_False);
- Handle(AIS_InteractiveContext) ctx, ownctx;
-
- if ( !myAIS.IsNull() ) {
-
- if ( !Label().IsNull()) {
+ if ( !myAIS.IsNull() )
+ {
+ if ( !Label().IsNull() )
+ {
Handle(TPrsStd_AISViewer) viewer;
- if( !TPrsStd_AISViewer::Find(Label(), viewer) ) return;
- ownctx = myAIS->GetContext();
- ctx = viewer->GetInteractiveContext();
- if( remove ) {
- if( !ctx.IsNull() ) ctx->Remove (myAIS,Standard_False);
- if( !ownctx.IsNull() && ownctx != ctx ) ownctx->Remove (myAIS,Standard_False);
+ if( !TPrsStd_AISViewer::Find(Label(), viewer) )
+ return;
+ anOwnContext = myAIS->GetContext();
+ aContext = viewer->GetInteractiveContext();
+
+ if ( theIsRemove )
+ {
+ if ( !aContext.IsNull() )
+ aContext->Remove(myAIS, Standard_False);
+ if ( !anOwnContext.IsNull() && anOwnContext != aContext )
+ anOwnContext->Remove(myAIS, Standard_False);
+
myAIS->SetToUpdate();
}
- else {
- if( !ctx.IsNull() ) ctx->Erase (myAIS,Standard_False);
- if( !ownctx.IsNull() && ownctx != ctx ) ownctx->Erase (myAIS,Standard_False);
+ else
+ {
+ if ( !aContext.IsNull() )
+ aContext->Erase(myAIS, Standard_False);
+ if ( !anOwnContext.IsNull() && anOwnContext != aContext )
+ anOwnContext->Erase(myAIS, Standard_False);
}
}
- else {
- if( remove ) {
- if( !ownctx.IsNull() ) {
- ownctx->Remove (myAIS,Standard_False);
- myAIS->SetToUpdate();
+ else
+ {
+ if ( theIsRemove )
+ {
+ if ( !anOwnContext.IsNull() )
+ {
+ anOwnContext->Remove(myAIS, Standard_False);
+ myAIS->SetToUpdate();
+ }
}
- } else
- if( !ownctx.IsNull() ) ownctx->Erase (myAIS,Standard_False);
+ else
+ if( !anOwnContext.IsNull() )
+ anOwnContext->Erase(myAIS, Standard_False);
}
}
}
//=======================================================================
-//function :SetDisplayed
+//function : getAISContext
//purpose :
//=======================================================================
-void TPrsStd_AISPresentation::SetDisplayed(const Standard_Boolean B)
+Handle(AIS_InteractiveContext) TPrsStd_AISPresentation::getAISContext() const
{
- Backup();
- isDisplayed = B;
+ Handle(TPrsStd_AISViewer) aViewer;
+ if ( TPrsStd_AISViewer::Find(Label(), aViewer) )
+ return aViewer->GetInteractiveContext();
+
+ return Handle_AIS_InteractiveContext();
}
+
+//=======================================================================
+//function : getData
+//purpose :
+//=======================================================================
+Handle(TDataXtd_Presentation) TPrsStd_AISPresentation::getData() const
+{
+ return TDataXtd_Presentation::Set(this);
+}
//=======================================================================
Handle(TPrsStd_AISViewer) TPrsStd_AISViewer::New (const TDF_Label& acces,
- const Handle(V3d_Viewer)& viewer)
+ const Handle(V3d_Viewer)& viewer)
{
Handle(TPrsStd_AISViewer) V;
if (acces.Root().FindAttribute(TPrsStd_AISViewer::GetID(),V)) {
//purpose :
//=======================================================================
Handle(TPrsStd_AISViewer) TPrsStd_AISViewer::New (const TDF_Label& acces,
- const Handle(AIS_InteractiveContext)& IC)
+ const Handle(AIS_InteractiveContext)& IC)
{
Handle(TPrsStd_AISViewer) V;
if (acces.Root().FindAttribute(TPrsStd_AISViewer::GetID(),V)) {
//purpose :
//=======================================================================
Standard_Boolean TPrsStd_AISViewer::Find (const TDF_Label& acces,
- Handle(TPrsStd_AISViewer)& V)
+ Handle(TPrsStd_AISViewer)& V)
{
return (acces.Root().FindAttribute(TPrsStd_AISViewer::GetID(),V));
}
//purpose :
//=======================================================================
Standard_Boolean TPrsStd_AISViewer::Find (const TDF_Label& acces,
- Handle(AIS_InteractiveContext)& IC)
+ Handle(AIS_InteractiveContext)& IC)
{
Handle(TPrsStd_AISViewer) V;
if (acces.Root().FindAttribute(TPrsStd_AISViewer::GetID(),V)) {
//=======================================================================
Standard_Boolean TPrsStd_AISViewer::Find (const TDF_Label& acces,
- Handle(V3d_Viewer)& VIEW)
+ Handle(V3d_Viewer)& VIEW)
{
Handle(TPrsStd_AISViewer) V;
if (acces.Root().FindAttribute(TPrsStd_AISViewer::GetID(),V)) {
void TPrsStd_AISViewer::Update () const
{
- myInteractiveContext->UpdateCurrentViewer();
+ myInteractiveContext->UpdateCurrentViewer();
}
-
+
//=======================================================================
//function : SetInteractiveContext
//purpose :
//=======================================================================
void TPrsStd_AISViewer::Paste (const Handle(TDF_Attribute)&,
- const Handle(TDF_RelocationTable)&) const
+ const Handle(TDF_RelocationTable)&) const
{
}
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)
{
#include <XmlMDocStd.hxx>
#include <XmlMFunction.hxx>
#include <XmlMNaming.hxx>
-#include <XmlMPrsStd.hxx>
#include <locale.h>
#include <time.h>
XmlMNaming ::AddDrivers (aTable, theMessageDriver);
XmlMFunction ::AddDrivers (aTable, theMessageDriver);
XmlMDocStd ::AddDrivers (aTable, theMessageDriver);
- XmlMPrsStd ::AddDrivers (aTable, theMessageDriver);
//
return aTable;
}
#include <XmlObjMgt_Document.hxx>
#include <XmlObjMgt_RRelocationTable.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(myDevice);
+ if ( !aFile.IsNull() )
+ {
+ TCollection_AsciiString aPath( aFile->Path() );
+ aRes = aParser.parse( aPath.ToCString() );
+ }
+ else if ( !myDevice.IsNull() && myDevice->CanRead() )
+ {
+ if ( myDevice->Open( Storage_VSRead ) == Storage_VSOk )
+ {
+ Standard_Size aSize = 8000;
+ char* aBuf = (char*)malloc( aSize );
+ std::string aStr;
+ while ( !myDevice->IsEnd() )
+ {
+ Standard_Size aNum = myDevice->Read( aBuf, aSize );
+ aStr.append( aBuf, aNum );
+ }
+ free( aBuf );
+
+ myDevice->Close();
+
+ Standard_SStream aStream( std::ios::in );
+ aStream.str( aStr );
+
+ aRes = aParser.parse( aStream );
+ }
+ else
+ myReaderStatus = PCDM_RS_OpenError;
+ }
+
+ 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;
-
- 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
+// 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
- 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;
//=======================================================================
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);
#include <XmlMDataXtd_PointDriver.hxx>
#include <XmlMDataXtd_ShapeDriver.hxx>
#include <XmlMDF_ADriverTable.hxx>
+#include <XmlMDataXtd_PositionDriver.hxx>
+#include <XmlMDataXtd_PresentationDriver.hxx>
static Standard_Integer myDocumentVersion = -1;
//=======================================================================
void XmlMDataXtd::AddDrivers (const Handle(XmlMDF_ADriverTable)& aDriverTable,
const Handle(CDM_MessageDriver)& anMsgDrv)
{
- aDriverTable-> AddDriver (new XmlMDataXtd_ShapeDriver (anMsgDrv));
- aDriverTable-> AddDriver (new XmlMDataXtd_PointDriver (anMsgDrv));
- aDriverTable-> AddDriver (new XmlMDataXtd_AxisDriver (anMsgDrv));
- aDriverTable-> AddDriver (new XmlMDataXtd_PlaneDriver (anMsgDrv));
- aDriverTable-> AddDriver (new XmlMDataXtd_GeometryDriver (anMsgDrv));
- aDriverTable-> AddDriver (new XmlMDataXtd_ConstraintDriver (anMsgDrv));
- aDriverTable-> AddDriver (new XmlMDataXtd_PlacementDriver (anMsgDrv));
- aDriverTable-> AddDriver (new XmlMDataXtd_PatternStdDriver (anMsgDrv));
+ aDriverTable->AddDriver(new XmlMDataXtd_ShapeDriver (anMsgDrv));
+ aDriverTable->AddDriver(new XmlMDataXtd_PointDriver (anMsgDrv));
+ aDriverTable->AddDriver(new XmlMDataXtd_AxisDriver (anMsgDrv));
+ aDriverTable->AddDriver(new XmlMDataXtd_PlaneDriver (anMsgDrv));
+ aDriverTable->AddDriver(new XmlMDataXtd_GeometryDriver (anMsgDrv));
+ aDriverTable->AddDriver(new XmlMDataXtd_ConstraintDriver (anMsgDrv));
+ aDriverTable->AddDriver(new XmlMDataXtd_PlacementDriver (anMsgDrv));
+ aDriverTable->AddDriver(new XmlMDataXtd_PatternStdDriver (anMsgDrv));
+ aDriverTable->AddDriver(new XmlMDataXtd_PositionDriver (anMsgDrv));
+ aDriverTable->AddDriver(new XmlMDataXtd_PresentationDriver (anMsgDrv));
}
//=======================================================================
--- /dev/null
+// Created on: 2001-09-04
+// Created by: Julia DOROVSKIKH
+// Copyright (c) 2001-2014 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <XmlMDataXtd_PositionDriver.ixx>
+
+#include <CDM_MessageDriver.hxx>
+#include <gp_XYZ.hxx>
+#include <Standard_Type.hxx>
+#include <TDataXtd_Position.hxx>
+#include <TDF_Attribute.hxx>
+#include <XmlMPrsStd_PositionDriver.hxx>
+#include <XmlObjMgt.hxx>
+#include <XmlObjMgt_Persistent.hxx>
+
+#include <stdio.h>
+//=======================================================================
+//function : XmlMDataXtd_PositionDriver
+//purpose : Constructor
+//=======================================================================
+XmlMDataXtd_PositionDriver::XmlMDataXtd_PositionDriver
+ (const Handle(CDM_MessageDriver)& theMsgDriver)
+: XmlMDF_ADriver (theMsgDriver, NULL)
+{}
+
+//=======================================================================
+//function : NewEmpty
+//purpose :
+//=======================================================================
+Handle(TDF_Attribute) XmlMDataXtd_PositionDriver::NewEmpty() const
+{
+ return (new TDataXtd_Position());
+}
+
+//=======================================================================
+//function : Paste
+//purpose : persistent -> transient (retrieve)
+//=======================================================================
+Standard_Boolean XmlMDataXtd_PositionDriver::Paste
+ (const XmlObjMgt_Persistent& theSource,
+ const Handle(TDF_Attribute)& theTarget,
+ XmlObjMgt_RRelocationTable& ) const
+{
+ Handle(TDataXtd_Position) aTPos = Handle(TDataXtd_Position)::DownCast(theTarget);
+
+ // position
+ XmlObjMgt_DOMString aPosStr = XmlObjMgt::GetStringValue(theSource.Element());
+ if (aPosStr == NULL)
+ {
+ WriteMessage ("Cannot retrieve position string from element");
+ return Standard_False;
+ }
+
+ gp_Pnt aPos;
+ Standard_Real aValue;
+ Standard_CString aValueStr = Standard_CString(aPosStr.GetString());
+
+ // X
+ if (!XmlObjMgt::GetReal(aValueStr, aValue))
+ {
+ TCollection_ExtendedString aMessageString =
+ TCollection_ExtendedString
+ ("Cannot retrieve X coordinate for TDataXtd_Position attribute as \"")
+ + aValueStr + "\"";
+ WriteMessage (aMessageString);
+ return Standard_False;
+ }
+ aPos.SetX(aValue);
+
+ // Y
+ if (!XmlObjMgt::GetReal(aValueStr, aValue))
+ {
+ TCollection_ExtendedString aMessageString =
+ TCollection_ExtendedString
+ ("Cannot retrieve Y coordinate for TDataXtd_Position attribute as \"")
+ + aValueStr + "\"";
+ WriteMessage (aMessageString);
+ return Standard_False;
+ }
+ aPos.SetY(aValue);
+
+ // Z
+ if (!XmlObjMgt::GetReal(aValueStr, aValue))
+ {
+ TCollection_ExtendedString aMessageString =
+ TCollection_ExtendedString
+ ("Cannot retrieve Z coordinate for TDataXtd_Position attribute as \"")
+ + aValueStr + "\"";
+ WriteMessage (aMessageString);
+ return Standard_False;
+ }
+ aPos.SetZ(aValue);
+
+ aTPos->SetPosition(aPos);
+
+ return Standard_True;
+}
+
+//=======================================================================
+//function : Paste
+//purpose : transient -> persistent (store)
+//=======================================================================
+void XmlMDataXtd_PositionDriver::Paste
+ (const Handle(TDF_Attribute)& theSource,
+ XmlObjMgt_Persistent& theTarget,
+ XmlObjMgt_SRelocationTable& ) const
+{
+ Handle(TDataXtd_Position) aTPos = Handle(TDataXtd_Position)::DownCast(theSource);
+ if (!aTPos.IsNull())
+ {
+ gp_Pnt aPos = aTPos->GetPosition();
+ char buf [64];
+ Sprintf (buf, "%.17g %.17g %.17g", aPos.X(), aPos.Y(), aPos.Z());
+ XmlObjMgt::SetStringValue(theTarget.Element(), buf);
+ }
+}
--- /dev/null
+// Created on: 2001-09-04
+// Created by: Julia DOROVSKIKH
+// Copyright (c) 2001-2014 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <XmlMDataXtd_PresentationDriver.ixx>
+
+#include <CDM_MessageDriver.hxx>
+#include <Standard_Type.hxx>
+#include <TDF_Attribute.hxx>
+#include <TPrsStd_AISPresentation.hxx>
+#include <XmlMPrsStd_AISPresentationDriver.hxx>
+#include <XmlObjMgt.hxx>
+#include <XmlObjMgt_Persistent.hxx>
+
+#include <TDataXtd_Presentation.hxx>
+
+IMPLEMENT_DOMSTRING (GuidString, "guid")
+IMPLEMENT_DOMSTRING (IsDisplayedString, "isdisplayed")
+IMPLEMENT_DOMSTRING (ColorString, "color")
+IMPLEMENT_DOMSTRING (MaterialString, "material")
+IMPLEMENT_DOMSTRING (TransparencyString,"transparency")
+IMPLEMENT_DOMSTRING (WidthString, "width")
+IMPLEMENT_DOMSTRING (ModeString, "mode")
+
+IMPLEMENT_DOMSTRING (DisplayedString, "true")
+
+//=======================================================================
+//function : XmlMDataXtd_PresentationDriver
+//purpose : Constructor
+//=======================================================================
+XmlMDataXtd_PresentationDriver::XmlMDataXtd_PresentationDriver
+ (const Handle(CDM_MessageDriver)& theMsgDriver)
+ : XmlMDF_ADriver (theMsgDriver, NULL)
+{}
+
+//=======================================================================
+//function : NewEmpty
+//purpose :
+//=======================================================================
+Handle(TDF_Attribute) XmlMDataXtd_PresentationDriver::NewEmpty() const
+{
+ return (new TDataXtd_Presentation());
+}
+
+//=======================================================================
+//function : Paste
+//purpose : persistent -> transient (retrieve)
+//=======================================================================
+Standard_Boolean XmlMDataXtd_PresentationDriver::Paste
+ (const XmlObjMgt_Persistent& theSource,
+ const Handle(TDF_Attribute)& theTarget,
+ XmlObjMgt_RRelocationTable& ) const
+{
+ TCollection_ExtendedString aMessageString;
+ XmlObjMgt_DOMString aDOMStr;
+
+ Handle(TDataXtd_Presentation) aTPrs =
+ Handle(TDataXtd_Presentation)::DownCast(theTarget);
+ const XmlObjMgt_Element& anElem = theSource;
+
+ //convert attribute value into GUID
+ aDOMStr = anElem.getAttribute(::GuidString());
+ if (aDOMStr == NULL)
+ {
+ WriteMessage("Cannot retrieve guid string from attribute");
+ return Standard_False;
+ }
+ Standard_CString aGuidStr = (Standard_CString) aDOMStr.GetString();
+ aTPrs->SetDriverGUID(aGuidStr);
+
+ // is displayed
+ aDOMStr = anElem.getAttribute(::IsDisplayedString());
+ aTPrs->SetDisplayed(aDOMStr != NULL);
+
+ Standard_Integer anIValue;
+
+ // color
+ aDOMStr = anElem.getAttribute(::ColorString());
+ if (aDOMStr != NULL)
+ {
+ if (!aDOMStr.GetInteger(anIValue))
+ {
+ aMessageString = TCollection_ExtendedString
+ ("Cannot retrieve Integer value from \"") + aDOMStr + "\"";
+ WriteMessage (aMessageString);
+ return Standard_False;
+ }
+ aTPrs->SetColor(anIValue);
+ }
+ else
+ {
+ aTPrs->UnsetColor();
+ }
+
+ // material
+ aDOMStr = anElem.getAttribute(::MaterialString());
+ if (aDOMStr != NULL)
+ {
+ if (!aDOMStr.GetInteger(anIValue))
+ {
+ aMessageString = TCollection_ExtendedString
+ ("Cannot retrieve Integer value from \"") + aDOMStr + "\"";
+ WriteMessage (aMessageString);
+ return Standard_False;
+ }
+ aTPrs->SetMaterial(anIValue);
+ }
+ else
+ {
+ aTPrs->UnsetMaterial();
+ }
+
+ Standard_Real aValue;
+
+ // transparency
+ aDOMStr = anElem.getAttribute(::TransparencyString());
+ if (aDOMStr != NULL)
+ {
+ if (!XmlObjMgt::GetReal(aDOMStr, aValue))
+ {
+ aMessageString = TCollection_ExtendedString
+ ("Cannot retrieve Real value from \"") + aDOMStr + "\"";
+ WriteMessage (aMessageString);
+ return Standard_False;
+ }
+ aTPrs->SetTransparency(aValue);
+ }
+ else
+ {
+ aTPrs->UnsetTransparency();
+ }
+
+ // width
+ aDOMStr = anElem.getAttribute(::WidthString());
+ if (aDOMStr != NULL)
+ {
+ if (!XmlObjMgt::GetReal(aDOMStr, aValue))
+ {
+ aMessageString = TCollection_ExtendedString
+ ("Cannot retrieve Real value from \"") + aDOMStr + "\"";
+ WriteMessage (aMessageString);
+ return Standard_False;
+ }
+ aTPrs->SetWidth(aValue);
+ }
+ else
+ {
+ aTPrs->UnsetWidth();
+ }
+
+ // mode
+ aDOMStr = anElem.getAttribute(::ModeString());
+ if (aDOMStr != NULL)
+ {
+ if (!aDOMStr.GetInteger(anIValue))
+ {
+ aMessageString = TCollection_ExtendedString
+ ("Cannot retrieve Integer value from \"") + aDOMStr + "\"";
+ WriteMessage (aMessageString);
+ return Standard_False;
+ }
+ aTPrs->SetMode(anIValue);
+ }
+ else
+ {
+ aTPrs->UnsetMode();
+ }
+
+ return Standard_True;
+}
+
+//=======================================================================
+//function : Paste
+//purpose : transient -> persistent (store)
+//=======================================================================
+void XmlMDataXtd_PresentationDriver::Paste
+ (const Handle(TDF_Attribute)& theSource,
+ XmlObjMgt_Persistent& theTarget,
+ XmlObjMgt_SRelocationTable&) const
+{
+ Handle(TDataXtd_Presentation) aTPrs =
+ Handle(TDataXtd_Presentation)::DownCast(theSource);
+ if (aTPrs.IsNull()) return;
+
+ //convert GUID into attribute value
+ Standard_Character aGuidStr [40];
+ Standard_PCharacter pGuidStr;
+ pGuidStr=aGuidStr;
+ aTPrs->GetDriverGUID().ToCString (pGuidStr);
+ theTarget.Element().setAttribute(::GuidString(), aGuidStr);
+
+ // is displayed
+ if (aTPrs->IsDisplayed())
+ theTarget.Element().setAttribute(::IsDisplayedString(), ::DisplayedString());
+
+ Standard_Integer aNb;
+
+ // color
+ if (aTPrs->IsHasOwnColor())
+ {
+ aNb = aTPrs->Color();
+ theTarget.Element().setAttribute(::ColorString(), aNb);
+ }
+
+ // material
+ if (aTPrs->IsHasOwnMaterial())
+ {
+ aNb = (Standard_Integer)(aTPrs->Material());
+ theTarget.Element().setAttribute(::MaterialString(), aNb);
+ }
+
+ // transparency
+ if (aTPrs->IsHasOwnTransparency())
+ {
+ TCollection_AsciiString aRNbStr (aTPrs->Transparency());
+ theTarget.Element().setAttribute(::TransparencyString(), aRNbStr.ToCString());
+ }
+
+ // width
+ if (aTPrs->IsHasOwnWidth())
+ {
+ TCollection_AsciiString aRNbStr (aTPrs->Width());
+ theTarget.Element().setAttribute(::WidthString(), aRNbStr.ToCString());
+ }
+
+#ifdef OCC6010
+ // mode
+ if (aTPrs->IsHasOwnMode())
+ {
+ aNb = aTPrs->Mode();
+ theTarget.Element().setAttribute(::ModeString(), aNb);
+ }
+#endif
+}
+++ /dev/null
-// Created on: 2001-09-04
-// Created by: Julia DOROVSKIKH
-// Copyright (c) 2001-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-
-#include <CDM_MessageDriver.hxx>
-#include <Standard_Type.hxx>
-#include <TDF_Attribute.hxx>
-#include <TPrsStd_AISPresentation.hxx>
-#include <XmlMPrsStd_AISPresentationDriver.hxx>
-#include <XmlObjMgt.hxx>
-#include <XmlObjMgt_Persistent.hxx>
-
-IMPLEMENT_DOMSTRING (GuidString, "guid")
-IMPLEMENT_DOMSTRING (IsDisplayedString, "isdisplayed")
-IMPLEMENT_DOMSTRING (ColorString, "color")
-IMPLEMENT_DOMSTRING (MaterialString, "material")
-IMPLEMENT_DOMSTRING (TransparencyString,"transparency")
-IMPLEMENT_DOMSTRING (WidthString, "width")
-IMPLEMENT_DOMSTRING (ModeString, "mode")
-
-IMPLEMENT_DOMSTRING (DisplayedString, "true")
-
-//=======================================================================
-//function : XmlMPrsStd_AISPresentationDriver
-//purpose : Constructor
-//=======================================================================
-XmlMPrsStd_AISPresentationDriver::XmlMPrsStd_AISPresentationDriver
- (const Handle(CDM_MessageDriver)& theMsgDriver)
- : XmlMDF_ADriver (theMsgDriver, NULL)
-{}
-
-//=======================================================================
-//function : NewEmpty
-//purpose :
-//=======================================================================
-Handle(TDF_Attribute) XmlMPrsStd_AISPresentationDriver::NewEmpty() const
-{
- return (new TPrsStd_AISPresentation());
-}
-
-//=======================================================================
-//function : Paste
-//purpose : persistent -> transient (retrieve)
-//=======================================================================
-Standard_Boolean XmlMPrsStd_AISPresentationDriver::Paste
- (const XmlObjMgt_Persistent& theSource,
- const Handle(TDF_Attribute)& theTarget,
- XmlObjMgt_RRelocationTable& ) const
-{
- TCollection_ExtendedString aMessageString;
- XmlObjMgt_DOMString aDOMStr;
-
- Handle(TPrsStd_AISPresentation) aTPrs =
- Handle(TPrsStd_AISPresentation)::DownCast(theTarget);
- const XmlObjMgt_Element& anElem = theSource;
-
- //convert attribute value into GUID
- aDOMStr = anElem.getAttribute(::GuidString());
- if (aDOMStr == NULL)
- {
- WriteMessage("Cannot retrieve guid string from attribute");
- return Standard_False;
- }
- Standard_CString aGuidStr = (Standard_CString) aDOMStr.GetString();
- aTPrs->SetDriverGUID(aGuidStr);
-
- // is displayed
- aDOMStr = anElem.getAttribute(::IsDisplayedString());
- aTPrs->SetDisplayed(aDOMStr != NULL);
-
- Standard_Integer anIValue;
-
- // color
- aDOMStr = anElem.getAttribute(::ColorString());
- if (aDOMStr != NULL)
- {
- if (!aDOMStr.GetInteger(anIValue))
- {
- aMessageString = TCollection_ExtendedString
- ("Cannot retrieve Integer value from \"") + aDOMStr + "\"";
- WriteMessage (aMessageString);
- return Standard_False;
- }
- aTPrs->SetColor((Quantity_NameOfColor)anIValue);
- }
- else
- {
- aTPrs->UnsetColor();
- }
-
- // material
- aDOMStr = anElem.getAttribute(::MaterialString());
- if (aDOMStr != NULL)
- {
- if (!aDOMStr.GetInteger(anIValue))
- {
- aMessageString = TCollection_ExtendedString
- ("Cannot retrieve Integer value from \"") + aDOMStr + "\"";
- WriteMessage (aMessageString);
- return Standard_False;
- }
- aTPrs->SetMaterial((Graphic3d_NameOfMaterial)anIValue);
- }
- else
- {
- aTPrs->UnsetMaterial();
- }
-
- Standard_Real aValue;
-
- // transparency
- aDOMStr = anElem.getAttribute(::TransparencyString());
- if (aDOMStr != NULL)
- {
- if (!XmlObjMgt::GetReal(aDOMStr, aValue))
- {
- aMessageString = TCollection_ExtendedString
- ("Cannot retrieve Real value from \"") + aDOMStr + "\"";
- WriteMessage (aMessageString);
- return Standard_False;
- }
- aTPrs->SetTransparency(aValue);
- }
- else
- {
- aTPrs->UnsetTransparency();
- }
-
- // width
- aDOMStr = anElem.getAttribute(::WidthString());
- if (aDOMStr != NULL)
- {
- if (!XmlObjMgt::GetReal(aDOMStr, aValue))
- {
- aMessageString = TCollection_ExtendedString
- ("Cannot retrieve Real value from \"") + aDOMStr + "\"";
- WriteMessage (aMessageString);
- return Standard_False;
- }
- aTPrs->SetWidth(aValue);
- }
- else
- {
- aTPrs->UnsetWidth();
- }
-
- // mode
- aDOMStr = anElem.getAttribute(::ModeString());
- if (aDOMStr != NULL)
- {
- if (!aDOMStr.GetInteger(anIValue))
- {
- aMessageString = TCollection_ExtendedString
- ("Cannot retrieve Integer value from \"") + aDOMStr + "\"";
- WriteMessage (aMessageString);
- return Standard_False;
- }
- aTPrs->SetMode(anIValue);
- }
- else
- {
- aTPrs->UnsetMode();
- }
-
- return Standard_True;
-}
-
-//=======================================================================
-//function : Paste
-//purpose : transient -> persistent (store)
-//=======================================================================
-void XmlMPrsStd_AISPresentationDriver::Paste
- (const Handle(TDF_Attribute)& theSource,
- XmlObjMgt_Persistent& theTarget,
- XmlObjMgt_SRelocationTable& ) const
-{
- Handle(TPrsStd_AISPresentation) aTPrs =
- Handle(TPrsStd_AISPresentation)::DownCast(theSource);
- if (aTPrs.IsNull()) return;
-
- //convert GUID into attribute value
- Standard_Character aGuidStr [40];
- Standard_PCharacter pGuidStr;
- pGuidStr=aGuidStr;
- aTPrs->GetDriverGUID().ToCString (pGuidStr);
- theTarget.Element().setAttribute(::GuidString(), aGuidStr);
-
- // is displayed
- if (aTPrs->IsDisplayed())
- theTarget.Element().setAttribute(::IsDisplayedString(), ::DisplayedString());
-
- Standard_Integer aNb;
-
- // color
- if (aTPrs->HasOwnColor())
- {
- aNb = (Standard_Integer)(aTPrs->Color());
- theTarget.Element().setAttribute(::ColorString(), aNb);
- }
-
- // material
- if (aTPrs->HasOwnMaterial())
- {
- aNb = (Standard_Integer)(aTPrs->Material());
- theTarget.Element().setAttribute(::MaterialString(), aNb);
- }
-
- // transparency
- if (aTPrs->HasOwnTransparency())
- {
- TCollection_AsciiString aRNbStr (aTPrs->Transparency());
- theTarget.Element().setAttribute(::TransparencyString(), aRNbStr.ToCString());
- }
-
- // width
- if (aTPrs->HasOwnWidth())
- {
- TCollection_AsciiString aRNbStr (aTPrs->Width());
- theTarget.Element().setAttribute(::WidthString(), aRNbStr.ToCString());
- }
-
-#ifdef OCC6010
- // mode
- if (aTPrs->HasOwnMode())
- {
- aNb = aTPrs->Mode();
- theTarget.Element().setAttribute(::ModeString(), aNb);
- }
-#endif
-}
+++ /dev/null
-// Created on: 2001-09-04
-// Created by: Julia DOROVSKIKH
-// Copyright (c) 2001-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-
-#include <CDM_MessageDriver.hxx>
-#include <gp_XYZ.hxx>
-#include <Standard_Type.hxx>
-#include <TDataXtd_Position.hxx>
-#include <TDF_Attribute.hxx>
-#include <XmlMPrsStd_PositionDriver.hxx>
-#include <XmlObjMgt.hxx>
-#include <XmlObjMgt_Persistent.hxx>
-
-#include <stdio.h>
-//=======================================================================
-//function : XmlMPrsStd_PositionDriver
-//purpose : Constructor
-//=======================================================================
-XmlMPrsStd_PositionDriver::XmlMPrsStd_PositionDriver
- (const Handle(CDM_MessageDriver)& theMsgDriver)
- : XmlMDF_ADriver (theMsgDriver, NULL)
-{}
-
-//=======================================================================
-//function : NewEmpty
-//purpose :
-//=======================================================================
-Handle(TDF_Attribute) XmlMPrsStd_PositionDriver::NewEmpty() const
-{
- return (new TDataXtd_Position());
-}
-
-//=======================================================================
-//function : Paste
-//purpose : persistent -> transient (retrieve)
-//=======================================================================
-Standard_Boolean XmlMPrsStd_PositionDriver::Paste
- (const XmlObjMgt_Persistent& theSource,
- const Handle(TDF_Attribute)& theTarget,
- XmlObjMgt_RRelocationTable& ) const
-{
- Handle(TDataXtd_Position) aTPos = Handle(TDataXtd_Position)::DownCast(theTarget);
-
- // position
- XmlObjMgt_DOMString aPosStr = XmlObjMgt::GetStringValue(theSource.Element());
- if (aPosStr == NULL)
- {
- WriteMessage ("Cannot retrieve position string from element");
- return Standard_False;
- }
-
- gp_Pnt aPos;
- Standard_Real aValue;
- Standard_CString aValueStr = Standard_CString(aPosStr.GetString());
-
- // X
- if (!XmlObjMgt::GetReal(aValueStr, aValue))
- {
- TCollection_ExtendedString aMessageString =
- TCollection_ExtendedString
- ("Cannot retrieve X coordinate for TDataXtd_Position attribute as \"")
- + aValueStr + "\"";
- WriteMessage (aMessageString);
- return Standard_False;
- }
- aPos.SetX(aValue);
-
- // Y
- if (!XmlObjMgt::GetReal(aValueStr, aValue))
- {
- TCollection_ExtendedString aMessageString =
- TCollection_ExtendedString
- ("Cannot retrieve Y coordinate for TDataXtd_Position attribute as \"")
- + aValueStr + "\"";
- WriteMessage (aMessageString);
- return Standard_False;
- }
- aPos.SetY(aValue);
-
- // Z
- if (!XmlObjMgt::GetReal(aValueStr, aValue))
- {
- TCollection_ExtendedString aMessageString =
- TCollection_ExtendedString
- ("Cannot retrieve Z coordinate for TDataXtd_Position attribute as \"")
- + aValueStr + "\"";
- WriteMessage (aMessageString);
- return Standard_False;
- }
- aPos.SetZ(aValue);
-
- aTPos->SetPosition(aPos);
-
- return Standard_True;
-}
-
-//=======================================================================
-//function : Paste
-//purpose : transient -> persistent (store)
-//=======================================================================
-void XmlMPrsStd_PositionDriver::Paste
- (const Handle(TDF_Attribute)& theSource,
- XmlObjMgt_Persistent& theTarget,
- XmlObjMgt_SRelocationTable& ) const
-{
- Handle(TDataXtd_Position) aTPos = Handle(TDataXtd_Position)::DownCast(theSource);
- if (!aTPos.IsNull())
- {
- gp_Pnt aPos = aTPos->GetPosition();
- char buf [64];
- Sprintf (buf, "%.17g %.17g %.17g", aPos.X(), aPos.Y(), aPos.Z());
- XmlObjMgt::SetStringValue(theTarget.Element(), buf);
- }
-}
projects / occt-copy.git / commitdiff